Comme j'avais quelques minutes... je propose une solution rapide pour l'orientation :
j'ai opté pour la solution de facilité : me contenter d'ajouter des paramètres alphax, alphay, alphaz pour pouvoir tourner chaque cube (par rapport aux trois axes de coordonnées) avant de le translater de la position (0,0,0) à la position définie par le paramètre pos.
Code : Tout sélectionner
import three;
currentprojection=perspective(camera=(4,5,3),up=Z);
currentlight=nolight;
pen[] listecouleurs={red,blue,.95white,orange,.5green,yellow};
triple[] listenormales={X,Y,Z,-X,-Y,-Z};
struct FACE { int dim;
triple n;
int[][] c;
void operator init(int dim, triple n, int[][] c=new int[][]) {
this.dim=dim;
this.n=n;
this.c=c;
}
void dessinerface(triple n, bool num=false,triple pos,real alphax=0, real alphay=0, real alphaz=0) {
transform3 t1,t2,
h=shift((0,0,0))*scale3(1.1)*shift(-(0,0,0)),
trrr=shift(pos)*rotate(alphaz,Z)*rotate(alphay,Y)*rotate(alphax,X);
for(int i=0; i<dim; ++i)
for(int j=0; j<dim; ++j){
pen couleur=listecouleurs[this.c[i][j]];
real x=i-(dim-1)/2, y=j-(dim-1)/2;
if(n==X) t1=shift(dim/2,x,-y)*rotate(90,Y);
if(n==Y) t1=shift(-x,dim/2,-y)*rotate(90,X);
if(n==Z) t1=shift(y,x,dim/2);
if(n==-X) t1=shift(-dim/2,-x,y)*rotate(90,Y);
if(n==-Y) t1=shift(x,-dim/2,y)*rotate(90,X);
if(n==-Z) t1=shift(-y,-x,-dim/2);
t2=t1*scale3(.95)*shift(-.5,-.5,0);
draw(surface(trrr*t2*unitsquare3),couleur);
if(num==true) label(trrr*YZ()*scale3(0.03)*format("$%i$",1+dim*i+j),h*t2*(0.5,0.5,0));
}
}
}
struct CUBE { int dim;
FACE[] f;
void operator init(int dim=3, FACE[] f) {
this.dim=dim;
this.f=f;
}
void operator init(int dim=3)
{
this.dim=dim;
int[][][] coul=new int[6][dim][dim];
for(int col=0; col<6; ++col)for(int i=0; i<dim; ++i)for(int j=0; j<dim; ++j) coul[col][i][j]=col;
for(int i=0; i<6; ++i) this.f[i]=FACE(dim,n=listenormales[i],coul[i]);
}
void dessinercube(bool num=false,triple pos=(0,0,0),real alphax=0, real alphay=0, real alphaz=0) {
transform3 trrr=shift(pos)*rotate(alphaz,Z)*rotate(alphay,Y)*rotate(alphax,X);
draw(trrr*shift(-.499this.dim,-.499this.dim,-.499this.dim)*scale3(.998dim)*unitcube,black);
for(int i=0; i<6; ++i) {
this.f[i].dessinerface(this.f[i].n,num=num,pos=pos,alphax=alphax,alphay=alphay,alphaz=alphaz);
}
}
}
CUBE c1=CUBE(dim=4);
c1.dessinercube(num=true);
CUBE c2=CUBE(dim=3,
new FACE[] {FACE(dim=3,n=X,new int[][] {{0,0,0},{0,0,0},{0,0,0}}), // couleurs de 0 à 5 dans la liste suivante :
FACE(dim=3,n=Y,new int[][] {{1,1,1},{1,1,1},{1,1,1}}), // listecouleurs={red,blue,.95white,orange,.5green,yellow};
FACE(dim=3,n=Z,new int[][] {{3,2,2},{2,2,2},{2,2,2}}),
FACE(dim=3,n=-X,new int[][] {{3,3,3},{3,3,3},{3,3,4}}),
FACE(dim=3,n=-Y,new int[][] {{4,4,2},{4,4,4},{4,4,4}}),
FACE(dim=3,n=-Z,new int[][] {{5,5,5},{5,5,5},{5,5,5}}),
});
c2.dessinercube(pos=(0,5,0),alphay=30,alphaz=135);
Il reste à ajouter les procédures pour tourner les faces... ce sera peut-être pour plus tard, peut-être pour jamais... car je ne fais cela que pour m'amuser, sans aucun but autre que celui d'apprendre un peu mieux Asymptote... et donc tout le reste est prioritaire.