3d – ValCon.It

RGB cube

04/01/2013 di admin

3D > Form > RGBCube Mouse (verticale): rotazione intorno all’asse X Mouse (orizzontale): rotazione intorno all’asse Y Applicazione Java

final float gap=PI/6;

final float dim=120;

float asseX, asseY;

float asseMin, asseMax;

int Xc, Yc;

int maxX, maxY;

void setup()

{

size(500, 500, P3D);

noStroke();

colorMode(RGB, 1);

Xc=width/2;

Yc=height/2;

maxX=width-1;

maxY=height-1;

asseMin=-gap;

asseMax=TWO_PI+gap;

noLoop();

}

void mouseMoved()

{

asseY = map(mouseX, 0, maxX, asseMin, asseMax);

asseX = map(mouseY, 0, maxY, asseMin, asseMax);

redraw();

}

void draw()

{

background(1);

translate(Xc, Yc);

rotateX(-asseX);

rotateY(-asseY);

scale(dim);

beginShape(QUADS);

fill(0, 1, 1); vertex(-1, 1, 1);

fill(1, 1, 1); vertex( 1, 1, 1);

fill(1, 0, 1); vertex( 1, -1, 1);

fill(0, 0, 1); vertex(-1, -1, 1);

fill(1, 1, 1); vertex( 1, 1, 1);

fill(1, 1, 0); vertex( 1, 1, -1);

fill(1, 0, 0); vertex( 1, -1, -1);

fill(1, 0, 1); vertex( 1, -1, 1);

fill(1, 1, 0); vertex( 1, 1, -1);

fill(0, 1, 0); vertex(-1, 1, -1);

fill(0, 0, 0); vertex(-1, -1, -1);

fill(1, 0, 0); vertex( 1, -1, -1);

fill(0, 1, 0); vertex(-1, 1, -1);

fill(0, 1, 1); vertex(-1, 1, 1);

fill(0, 0, 1); vertex(-1, -1, 1);

fill(0, 0, 0); vertex(-1, -1, -1);

fill(0, 1, 0); vertex(-1, 1, -1);

fill(1, 1, 0); vertex( 1, 1, -1);

fill(1, 1, 1); vertex( 1, 1, 1);

fill(0, 1, 1); vertex(-1, 1, 1);

fill(0, 0, 0); vertex(-1, -1, -1);

fill(1, 0, 0); vertex( 1, -1, -1);

fill(1, 0, 1); vertex( 1, -1, 1);

fill(0, 0, 1); vertex(-1, -1, 1);

endShape();

}

Cono ruotante

04/01/2013 di admin

Il cono è realizzato come una piramide con 36 lati di base Mouse (posizione verticale): rotazione intorno all’asse x Applicazione Java

final int numFACCE = 36;

final float RAGGIO = 150,

ALTEZZA = 150,

deltaANGOLO = TWO_PI/numFACCE,

deltaROTAZIONE = 0.05,

GAP = PI/6;

float angoloRotazione,

WIDTH2, HEIGHT2,

SENO[], COSENO[];

color COLORI[];

void setup()

