Pourquoi mon application de traitement ne se comporte pas?

Question

J'apprends à utiliser traitement , et ont modifié l'un des exemples pour créer cette applet . J'ai deux questions:

1. Pourquoi les sphères oblats? Les sphères dans l'exemple que je cribbed de sont belles et rondes.
2. Pourquoi dois-je obtenir la projection de lumière sur les bords extérieurs des sphères, lorsque la source ponctuelle est entre eux?

Voici la source de ce petit programme:

int radius = 40;
int spheredist = 320;
int maxlevel = 7;
float ecc = 0.28;
int x1, x2, y1, y2;

void setup() {
  size(640, 360, P3D);
  fill(204);
  //smooth();  // makes spheres ugly
  translate(width/2, height/2, 0);
  x1 = -spheredist/2+radius;
  x2 = spheredist/2-radius;
  y1 =
  y2 = 0;
}

void drawLightning(int x1_,int y1_,int x2_,int y2_,int lvl){
   if (lvl < maxlevel){
     int midx = (x1_ + x2_)/2;
     int midy = (y1_ + y2_)/2;
     float d = dist(x1_, y1_, x2_, y2_);
     d *= ecc;
     midx += random(-d, d);
     midy += random(-d, d);
     drawLightning(x1_, y1_, midx, midy, lvl+1);
     drawLightning(midx, midy, x2_, y2_, lvl+1);
   } else {
     strokeWeight(10);
     stroke(60,100,255,100);
     line(x1_,y1_,x2_,y2_);
     strokeWeight(1);
     stroke(255);
     line(x1_,y1_,x2_,y2_);
   }
}

void draw() {
  background(0); 
  noStroke(); 
  int brt = 200;
  pointLight(brt/2, brt/2, brt/2, spheredist/2, -spheredist, spheredist); 
  ambientLight(brt/8,brt/8,brt/8);


  if ((mouseX > width/4 && mouseX < width*3/4) &&
      (mouseY > height/2-radius && mouseY < height/2+radius)) {
    pushMatrix();
    translate(width/2, height/2, 0);
    pointLight(100, 100, 255, 0, 0, 0); 
    popMatrix();
  }

  pushMatrix();
  translate(width/2 - spheredist/2, height/2, 0); 
  sphere(radius); 
  translate(spheredist, 0, 0); 
  sphere(radius); 
  popMatrix();

  if ((mouseX > width/4 && mouseX < width*3/4) &&
      (mouseY > height/2-radius && mouseY < height/2+radius)) {
    pushMatrix();
    translate(width/2, height/2, 0);  
    drawLightning(x1,y1,x2,y2,0);
    popMatrix();
  }
}

Answer 1

La fonction lisse ne fonctionne pas bien dans ce cas parce que vous avez des polygones aboutement. Il est un peu difficile à suivre sans image, mais pensez à un pixel qui est sur le bord entre deux polygones. Pour l'exemple, disons que le fond est (0,0,0) et les polygones sont (255255255). Le premier polygone dessine et frappe ce pixel. Il couvre la moitié de celui-ci, de sorte qu'il calcule 0,5 * (0,0,0) + 0,5 * (255,255,255) et enregistre (126126126) en tant que nouvelle valeur pour ce pixel. Le second polygone dessine. Il couvre également la moitié du pixel il calcule 0,5 * (126126126) + 0,5 * (255,255,255) et sauve (190190190). Ce n'est pas correct parce que les deux polygones doivent avoir chacun couvert une autre moitié et a donné lieu à une couleur de (255255255). Mais vous ne pouvez pas comprendre que si vous dessinez chaque polygone individuellement et ne stockons aucune information de couverture entre les deux.

Cartes graphiques modernes prennent en charge quelque chose appelé multiéchantillon anticrénelage. Cela permet d'économiser quelques informations sur quelle partie du pixel du premier polygone couvert. Le traitement est en train de simuler sans le soutien matériel, il utilise une astuce qui fonctionne assez bien quand vous n'avez pas primitives aboutement, mais se désagrège quand vous faites.

En ce qui concerne l'aplatissement. Par défaut, le traitement remplit la totalité de la fenêtre, et votre taille n'est pas carré. La meilleure façon de traiter ce problème est d'utiliser la fonction ortho pour rendre le rapport d'aspect de votre carré de la caméra. Essayez d'ajouter ceci à votre configuration:

  

ortho (-360360, -180180, -10,10);

Answer 2

A propos des bords bien ronds, essayez d'appeler lisse la méthode () dans la configuration ():

void setup() {
  // ...
  smooth();
  // ...
}