Tag Archives: raytracing

Volumetric Thing (Tree)

3484TreeRender
Particle-generated volumetric tree.

Made with Processing+toxiclibs+SunflowApiApi.

L’idea su cui sto lavorando negli ultimi tempi, e cioè creare volumi registrando le informazioni relative ad un determinato stato di una immagine 2D con l’aggiunta della terza dimensione (estrusione data dal tempo che scorre) comunque non è mia e lo devo annotare ad onor del vero. Il concept originale é di Karsten “toxi” Schmidt (autore di toxiclibs) ma un giorno, su openprocessing mi sono imbattuto negli sketches di Dominik Strzelec “echoechonoisenoise” e i suoi esperimenti sulla time-extrusion con toxiclibs mi hanno talmente ispirato da spingermi ad iniziare ad usare le lib (un set di 270+ classi distribuite in 18 packages da utilizzare con Processing), cosa che non avevo fatto prima, concentrandomi a mia volta sul package toxi.volume.

La mia idea sarebbe ora di creare degli alberi a partire da sistemi multipli di particelle – in passato avevo tentato altri approcci e cioè le funzioni recursive e gli L-Systems; questo primo esempio è solo l’inizio anche se più che di un particle system si tratta di una ventina di particelle che ‘vivono’ sul piano da estrudere. All’inizio della time-extrusion (alla base dell’albero) si trovano tutte al centro, poi con un attrattore che in realtà le respinge – posto al centro del piano – le particelle (per via di massa e diametro differenziato) si allontanano più o meno velocemente. Questo crea i rami. Devo solo fare in modo che ogni particella, ad un dato momento della sua vita, possa generare altre particelle e riduca il suo raggio fino a zero. Così da un singolo ramo otterrei altri rami, e anche loro si assottiglierebbero fino allo zero generando ulteriori rami.

re-mesh

hmrecreate04
hmrecreate04det
hmrecreate03
hmrecreate02
Re-constructed structures. Made with Processing+Hemesh+SunflowApiApi.

Creating meshes is cool (for a given amount of cool) but destroying them is even cooler.
— W:Blut

True, but once a mesh is modified (with the Lattice modifier, for example) how can we re-construct the shape keeping track of the removed ones? I wanted a way to render some glass-looking windows on the buildings faces and discovered (hacked) a way to re-generate a polygon (a new cube but still missing the 6th face) where initially a hole have been created. One can draw the polygons by going through the WB_Point array of each poly, creating a polygon for every face you delete.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import wblut.hemesh.*;
import wblut.hemesh.creators.*;
import wblut.hemesh.modifiers.*;
import wblut.hemesh.subdividors.*;
import wblut.hemesh.kdtree.*;
import wblut.hemesh.tools.*;
import wblut.geom.*;
import wblut.math.*;
 
import peasy.org.apache.commons.math.*;
import peasy.*;
import peasy.org.apache.commons.math.geometry.*;
 
HE_Mesh mesh, holes;
PeasyCam cam;
HE_Selection selection;
 
ArrayList<WB_Polygon> removedPolys = new ArrayList<WB_Polygon>();
ArrayList<WB_Quad> qua = new ArrayList<WB_Quad>();
 
void setup()
{
	size(650, 650, P3D);
	cam = new PeasyCam(this, 450);
	HEC_Creator cube = new
	HEC_Box(this).setWidth(100).setWidthSegments(5)
		.setHeight(100).setHeightSegments(5)
		.setDepth(100).setDepthSegments(6);
	mesh = new HE_Mesh(cube);
	selection=new HE_Selection();
	Iterator fItr=mesh.fItr();
	HE_Face f;
	while(fItr.hasNext()){
	 f=fItr.next();
	 if(random(100) < 50){
	   selection.add(f);
	   removedPolys.add(f.toPolygon());
	 }
	}
	HEM_Lattice lattice = new HEM_Lattice().setDepth(6).setWidth(3);
	mesh.modifySelected(lattice, selection);
 
	for (WB_Polygon wb:removedPolys){
	  for(int i = 0; i < wb.points.length; i+=4){
		WB_Quad wbq = new WB_Quad(wb.points[i], wb.points[i+1], wb.points[i+2], wb.points[i+3]);
		qua.add(wbq);
	  }
	}
	HEC_FromQuads hfq = new HEC_FromQuads(this).setQuads(qua);
	holes = new HE_Mesh(hfq);
	HEM_Extrude extrude = new HEM_Extrude().setDistance(1);
	holes.modify(extrude);
}
 
