public PointColore(V3 spatialLocator, V3 normale, Couleur couleur, Formes proprio) { SpatialLocator = spatialLocator; Couleur = couleur; this.normale = normale; this.proprietaire = proprio; }
/*public override void Draw(Couleur C_ambiant, Lumiere L, V3 camera) { //float cosln; //Couleur final_ambiant, final_diff, final_spec; //Couleur C_lampe = L.getClampe(); //L1 = (new V3(0.0f, 1.0f, 0.0f)) ^ (L1 ^ (new V3(0.0f, 1.0f, 0.0f))); //L2 = (new V3(0.0f, 1.0f, 0.0f)) ^ (L2 ^ (new V3(0.0f, 1.0f, 0.0f))); // 4 sommets : origin, origin + L1, origin + L2, origin + L1 + L2 for (V3 u = new V3(0.0f, 0.0f, 0.0f); (u.x < Math.Abs(L1.x) || L1.x == 0) && (u.y < Math.Abs(L1.y) || L1.y == 0) && (u.z < Math.Abs(L1.z) || L1.z == 0); u += (L1 * (float)pas)) { for (V3 v = new V3(0.0f, 0.0f, 0.0f); (v.x < Math.Abs(L2.x) || L2.x == 0) && (v.y < Math.Abs(L2.y) || L2.y == 0) && (v.z < Math.Abs(L2.z) || L2.z == 0); v += (L2 * (float)pas)) { float dhdu, dhdv; float x = u.x + v.x + origin.x; float y = u.y + v.y + origin.y; float z = u.z + v.z + origin.z; int x_ecran = (int)x; int z_ecran = (int)z; Couleur C_obj = T.LireCouleur((float)(u.Norm() / L1.Norm()), (float)(v.Norm() / L2.Norm())); //final_ambiant = C_obj * C_ambiant; if (ZBuffer.test(y, x_ecran, z_ecran)) { // BUMP MAP V3 Np = N; if (T_bump != null) { V3 dmdu = L1; V3 dmdv = L2; this.T_bump.Bump((float)(u.Norm() / L1.Norm()), (float)(v.Norm() / L2.Norm()), out dhdu, out dhdv); Np = N + bump_coeff * ((dmdu ^ (N * dhdv)) + ((N * dhdu) ^ dmdv)); } // FIN BUMP MAP V3 O = new V3(x, y, z); O = camera - O; //Couleur finalColor = computeLights(C_obj, C_ambiant, Np, O, L, k); //BitmapEcran.DrawPixel(x_ecran, z_ecran, finalColor); } } } }*/ public override Couleur DrawPoint(Couleur C_ambiant, List<Lampe> lampList, V3 camera, V3 R, bool[] occs) { V3 N = this.N; N.Normalize(); V3 O = camera - R; // TEXTURE V3 AI = R - this.origin; float a = (this.L1 * AI) / (this.L1.Norme2()); float b = ((AI - a * this.L1).Norm()) / (this.L2.Norm()); Couleur C_obj = T.LireCouleur(a, 1 - b); // BUMP MAP if (T_bump != null) { float dhdu, dhdv; V3 dmdu = L1; V3 dmdv = L2; this.T_bump.Bump(a, b, out dhdu, out dhdv); N = N + bump_coeff * ((dmdu ^ (N * dhdv)) + ((N * dhdu) ^ dmdv)); } // FIN BUMP MAP Point I = new Point(C_obj, C_ambiant, N, O, this.k); Couleur finalColor = computeLights(I, lampList, occs); return finalColor; }
public static Couleur Color_Specular(Light_Source light, V3 P, V3 N, int k) { V3 L = -light.direction; if (light.point_light) { L = light.position - P; L.Normalize(); } float cos_alpha = (N * L); if (light.point_light && cos_alpha < 0) { cos_alpha = -cos_alpha; } V3 R = (N * 2 * cos_alpha) - L; R.Normalize(); V3 D = Elements.camera_position - P; D.Normalize(); float f = (R * D); if (f < 0) { f = 0; // if cos is negative there won't be any specularity } Couleur c = (float)Math.Pow(f, k) * (light.color); return(c); }
public Light_Source(V3 direction, Couleur color) { ; this.direction = direction; this.direction.Normalize(); this.color = color; }
public static Couleur Color_Diffused(Light_Source light, Couleur px_color, V3 P, V3 N) { V3 L = -light.direction; if (light.point_light) { L = light.position - P; //L = P-light.position; L.Normalize(); } float cos_theta = N * L; if (cos_theta < 0) { cos_theta = 0; } float on_shadow = getShadow(P, light); Couleur c = cos_theta * (light.color * px_color); return(c * on_shadow); }
private Couleur processLumiere(V3 rayon, PointColore point) { V3 normalPoint = point.GetNormale(); //V3 directionOculaire = new V3(camera - point.GetLoc()); //directionOculaire.Normalize(); Couleur lumiereTotale = new Couleur(0, 0, 0); lumiereTotale += point.GetCouleur() * couleurAmbiance * intensiteAmbiance; foreach (Lumiere lampe in lampes) { if (!(lampe.isOccluded(point, objets))) { V3 directionLampeNormale = new V3(lampe.GetDirection(point.GetLoc())); directionLampeNormale.Normalize(); float cosAlpha = normalPoint * directionLampeNormale; float facteurDiffus = Math.Max(0, cosAlpha); lumiereTotale += point.GetCouleur() * lampe.GetCouleur() * facteurDiffus * lampe.GetIntensite(point.GetLoc()); V3 reflet = (2 * cosAlpha * normalPoint) - directionLampeNormale; float produitSpeculaire = Math.Max(0, (reflet * (-rayon)) / (reflet.Norm() * rayon.Norm())); float facteurSpeculaire = (float)Math.Pow(produitSpeculaire, puissanceSpeculaire); lumiereTotale += lampe.GetCouleur() * lampe.GetIntensite(point.GetLoc()) * facteurSpeculaire; } } return(lumiereTotale); }
public Materiel(Couleur pcouleur, Texture ptextureBump, float pforceSpeculaire, float pforceBumping) { couleur = pcouleur; textureBump = ptextureBump; forceSpeculaire = pforceSpeculaire; forceBumping = pforceBumping; }
/* * getPixelColor adds all lights and "shadows" at each point P of the image */ public static Couleur getPixelColor(V3 P, Couleur c, V3 N, int object_index) { Couleur pixel_color = c; float decay = 1; pixel_color = Color_Ambient(c); foreach (Light_Source light in lights) { if (light.point_light) { Elements.objects_on_screen[object_index].intersection_RayObject(light.position, P - light.position, out V3 P1, out V3 N1, out float t); decay = (float)Math.PI / (float)(Math.Pow(t, 2)); if (decay > 1) { decay = 1; } } pixel_color += decay * Color_Diffused(light, c, P, N); decay = 1; if (Elements.objects_on_screen[object_index].is_spec) { // if the light creates a specular effect pixel_color += Color_Specular(light, P, N, 200); } } pixel_color.check(); return(pixel_color); }
public Sphere(float R, V3 center, Couleur c, int index) { this.R = R; Center = center; color = c; object_index = index; }
public static void Go() { int screen_w = BitmapEcran.GetWidth(), screen_h = BitmapEcran.GetHeight(); V3 camera_position = new V3(screen_w / 2, -400, screen_h / 2); /* Lights */ // Light sources V3 key_light_dir = new V3(-1, 1, -1); Couleur key_light_color = new Couleur(0.8f, 0.8f, 0.8f); //Lights.add_light(key_light_dir, key_light_color); V3 fill_light_dir = new V3(1, 1, -1); Couleur fill_light_color = new Couleur(0.5f, 0.5f, 0.5f); //Lights.add_light(fill_light_dir, fill_light_color); V3 point_light_position = new V3(screen_w * 0.5f, Scene.max_y_position / 2, screen_h - 43); Couleur point_light_color = new Couleur(1f, 1f, 1f); Lights.add_light(point_light_position, point_light_color, true); /* Objects */ // list of all objects appearing on screen List <Object> objects_on_screen = new List <Object>(); Scene.Room(ref objects_on_screen); Scene.Boxes(ref objects_on_screen); Scene.Mirror(ref objects_on_screen); Scene.Bed(ref objects_on_screen); Scene.Ball(ref objects_on_screen); Scene.Shelf(ref objects_on_screen); // Creates and initialize Z_buffer/ray casting activate + determines the camera position Elements.inicialize_Elements(camera_position, true, objects_on_screen); // Plot all objects on the screen with the ray casting method /*for (int i = 0; i < screen_w; i++) * { * for(int j = 0; j < screen_h; j++) * { * Elements.RayCasting(new V3(i, 0, j), objects_on_screen); * } * }*/ V3 ray_direction; Couleur c; for (int i = 0; i < screen_w; i++) { for (int j = 0; j < screen_h; j++) { ray_direction = new V3(i, 0, j) - Elements.camera_position; ray_direction.Normalize(); c = Elements.RayTracer(Elements.camera_position, ray_direction, 0); BitmapEcran.DrawPixel(i, j, c); } } }
/* Prints the pixel of point P on the screen: * * receives the color of the pixel without the lights * and the normal vector. * * if P is set outside of the screen bounds, doesn't print anything * * compare its position on the Z_Buffer * * draws the pixel with its final color (adding the lights effects) */ public int printPixel(V3 P, Couleur color) { int x, y, z; x = (int)P.x; y = (int)P.y; z = (int)P.z; if (x < 0 || x >= BitmapEcran.GetWidth() || z < 0 || z >= BitmapEcran.GetHeight()) { return(-1); } if (Elements.raycasting) // using ray casting { BitmapEcran.DrawPixel(x, z, color); } else { //using Z-Buffer if (y < Elements.Z_Buffer[x, z]) { Elements.Z_Buffer[x, z] = y; BitmapEcran.DrawPixel(x, z, color); } } return(0); }
public Lumiere() { type = 0; // directional light direction = new V3(0.0f,0.0f,0.0f); position = new V3(0.0f, 0.0f, 0.0f); C_lampe = new Couleur(1.0f, 1.0f, 1.0f); }
public Couleur RayCast(V3 PosCamera, V3 DirRayon, List <Objet3D> Objets) { Couleur c; float t; float tmin = float.MaxValue; Objet3D ObjectAAfficher = null; foreach (Objet3D Objet in Objets) { //Console.WriteLine("OBJET: " + Objet.GetType().ToString()); t = Objet.gettIntersect(PosCamera, DirRayon); //Console.WriteLine(" Distance " + t); if (t > 0 && t < tmin) { ObjectAAfficher = Objet; tmin = t; } } //Console.WriteLine(""); //Console.WriteLine("Distance min: " + tmin ); if (ObjectAAfficher != null) { V3 PointIntersection = new V3(PosCamera + tmin * DirRayon); c = ObjectAAfficher.getCouleurRaycast(PointIntersection, this); return(c); } else { c = new Couleur(0.3f, 0.3f, 0.3f); return(c); } }
public Lumiere(int pType, V3 pDirection, V3 pPosition, Couleur pC_lampe) { this.type = pType; this.direction = pDirection; this.position = pPosition; this.C_lampe = pC_lampe; }
/*public override void Draw(Couleur C_ambiant, Lumiere L, V3 camera) { Couleur final_ambiant; Couleur C_lampe = L.getClampe(); for (double u = 0; u < 2 * Math.PI; u += pas) { for (double v = -1 * Math.PI / 2; v < Math.PI / 2; v += pas) { float dhdu, dhdv; Couleur C_obj = T.LireCouleur((float)(u / (2 * Math.PI)), (float)((v + Math.PI / 2) / Math.PI)); final_ambiant = C_obj * C_ambiant; double x = rayon * Math.Cos(v) * Math.Cos(u); double y = rayon * Math.Cos(v) * Math.Sin(u); double z = rayon * Math.Sin(v); int x_ecran = (int)x + (int)origin.x; int z_ecran = (int)z + (int)origin.z; if (ZBuffer.test(y, x_ecran, z_ecran)) { V3 N = new V3((float)x, (float)y, (float)z); //ne pas toucher // BUMP MAP if (T_bump != null) { V3 dmdu = new V3((float)(-rayon * Math.Cos(v) * Math.Sin(u)), (float)(rayon * Math.Cos(v) * Math.Cos(u)), 0.0f); V3 dmdv = new V3((float)(-rayon * Math.Sin(v) * Math.Cos(u)), (float)(-rayon * Math.Sin(v) * Math.Sin(u)), (float)(rayon * Math.Cos(v))); this.T_bump.Bump((float)(u / (2 * Math.PI)), (float)((v + Math.PI / 2) / Math.PI), out dhdu, out dhdv); N = N + bump_coeff * ((dmdu ^ (N * dhdv)) + ((N * dhdu) ^ dmdv)); } // FIN BUMP MAP V3 O = new V3((float)x, (float)y, (float)z); O = camera - O; //Couleur finalColor = computeLights(C_obj, C_ambiant, N, O, L, k); //BitmapEcran.DrawPixel(x_ecran, z_ecran, finalColor); } } } }*/ public override Couleur DrawPoint(Couleur C_ambiant, List<Lampe> lampList, V3 camera, V3 R, bool[] occs) { V3 N = R - this.origin; N.Normalize(); V3 O = camera - R; // TEXTURE float u, v; IMA.Invert_Coord_Spherique(R - this.origin, this.rayon, out u, out v); Couleur C_obj = T.LireCouleur((float)(u / (Math.PI)), (float)((v + IMA.PI2) / Math.PI)); // BUMP MAP if (T_bump != null) { float dhdu, dhdv; V3 dmdu = new V3((float)(-rayon * Math.Cos(v) * Math.Sin(u)), (float)(rayon * Math.Cos(v) * Math.Cos(u)), 0.0f); V3 dmdv = new V3((float)(-rayon * Math.Sin(v) * Math.Cos(u)), (float)(-rayon * Math.Sin(v) * Math.Sin(u)), (float)(rayon * Math.Cos(v))); this.T_bump.Bump((float)(u / (Math.PI)), (float)((v + IMA.PI2) / Math.PI), out dhdu, out dhdv); N = N + bump_coeff * ((dmdu ^ (N * dhdv)) + ((N * dhdu) ^ dmdv)); } // FIN BUMP MAP Point I = new Point(C_obj, C_ambiant, N, O, this.k); Couleur finalColor = computeLights(I, lampList, occs); return finalColor; }
public Light_Source(V3 position, Couleur color, bool point_light) { ; this.position = position; this.color = color; this.point_light = true; }
public Scene(Couleur couleurAmbiante, float intensiteAmbiante, int puissanceSpeculaire) { this.couleurAmbiance = couleurAmbiante; this.intensiteAmbiance = intensiteAmbiante; this.lampes = new List <Lumiere>(); this.objets = new List <Formes>(); this.puissanceSpeculaire = puissanceSpeculaire; }
public Point() { this.C_obj = new Couleur (1.0f, 1.0f, 1.0f); this.C_ambiant = new Couleur(0.2f, 0.2f, 0.2f); this.N = new V3(0, -1, 0); this.O = new V3(0, 0, 0); this.k = 30; }
public void Draw(double x, double y, Couleur couleur) { int x_sceem = (int)((x / (20.0 * this.ration)) * this.resolution_X + this.resolution_X / 2); int y_screem = (int)((y / 20.0) * this.resolution_Y + this.resolution_Y / 2); //Console.WriteLine("x:"+x_sceem+" y:"+y_screem); BitmapEcran.DrawPixel(x_sceem, y_screem, couleur); }
public Rectangle_2(V3 a, V3 b, V3 c, Couleur color, int index) { A = a; B = b; C = c; this.color = color; object_index = index; }
public Point(Couleur C_obj, Couleur C_ambiant, V3 N, V3 O, int k) { this.C_obj = C_obj; this.C_ambiant = C_ambiant; this.N = N; this.O = O; this.k = k; }
public static void DrawPixel(int x, int y, Couleur c) { int x_ecran = x; int y_ecran = Hauteur - y; if ((x_ecran >= 0) && (x_ecran < Largeur) && (y_ecran >= 0) && (y_ecran < Hauteur)) if (Mode == ModeAff.SLOW_MODE) DrawSlowPixel(x_ecran, y_ecran, c); else DrawFastPixel(x_ecran, y_ecran, c); }
//dessine tous les objets de la scène public void DrawScene() { for (int x_ecran = 0; x_ecran <= BitmapEcran.GetWidth(); x_ecran++) { for (int y_ecran = 0; y_ecran <= BitmapEcran.GetHeight(); y_ecran++) { V3 PosPixScene = new V3(x_ecran, 0, y_ecran); V3 DirRayon = PosPixScene - PosCamera; DirRayon.Normalize(); Couleur C = RayCast(PosCamera, DirRayon, Objets); BitmapEcran.DrawPixel(x_ecran, y_ecran, C); } } }
public override Couleur drawPixel(V3 positionInScene) { V3 posionForSphere = positionInScene - this.getPosition(); float v; float u; IMA.Invert_Coord_Spherique(posionForSphere, this.rayon, out u, out v); V3 vectSphere = new V3((float)(this.rayon * Math.Cos(v) * Math.Cos(u)), (float)(this.rayon * Math.Cos(v) * Math.Sin(u)), (float)(this.rayon * Math.Sin(v))); V3 copyvectSphere = new V3(vectSphere); copyvectSphere.Normalize(); float dhsdu; float dhsdv; this.getBump(u / (Math.PI * 2), v / Math.PI + Math.PI / 2, out dhsdu, out dhsdv); V3 dmsdu = new V3((float)(-1 * Math.Cos(v) * Math.Sin(u)), (float)(1 * Math.Cos(v) * Math.Cos(u)), 0.0f); V3 dmsdv = new V3((float)(-1 * Math.Sin(v) * Math.Cos(u)), (float)(-1 * Math.Sin(v) * Math.Sin(u)), (float)(1 * Math.Cos(v))); V3 dmpsdu = dmsdu + dhsdu * copyvectSphere; V3 dmpsdv = dmsdv + dhsdv * copyvectSphere; V3 Np = ((dmpsdu ^ dmpsdv) / (dmpsdu ^ dmpsdv).Norm()); V3 vecteurBump = Np; V3 vect = this.getPosition() + vectSphere; Couleur vcolor = new Couleur(); foreach (Light light in RenderSing.getCurrentRender().getLight()) { vcolor += light.applyLight(this, vect, vecteurBump, this.getColor(u / (2 * Math.PI), v / Math.PI + Math.PI / 2)); } return(vcolor); }
static void DrawFastPixel(int x, int y, Couleur c) { unsafe { byte RR, VV, BB; c.Check(); c.To255(out RR, out VV, out BB); byte *ptr = (byte *)data.Scan0; ptr[(x * 3) + y * stride] = BB; ptr[(x * 3) + y * stride + 1] = VV; ptr[(x * 3) + y * stride + 2] = RR; } }
static void DrawSlowPixel(int x, int y, Couleur c) { Color cc = c.Convertion(); B.SetPixel(x, y, cc); Program.MyForm.PictureBoxInvalidate(); nb_pix++; if (nb_pix > refresh_every) // force l'affichage à l'écran tous les 1000pix { Program.MyForm.PictureBoxRefresh(); nb_pix = 0; } }
private void outColor() { if (this.color_rb.Checked) { Couleur cl = new Couleur(); cl.B = ((float)(this.colorDialog1.Color.B)) / 256.0f; cl.R = ((float)(this.colorDialog1.Color.R)) / 256.0f; cl.V = ((float)(this.colorDialog1.Color.G)) / 256.0f; this.formToModif.setCouleur(cl); } else { this.formToModif.setCouleur(new Couleur()); } }
public Couleur getPixelColor(V3 P) { V3 N = getRectangleNormal(P); // get pixel's color getUV(P, out float u, out float v); Couleur c = getColor(u, v); if (bump_activate) { N = bumpN(N, u, v); } c = Lights.getPixelColor(P, c, N, object_index); return(c); }
public Couleur computeLights(Point I, List<Lampe> lampList, bool[] occs) { Couleur C_obj = I.C_obj; Couleur C_ambiant = I.C_ambiant; V3 N = I.N; V3 O = I.O; int k = I.k; float cosln; Couleur black = new Couleur(0f, 0f, 0f); Couleur final_ambiant; Couleur final_diff = black; Couleur final_spec = black; Couleur finalColor = black; final_ambiant = C_obj * C_ambiant; for(int i = 0; i < lampList.Count; i++) { Lumiere L = (Lumiere)lampList.ElementAt(i); if (occs[i] == false) { /* DIFFUS */ N.Normalize(); L.getDirection().Normalize(); cosln = L.getDirection() * N; cosln = cosln < 0 ? 0 : cosln; final_diff += C_obj * L.getClampe() * cosln; /* FIN DIFFUS */ /* SPECULAIRE */ V3 S = 2 * N * cosln - L.getDirection(); S.Normalize(); O.Normalize(); double cosso = S * O; final_spec += L.getClampe() * (float)Math.Pow(cosso, k); /* FIN SPECULAIRE */ finalColor += final_diff + final_spec; } } finalColor += final_ambiant; //Console.WriteLine("Couleur 1 " + finalColor.R + " " + finalColor.V + " " + finalColor.B); finalColor.check(); //Console.WriteLine("Couleur 2 " + finalColor.R + " " + finalColor.V + " " + finalColor.B); return finalColor; }
public static void DrawPixel(int x, int y, Couleur c) { int x_ecran = x; int y_ecran = Hauteur - y; if ((x_ecran >= 0) && (x_ecran < Largeur) && (y_ecran >= 0) && (y_ecran < Hauteur)) { if (Mode == ModeAff.SLOW_MODE) { DrawSlowPixel(x_ecran, y_ecran, c); } else { DrawFastPixel(x_ecran, y_ecran, c); } } }
public static Scene Scene2() { Couleur blanc = new Couleur(1.0f, 1.0f, 1.0f); Scene scene = new Scene(blanc, 0.05f, 50); Couleur orangesque = new Couleur(1.0f, 0.78f, 0.59f); Couleur bleuesque = new Couleur(0.78f, 0.59f, 1.0f); Couleur rouge = new Couleur(1.0f, 0.0f, 0.0f); Quadrilatere sol = new Quadrilatere("wood.jpg", "bump1.jpg", new V3(500.0f, 0.0f, 0.0f), new V3(1000.0f, 500.0f, 0.0f), new V3(0.0f, 500.0f, 0.0f)); scene.AddObjet(sol); Quadrilatere mur = new Quadrilatere(blanc, "bump.jpg", new V3(0.0f, 500.0f, 0.0f), new V3(500.0f, 1000.0f, 0.0f), new V3(0.0f, 500.0f, 1000.0f)); scene.AddObjet(mur); Quadrilatere mur2 = new Quadrilatere(blanc, "bump.jpg", new V3(500.0f, 1000.0f, 0.0f), new V3(1000.0f, 500.0f, 0.0f), new V3(500.0f, 1000.0f, 1000.0f)); scene.AddObjet(mur2); Lumiere key = new LampeDirectionelle(orangesque, 0.48f, new V3(1.0f, -1.0f, 1.0f)); scene.AddLampe(key); Lumiere fill = new LampeDirectionelle(bleuesque, 0.27f, new V3(-1.0f, -1.0f, 1.0f)); scene.AddLampe(fill); Lumiere back = new LampeDirectionelle(blanc, 0.2f, new V3(-1.0f, 1.0f, -1.0f)); scene.AddLampe(back); Mesh mesh = new Mesh("teapot.obj", "gold.jpg"); mesh.Rescale(100.0f); mesh.Translate(new V3(500.0f, 300.0f, 70.0f)); foreach (Triangle t in mesh.GetPolygons()) { scene.AddObjet(t); } return(scene); }
/// ///////////////// public methods /////////////////////// public static void RefreshScreen(Couleur c) { if (Program.MyForm.Checked()) { Mode = ModeAff.SLOW_MODE; Graphics g = Graphics.FromImage(B); Color cc = c.Convertion(); g.Clear(cc); } else { Mode = ModeAff.FULL_SPEED; data = B.LockBits(new Rectangle(0, 0, B.Width, B.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); stride = data.Stride; for (int x = 0; x < Largeur; x++) for (int y = 0; y < Hauteur; y++) DrawFastPixel(x, y, c); } }
//récupère la couleur du pixel en prenant compte des lumières de la scène public Couleur CouleurEclairee(V3 position, V3 normal, Couleur couleurDeBase, Materiel mat, Objet3D ObjetToDraw) { //initialisation de la couleur Couleur couleurFinale = new Couleur(0, 0, 0); //---------------------------Lumiere AMBIANTE----------------------------------// if (LumAmb != null) { couleurFinale += new Couleur(couleurDeBase * LumAmb.Couleur); } if (Lumieres.Count > 0) { foreach (Lumiere l in Lumieres) { V3 DirectionLumiere = l.getDirection(position); DirectionLumiere.Normalize(); if (!CheckIfObjectBetweenLightSource(DirectionLumiere, position, ObjetToDraw)) { //Console.WriteLine("Je dessine la lumière"); //-------------------------------Lumiere DIFFUSE------------------------------------// float diff = Math.Max((DirectionLumiere * normal), 0); couleurFinale += new Couleur((couleurDeBase * l.getCouleur()) * diff); //--------------------------------Reflet SPECULAIRE--------------------------------// float forceSeculaire = mat.GetForceSpeculaire(); V3 positionOeil = new V3(BitmapEcran.GetHeight() / 2, -3000, BitmapEcran.GetWidth() / 2); V3 directionDuRayonReflechis = new V3(2 * normal - DirectionLumiere); directionDuRayonReflechis.Normalize(); V3 directionObservateur = new V3(positionOeil - position); directionObservateur.Normalize(); couleurFinale += new Couleur(l.getCouleur() * (float)Math.Pow((directionDuRayonReflechis * directionObservateur), forceSeculaire)); } } } return(couleurFinale); }
public void DessineRaycast() { V3 camera = new V3((float)BitmapEcran.GetWidth() / 2, (float)BitmapEcran.GetWidth() * -1.5f, (float)BitmapEcran.GetHeight() / 2); int xmax = BitmapEcran.GetWidth(); int ymax = BitmapEcran.GetHeight(); Couleur[,] colorbuffer = new Couleur[xmax, ymax]; for (int x_ecran = 0; x_ecran < BitmapEcran.GetWidth(); x_ecran++) { for (int y_ecran = 0; y_ecran < BitmapEcran.GetHeight(); y_ecran++) { V3 pixel = new V3((float)x_ecran, 0, (float)y_ecran); V3 rayon = pixel - camera; rayon.Normalize(); colorbuffer[x_ecran, y_ecran] = Raycast(camera, rayon); BitmapEcran.DrawPixel(x_ecran, y_ecran, colorbuffer[x_ecran, y_ecran]); } } }
private void inTextureOrColor() { if (this.formToModif.getTexture() == null) { this.color_rb.Checked = true; Couleur cl = this.formToModif.getCouleur(); Color cl2 = Color.FromArgb( (int)(cl.R * 256), (int)(cl.V * 256), (int)(cl.B * 256) ); this.colorDialog1.Color = cl2; this.button3.BackColor = cl2; } else { this.image_rb.Checked = true; this.openFileDialog1.FileName = this.formToModif.getTexture().path; this.button4.Image = new Bitmap(this.openFileDialog1.FileName); } }
override public Couleur getCouleurRaycast(V3 PointIntersection, Scene scene) { //Console.WriteLine("Sphere Pt Intersect: " + PointIntersection.x + " " + PointIntersection.y + " " + PointIntersection.z); V3 pixel_position = PointIntersection - center; //Console.WriteLine(" " + PointIntersection.x + " " + PointIntersection.y + " " + PointIntersection.z); IMA.Invert_Coord_Spherique(pixel_position, rayon, out float u, out float v); //Console.WriteLine(" u: " + u+" ,v " + v); //------------------------------BUMP MAPING---------------------------------------// float pi = (float)Math.PI; float uNormalise = u / (2 * pi); float vNormalise = v / pi + pi; Partial_derivative(u, v, out V3 dMdu, out V3 dMdv); materiel.GetTextureBump().Bump(uNormalise, vNormalise, out float dhdu, out float dhdv); V3 normal = getNormal(u, v) + materiel.GetForceBumping() * (dhdu * (getNormal(u, v) ^ dMdv) + dhdv * (getNormal(u, v) ^ dMdu)); //------------------------------TEXTURE---------------------------------------// Couleur couleur = new Couleur(); if (materiel.GetTexture() != null) { couleur = materiel.GetTexture().LireCouleur(uNormalise, vNormalise); } else { couleur = materiel.GetCouleur(); } //------------------------------LUMIERE---------------------------------------// couleur = scene.CouleurEclairee(PointIntersection, normal, couleur, materiel, this); return(couleur); }
/// ///////////////// public methods /////////////////////// static public void RefreshScreen(Couleur c) { if (Program.MyForm.Checked()) { Mode = ModeAff.SLOW_MODE; Graphics g = Graphics.FromImage(B); Color cc = c.Convertion(); g.Clear(cc); } else { Mode = ModeAff.FULL_SPEED; data = B.LockBits(new System.Drawing.Rectangle(0, 0, B.Width, B.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); stride = data.Stride; for (int x = 0; x < Largeur; x++) { for (int y = 0; y < Hauteur; y++) { DrawFastPixel(x, y, c); } } } }
override public Couleur getCouleurRaycast(V3 PointIntersection, Scene scene) { float u = ((PointIntersection - A) * (B - A)) / ((B - A) * (B - A)); float v = ((PointIntersection - A) * (C - A)) / ((C - A) * (C - A)); //V3 pixel_position = getPixel3DPosition(u, v); V3 pixel_position = PointIntersection; //------------------------------BUMP MAPING---------------------------------------// float uNormalise = u; float vNormalise = v; Partial_derivative(u, v, out V3 dMdu, out V3 dMdv); materiel.GetTextureBump().Bump(u, v, out float dhdu, out float dhdv); V3 normal = getNormal() + materiel.GetForceBumping() * (dhdu * (getNormal() ^ dMdv) + dhdv * (getNormal() ^ dMdu)); //V3 normal = getNormal(u,v); //------------------------------TEXTURE---------------------------------------// Couleur couleur = new Couleur(); if (materiel.GetTexture() != null) { couleur = materiel.GetTexture().LireCouleur(uNormalise, vNormalise); } else { couleur = materiel.GetCouleur(); } //------------------------------LUMIERE---------------------------------------// couleur = scene.CouleurEclairee(pixel_position, normal, couleur, materiel, this); //System.Console.WriteLine(couleur.R+" "+couleur.V+" "+couleur.B); //------------------------------DESSIN FINAL---------------------------------------// return(couleur); }
public LumiereAmbiante(Couleur pCouleurLumiereAmbiante) { Couleur = pCouleurLumiereAmbiante; }
public static void Go() { int width = BitmapEcran.GetWidth(); int height = BitmapEcran.GetHeight()+1; Couleur C_ambiant = new Couleur(0.2f, 0.2f, 0.2f); V3 camera = new V3(width / 2, -1000, height / 2); // LAMPES List<Lampe> lampList = new List<Lampe>(); lampList.Add(new Lumiere(0, new V3(1f, -1f, 1f), new V3(0f, 0f, 0f), new Couleur(0.4f, 0.4f, 0.4f))); lampList.Add(new Lumiere(0, new V3(-1f, -1f, 1f), new V3(0f, 0f, 0f), new Couleur(0.4f, 0.4f, 0.4f))); // TEXTURES Texture T_carreau = new Texture("carreau.jpg"); Texture T_lead = new Texture("lead.jpg"); Texture T_Aymeric = new Texture("aymeric.jpg"); Texture T_stone = new Texture("stone2.jpg"); Texture T_fibre = new Texture("fibre.jpg"); Texture T_brick = new Texture("brick01.jpg"); Texture T_gold = new Texture("gold.jpg"); // BUMP TEXTURES Texture T_bump = new Texture("bump38.jpg"); Texture T_leadbump = new Texture("lead_bump.jpg"); // OBJETS List<Objet3D> objList = new List<Objet3D>(); //SPHERES objList.Add(new Sphere(new V3(width / 2, 500, height - 50), 150, T_carreau, T_bump, 0.008f)); objList.Add(new Sphere(new V3(50, 500, height / 2), 150, T_lead, T_leadbump, 0.01f)); objList.Add(new Sphere(new V3(175, 300, height / 2 + 75), 50, T_gold, T_bump, 0.1f)); //RECTS //fond objList.Add(new Rect(new V3(50, 1000, 50), new V3(width - 100, 0, 0), new V3(0, 0, height - 100), T_brick, null)); //bas objList.Add(new Rect(new V3(50, 0, 50), new V3(width - 100, 0, 0), new V3(0, 1000, 0), T_stone, null)); //haut //objList.Add(new Rect(new V3(width-50, 0, height-50), new V3(-(width-100), 0, 0), new V3(0, 1000, 0), T_fibre, null)); //gauche objList.Add(new Rect(new V3(50, 0, 50), new V3(0, 1000, 0), new V3(0, 0, height - 100), T_brick, null)); //droite objList.Add(new Rect(new V3(width - 50, 1000, 50), new V3(0, -1000, 0), new V3(0, 0, height - 100), T_brick, null)); //milieu objList.Add(new Rect(new V3(width / 2 + 100, 750, 50), new V3(0, -500, 0), new V3(0, 0, height / 3), T_brick, null)); // RAY CASTING V3 Rd, R; float t, tnew; bool[] occs = new bool[lampList.Count]; //parcourir les pixels en x for (int pxx = 0; pxx < width; pxx++) { //parcourir les pixels en z for (int pxz = 0; pxz < height; pxz++) { t = float.MaxValue; // pour chaque pixel générer un rayon Rd Rd = new V3(pxx - camera.x, -camera.y, pxz - camera.z); Rd.Normalize(); // parcourir la liste des objets foreach (Objet3D obj in objList) { // appeler l'intersection et récupérer le point tnew = obj.getIntersect(Rd, camera); if (tnew != -1) { if (tnew <= t) { t = tnew; // R est le point d'intersection de Rd et de l'objet R = camera + t * Rd; occs = obj.occultation(R, objList, lampList); //Console.WriteLine(occs[0]+" "+occs[1]); Couleur finalColor = obj.DrawPoint(C_ambiant, lampList, camera, R, occs); BitmapEcran.DrawPixel(pxx, pxz, finalColor); } } } } } //s1.Draw(C_ambiant, L, camera); //s2.Draw(C_ambiant, L, camera); //r1.Draw(C_ambiant, L, camera); //r2.Draw(C_ambiant, L, camera); }
static void DrawFastPixel(int x, int y, Couleur c) { unsafe { byte RR, VV, BB; c.check(); c.To255(out RR, out VV, out BB); byte* ptr = (byte*)data.Scan0; ptr[(x * 3) + y * stride ] = BB; ptr[(x * 3) + y * stride + 1] = VV; ptr[(x * 3) + y * stride + 2] = RR; } }
public abstract Couleur DrawPoint(Couleur C_ambiant, List<Lampe> lampList, V3 camera, V3 R, bool[] occs);
public Couleur(Couleur c) { this.R = c.R; this.V = c.V; this.B = c.B; }
public static void Transpose(ref Couleur cc, System.Drawing.Color c) { cc.R = (float) (c.R / 255.0); cc.V = (float) (c.G / 255.0); cc.B = (float) (c.B / 255.0); }
public void setClampe(Couleur pClampe) { this.C_lampe = pClampe; }