{

size(500, 500, P3D);

frameRate(30);

noStroke();

WIDTH2 =width/2;

HEIGHT2=height/2;

COLORI=new color[numFACCE+1];

for(int i=0; i < numFACCE; i++)

COLORI[i]=color(random(0, 125), random(128, 255), random(0, 125));

COLORI[numFACCE]=COLORI[0];

SENO =new float[numFACCE+1];

COSENO=new float[numFACCE+1];

float angolo=0;

for(int i=0; i < numFACCE+1; i++)

{

SENO[i] = sin(angolo)*RAGGIO;

COSENO[i] = cos(angolo)*RAGGIO;

angolo += deltaANGOLO;

}

void draw()

{

background(255);

angoloRotazione+=deltaROTAZIONE;

translate(WIDTH2, HEIGHT2);

rotateX(-map(mouseY, 0, width, -GAP, TWO_PI+GAP));

rotateY(angoloRotazione);

solido();

}

void solido()

{

beginShape(TRIANGLE_FAN); // parete laterale

vertex(0, ALTEZZA, 0);

for (int i=0; i < numFACCE+1; i++)

{

fill(COLORI[i]);

vertex(COSENO[i], -ALTEZZA, SENO[i]);

}

endShape();

beginShape(TRIANGLE_FAN); // base

vertex(0, -ALTEZZA, 0);

for (int i=0; i < numFACCE+1; i++)

{

fill(COLORI[i]);

vertex(COSENO[i], -ALTEZZA, SENO[i]);

}

endShape();

}

Mouse (posizione verticale): rotazione intorno all’asse x Mouse (tasto): visualizza una combinazione casuale delle facce Mouse (tasto): si può accendere/spegnere la singola faccia cliccando sul quadratino corrispondente in alto a destra Applicazione Java

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

final int numVertici = 8,

numFacce = 6;

Faccia facce[]=new Faccia[numFacce];

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

final int CHIARO = 255;

final int SCURO = 0;

final int TRASP = 127;

final color COLORE = color(SCURO, CHIARO, SCURO, TRASP);

final color TRATTO = color(CHIARO/2);

final color SFONDO = color(CHIARO);

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

final int DIM = 125;

final float deltaR = PI/200;

float angoloR=0,

WIDTH2 ,

HEIGHT2;

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Punto vertici[]= {

new Punto( 1, 1, 1), // 0

new Punto( 1, 1,-1), // 1

new Punto( 1,-1, 1), // 2

new Punto( 1,-1,-1), // 3

new Punto(-1, 1, 1), // 4

new Punto(-1, 1,-1), // 5

new Punto(-1,-1, 1), // 6

new Punto(-1,-1,-1) // 7

};

int quadrato[][]={

{ 0, 1, 3, 2 }, // 0

{ 1, 5, 7, 3 }, // 1

{ 5, 4, 6, 7 }, // 2

{ 4, 0, 2, 6 }, // 3

{ 2, 3, 7, 6 }, // 4

{ 5, 1, 0, 4 } // 5

};

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Faccia nuovaFaccia(int x)

{

return new Faccia(

vertici[quadrato[x][0]],

vertici[quadrato[x][1]],

vertici[quadrato[x][2]],

vertici[quadrato[x][3]],

COLORE

);

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void setup()

{

size(500, 500, P3D);

stroke(TRATTO);

lights();

WIDTH2 =width/2;

HEIGHT2=height/2;

creaFacce();

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void draw()

{

background(SFONDO);

angoloR += deltaR;

if(angoloR > TWO_PI)

angoloR -= TWO_PI;

pushMatrix();

translate(WIDTH2, HEIGHT2);

rotateX(-map(mouseY, 0, width, 0, TWO_PI));

rotateY(angoloR);

scale(DIM);

for(int i=0; i

{

if(facce[i]!=null)

facce[i].draw();

}

popMatrix();

visControllo();

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Punto

{

float x, y, z;

Punto(float nx, float ny, float nz)

{

x=nx; y=ny;

z=nz;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Faccia

{

Punto p1, p2, p3, p4;

color c;

Faccia(Punto np1, Punto np2, Punto np3, Punto np4, color nc)

{

p1=np1; p2=np2; p3=np3; p4=np4;

c=nc;

}

void draw()

{

fill(c);

beginShape(QUADS);

vertex(p1.x, p1.y, p1.z);

vertex(p2.x, p2.y, p2.z);

vertex(p3.x, p3.y, p3.z);

vertex(p4.x, p4.y, p4.z);

endShape();

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

final int dimCONTR = 20;

int posControlli[][]=

{

{ 10, 30 , 10+dimCONTR, 30+dimCONTR },

{ 30, 30 , 30+dimCONTR, 30+dimCONTR },

{ 50, 30 , 50+dimCONTR, 30+dimCONTR },

{ 70, 30 , 70+dimCONTR, 30+dimCONTR },

{ 30, 50 , 30+dimCONTR, 50+dimCONTR },

{ 30, 10 , 30+dimCONTR, 10+dimCONTR }

};

void visControllo()

{

for(int i=0; i < numFacce; i++)

{

if(facce[i]==null) fill(SFONDO);

else fill(COLORE);

rect(posControlli[i][0], posControlli[i][1], dimCONTR, dimCONTR);

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void mousePressed()

{

int X=mouseX;

int Y=mouseY;

for(int i=0; i < numFacce; i++)

{

if(X > posControlli[i][0] && X < posControlli[i][2] &&

Y > posControlli[i][1] && Y < posControlli[i][3])

{

if(facce[i]==null) facce[i]=nuovaFaccia(i);

else facce[i]=null;

return;

}

creaFacce();

}

void creaFacce()

{

for(int i=0; i < numFacce; i++)

{

switch((int)random(3))

{

case 0:

case 1: facce[i]=nuovaFaccia(i); break;

case 2: facce[i]=null; break;

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Albero 3D di cubi

31/12/2012 di admin

Mouse (verticale): rotazione intorno all’asse X Mouse (orizzontale): rotazione intorno all’asse Y Mouse (tasto): aumenta la ricorsione Mouse (Ctrl+tasto): diminuisce la ricorsione Applicazione Java

final int maxRIC=5;

final float GAP=PI/6;

final float dim=120;

int RIC;

boolean scende;

float asseX, asseY;

float raggi[];

int colori[];

int Xc, Yc;

int maxX, maxY;

void setup()

{

size(500, 500, P3D);

frameRate(30);

noStroke();

Xc=width/2;

Yc=height/2;

maxX=width-1;

maxY=height-1;

colori=new int[maxRIC+1];

raggi =new float[maxRIC+1];

RIC=3;

scende=false;

inizializzaRIC();

noLoop();

}

void inizializzaRIC()

{

colori[RIC]=50;

for(int i=RIC-1; i >=0; i--)

colori[i]=colori[i+1]+30;

raggi[RIC]=dim;

for(int i=RIC-1; i >=0; i--)

raggi[i]=raggi[i+1]/2;

}

void keyPressed()

{

scende=true;

}

void keyReleased()

{

scende=false;

}

void mousePressed()

{

if(scende && RIC > 0)

{

RIC--;

inizializzaRIC();

redraw();

}

else if(!scende && RIC < maxRIC)

{

RIC++;

inizializzaRIC();

redraw();

}

void mouseMoved()

{

asseY = -map(mouseX, 0, +maxX, -HALF_PI-GAP, +HALF_PI+GAP);

asseX = map(mouseY, 0, +maxY, -PI-GAP, +PI+GAP);

redraw();

}

void draw()

{

background(255);

lights();

translate(Xc, Yc);

rotateX(-asseX);

rotateY(-asseY);

cubo(RIC, 0, 0, 0);

}

void cubo(int n, float x, float y, float z)

{

fill(25, colori[n], 50);

pushMatrix();

translate(x, y, z);

box(raggi[n]);

popMatrix();

if(n > 0)

{

float prossimo=raggi[n-1];

cubo(n-1, x-prossimo, y-prossimo, z-prossimo);

cubo(n-1, x+prossimo, y-prossimo, z-prossimo);

cubo(n-1, x-prossimo, y-prossimo, z+prossimo);

cubo(n-1, x+prossimo, y-prossimo, z+prossimo);

}

Albero 3D

31/12/2012 di admin

final float DIR = HALF_PI;

final float deltaDir = PI/4;

final float deltaDim = 0.59;

final int maxRIC = 10;

final float GAP = PI/6;

float DIM;

int RIC=10;

boolean scende;

float asseX, asseY;

int Xc, Yc;

int maxX, maxY;

float Dimensioni[];

void setup()

{

size(500, 500, P3D);

Xc = width/2;

Yc = height/2;

maxX = width-1;

maxY = height-1;

RIC = 4;

DIM = width*0.19;

scende = false;

Dimensioni = new float[maxRIC+1];

inizializzaRIC();

noLoop();

}

void inizializzaRIC()

{

Dimensioni=new float[RIC+1];

Dimensioni[RIC]=DIM;

for(int i=RIC-1; i >=1; i--)

Dimensioni[i]=Dimensioni[i+1]*deltaDim;

}

void keyPressed()

{

scende=true;

}

void keyReleased()

{

scende=false;

}

void mousePressed()

{

if(scende && RIC > 1)

{

RIC--;

inizializzaRIC();

redraw();

}

else if(!scende && RIC < maxRIC)

{

RIC++;

inizializzaRIC();

redraw();

}

void mouseMoved()

{

asseY = map(mouseX, 0, +maxX, -HALF_PI, +HALF_PI);

asseX = -map(mouseY, 0, +maxY, -PI, +PI);

redraw();

}

void draw()

{

background(255);

stroke(0);

fill(0, 25);

translate(Xc, Yc);

rotateX(asseX);

rotateY(asseY);

box(10);

albero(RIC, 0, 0, DIR);

}

void albero(int n, float x, float y, float angolo)

{

float newX = x+Dimensioni[n]*cos(angolo);

float newY = y-Dimensioni[n]*sin(angolo);

line(x, y, newX, newY);

if(n > 1)

{

albero(n-1, newX, newY, angolo+deltaDir);

albero(n-1, newX, newY, angolo-deltaDir);

}