void draw()
{
    background(255);
    lights();
    noStroke();
    fill(220);
    mesh.drawFaces();
    fill(#B90202, 70);
    holes.drawFaces();
}

3D shapes with Hemesh

hemesh01
HEC_Geodesic. made with Processing and Hemesh.

These incredible shapes have been created with Hemesh, a library for Processing created by Frederik Vanhoutte (W:Blut) for creating and manip­u­lat­ing 3D meshes. I just downloaded the lib and started coding, trying to render them with Christopher Warnow’s SunflowApiApi. So far, these are the results. Amazing libraries!

hemeshsunflow
hemeshsunflow02

After some figuring out, I got SunflowApiApi to work directly from Processing! Still did not get perfectly how to use the 8 available shaders and how to set up the scene global illumination, but the first results are impressive.

Typo Mishap

typomishap
Typo Mishap. Rendered with P5Sunflow.

Typo Mishap. Applet and source code: http://www.openprocessing.org/visuals/?visualID=9333

Come anticipato, inizio a studiarmi jBullet – il Java port di Bullet Physics (open source collision detection, rigid and soft body dynamics library), visto che é proprio quello che serve per aggiungere convincenti effetti di fisica agli oggetti 3D disegnati in Processing; la lib é molto complessa ed espone centinaia di classi e metodi per calcolare collisioni, primitive, inierzia, posizioni, piani, velocità, accelerazioni, punti di contatto, shapes convesse e concave, eventi, algoritmi ecc… Si é reso necessario un decompiler per leggere le classi (.java) contenute nel .jar della demo Applet originale; questo é l’unico modo per poter affrontare le API di Bullet Physics almeno per identificare chi-fa-cosa. In questa situazione iniziale é chiaro che per comprendere, devo ricostruire la demo base trovando però un punto di contatto efficiente tra le funzionalità di disegno (rendering) in Processing e quelle di calcolo di forme e comportamenti in Bullet. Comunque – e questa é la parte che mi entusiasma – non ci sono limiti a ciò che si può realizzare, perché questa libreria é scelta come framework per le simulazioni da almeno 3 su 10 tra le Top Game Companies che sfornano videogames per Wii e PS3.

r003
lettercam
Kill ‘em all! Posso creare forme e lanciarle nella direzione del lookAt point della camera partendo dalla posizione della stessa. Delle vere e proprie cannonate!

Nello sketch in cui ho tentato di usare per la prima volta Bullet, riprodotto nel video in alto, ad ogni key press la lettera o il numero corrispondente vengono creati e per effetto della gravità piombano sul piano sottostante; le forme sono dei veri e propri corpi rigidi che si fermano sui loro punti di contatto senza attraversarsi. La versione con cui si può ‘giocare’ sotto forma di Applet corredata di sorgente, è come al solito disponbile su OpenProcessing. Col mouse e tasto sx si ruota, col dx si fa zoom, e con la tastiera si creano i Characters.

Il poter simulare la matericità delle cose, ottenere reazioni in seguito ad azioni (come avviene nel mondo che ci circonda) suscita in me la stessa ‘frenesia creativa’ che potrebbe avere un pittore messo di fronte alla più grande tela bianca che potesse desiderare.

 

p5sunflow

p5sf03
p5sunflow rendering test – GC Mingati

Primi test con p5sunflow, un 3D render engine open source con tanto di global illumination (una serie di algoritmi realizzati per aggiungere realismo alle scene 3D – riflessi, rifrazioni, ombre) originariamente chiamato Sunflow. Sunflow è un raytracer scritto in Java e reso compatibile con Processing da hipstersinc più di un anno fa col nome p5sunflow che poi però, a partire dalla versione 1.0 del framework, non ha più funzionato.
Finalmente qualcuno ha apportato le opportune modifiche e p5sunflow può nuovamente essere utilizzato per rendere “your Processing sketches look sexy as hell”.
Niente male davvero.