[JAVA3D] problema rotazione ambiente

[Marbury]

salve, ho un problema che non riesco a risolvere, in pratica disegno un cubo che non è altro che tanti Box inseriti vicini e vorrei far ruotare il sistema però non ci riesco, posto il codice e spiego perchè:

public class Cubo extends TransformGroup{
	private Box box;
	private static TextureLoader loader=new TextureLoader("red.jpg",null);
	private static TextureLoader loader2=new TextureLoader("green.jpg",null);
	
	public Cubo(float x, float y, float z){
		super();
		//System.out.println("CREA CUBO");
		Transform3D transform = new Transform3D();
		Vector3f vector = new Vector3f(x,y,z);
		transform.setTranslation(vector);
		setTransform(transform);
		
    	Appearance a = new Appearance();
    	
        a.setTexture(loader.getTexture());
        TextureAttributes texAttr = new TextureAttributes();
    	texAttr.setTextureMode(TextureAttributes.MODULATE);
    	a.setTextureAttributes(texAttr);         
		
	/*	Material mat = new Material();
        mat.setDiffuseColor(new Color3f(1.0f, 0.0f, 0.0f));
        //mat.setSpecularColor(new Color3f(1.0f, 0.0f, 0.0f));
        mat.setShininess(1.0f);
        a.setMaterial(mat);*/
        
		box = new Box(0.1f, 0.1f, 0.1f, Box.GENERATE_TEXTURE_COORDS, a);
        box.setAppearance(a);
        
		addChild(box);
		
	}

Qui disegno tutti i cubi e se inserisco il codice per la rotazione qui mi da il problema che invece di far ruotare il sistema "centralmente" ruota attorno all'ultimo cubo inserito

class GruppoCubo extends TransformGroup{
	//Memorizza puntatori alle matrici che contengono i cubi
	private Vector<Cubo[][]> facce = null;
	private int numCubiRiga = 0; 
	
	public GruppoCubo(int n, float x, float y, float z){
		numCubiRiga = n;
		Cubo[][] faccia = null;
		
		float indiceZ = 0.0f; float indiceY = 0.0f; float indiceX = 0.0f;
		int i = 0; int j = 0; //mi servono per calcolare gli indici dove salvare i cubi
		
		while(indiceZ > (-n*0.23f)){
			//System.out.println("indiceZ, n = " + (-n*0.1f) + " "+indiceZ);
			i = 0; j = 0;
			faccia = new Cubo[n][n];
			
			while(indiceY > (-n*0.23f)){
				//System.out.println("indiceY, n = "+ (-n*0.1f)+ " " + indiceY);
				while(indiceX < (n*0.23f)){
					//System.out.println("indiceX, n= " + (-n*0.1f)+" " + indiceX);
					faccia[i][j] = new Cubo(indiceX, indiceY, indiceZ);
					if(indiceX == 0.0f) (faccia[i][j]).coloraCubo(1);
					addChild(faccia[i][j]);
					indiceX = indiceX + 0.23f;
					i += 1;	
				}
				indiceX=0;
				i=0; j = j+1;
				indiceY = indiceY - 0.23f;
			}
			indiceY=0;
			indiceZ = indiceZ -0.23f;
		}
		
		System.out.println("OUT");
		
		
		Vector3f vector = null;
		Transform3D transform = new Transform3D();
		transform.setScale(1);
		vector = new Vector3f(x,y,z);
		transform.setTranslation(vector);
		setTransform(transform);
		setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
		
		//Crea il behavior per ruotare il cubo
   	/*	RotazioneCubo rc = new RotazioneCubo(/*cuboGrafico*///);
   	/*	RotazioneMouse myMouseRotate2= new RotazioneMouse(this,rc);
   		myMouseRotate2.setSchedulingBounds(new BoundingSphere());
   		addChild(myMouseRotate2);*/
	}

Questa classe estende simpleUniverse e se lo scrivo qua non ruota proprio nulla!!! Credevo fosse quest'ultima soluzione quella giusta e invece... qualcuno ha qualche idea da darmi? Grazie mille

public class DrawCubo extends SimpleUniverse{
	private GruppoCubo cubo;
	private BranchGroup root = null;
	
	//Riceve come parametro il num elementi di una riga
	public DrawCubo(int n, Canvas3D canvas){
		super(canvas);
		
		switch (n){
			case 5: cubo = new GruppoCubo(n, 0f, 0.2f, -2f); 
			break;
			case 10: cubo = new GruppoCubo(n, 0f, 0.1f, -10f);
			break;
			case 15: cubo = new GruppoCubo(n, 0f, -0.1f, -19f);
			break;
			case 7: cubo = new GruppoCubo(n, 0f, 0.2f, -5f);
			break;
			case 14: cubo = new GruppoCubo(n, 0f, 0.0f, -17f);
			break;
			case 21: cubo = new GruppoCubo(n, 0f, -0.2f, -29f);
			break;
			case 9: cubo = new GruppoCubo(n, 0f, 0.2f, -9f);
			break;
			case 18: cubo = new GruppoCubo(n, 0f, -0.15f, -24f);
			break;
			case 27: cubo = new GruppoCubo(n, 0f, -0.3f, -39f);
			break;	
		}
		
		root = new BranchGroup();
		
		root.addChild(cubo);
		getViewingPlatform().setNominalViewingTransform();
	/*	
		TextureLoader loader=new TextureLoader("sfondo.jpg",null);
		ImageComponent2D image=loader.getImage();
		Background bg = new Background(image);
		BoundingSphere infinity = new BoundingSphere(new Point3d(), Double.POSITIVE_INFINITY);
		bg.setApplicationBounds(infinity);
		
		root.addChild(bg);*/
		
		//Crea un gruppo per le trasformazioni affini
    	TransformGroup objRotate=new TransformGroup();
    	objRotate.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    	objRotate.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
    	//Crea il behavior per ruotare il cubo
   		RotazioneCubo rc = new RotazioneCubo(/*cuboGrafico*/);
   		RotazioneMouse myMouseRotate2= new RotazioneMouse(objRotate,rc);
   		myMouseRotate2.setSchedulingBounds(new BoundingSphere());
   		root.addChild(myMouseRotate2);
    	root.addChild(objRotate);
    	
    	root.compile();
    	
    	addBranchGraph(root);

[PGI-Bis]

Crea un TransformGroup "ruotabile" (setCapability eccetera), chiamiamolo A. Aggiungi al TransformGroup un BranchGroup, aggiungi tutti i cubi a questo BranchGroup.

A questo punto se fai ruotare "A" ruota anche tutto quello che è agganciato ad A.

Il problema della rotazione intorno al centro lo risolvi o con una rototraslazione di A o con una rotazione semplice di A ed una distribuzione dei cubi attorno al centro di A.

Per distribuire rapidamente i cubi puoi aggiungere ad A un secondo TransformGroup B, aggiungere i cubi a B e traslare B di un vettore V = (-x/2, -y/2, -z/2), con x, y e z lunghezze dei lati del "super-cubo" formato dai tanti cubetti. A conti fatti Java3D transformerà la faccenda in una rotazione di A intorno al punto P centro del gruppo di cubi.

[Marbury]

grazie mille adesso provo

[Marbury]

ho fatto cosi però non cambia nulla:

class GruppoCubo extends TransformGroup{
	//Memorizza puntatori alle matrici che contengono i cubi
	private Vector<Cubo[][]> facce = new Vector<Cubo[][]>();
	private int numCubiRiga = 0; 
	
	public GruppoCubo(int n, float x, float y, float z){
		numCubiRiga = n;
		Cubo[][] faccia = null;
		
		//Creo un BranchGroup dove attaccare i cubi
		BranchGroup branch = new BranchGroup();
		//Creo un nuovo TransformGroup B per la rotazione al centro
		TransformGroup B = new TransformGroup();
		
		float indiceZ = 0.0f; float indiceY = 0.0f; float indiceX = 0.0f;
		int i = 0; int j = 0; //mi servono per calcolare gli indici dove salvare i cubi
		
		while(indiceZ > (-n*0.23f)){
			//System.out.println("indiceZ, n = " + (-n*0.1f) + " "+indiceZ);
			i = 0; j = 0;
			faccia = new Cubo[n][n];
			
			while(indiceY > (-n*0.23f)){
				//System.out.println("indiceY, n = "+ (-n*0.1f)+ " " + indiceY);
				while(indiceX < (n*0.23f)){
					//System.out.println("indiceX, n= " + (-n*0.1f)+" " + indiceX);
					faccia[i][j] = new Cubo(indiceX, indiceY, indiceZ);
					branch.addChild(faccia[i][j]);
					indiceX = indiceX + 0.23f;
					i += 1;	
				};
				indiceX=0;
				i=0; j = j+1;
				indiceY = indiceY - 0.23f;
			}
			facce.add(faccia);
			indiceY=0;
			indiceZ = indiceZ -0.23f;
		}
		
		System.out.println("OUT");
		
		B.addChild(branch);
		
		Vector3f vector = null;
		Transform3D transform = new Transform3D();
		
		vector = new Vector3f((n*0.1f)/2,-(n*0.1f)/2,-(n*0.1f)/2);
		transform.setTranslation(vector);
		B.setTransform(transform);
		
		transform = new Transform3D();
		transform.setScale(1);
		vector = new Vector3f(x,y,z);
		transform.setTranslation(vector);
		setTransform(transform);
		setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
		
		//Crea il behavior per ruotare il cubo
   		RotazioneCubo rc = new RotazioneCubo(/*cuboGrafico*/);
   		RotazioneMouse myMouseRotate2= new RotazioneMouse(this,rc);
   		myMouseRotate2.setSchedulingBounds(new BoundingSphere());
   		addChild(myMouseRotate2);
   		addChild(B);

[Marbury]

non riesco a risolvere, non è che potresti darmi una mano? Grazie

[PGI-Bis]

La versione più semplice è quella in cui i cubi del gruppo di cubi sono creati e distribuiti intorno al punto 0,0,0. Detta "CubeGroup" la classe che dichiara questo cubo di cubi e "getGroup()" il metodo di CubeGroup che restituisce un javax.media.j3d.node a cui sono connessi i vari cubi, il programma è semplicemente:

package cubi;

import java.awt.*;
import java.awt.event.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.behaviors.mouse.*;

public class Main implements Runnable {
	public static void main(String[] args) {
		EventQueue.invokeLater(new Main());
	}
	
	public void run() {
		final int CUBE_COUNT = 4;
		final float CUBE_EDGE = 1;
		
		/* Questo è il gruppo di trasformazione "ruotabile" con il mouse a cui
		è aggiunto il gruppo di cubi */
		TransformGroup cubeGroupRotator = new TransformGroup();
		cubeGroupRotator.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
		cubeGroupRotator.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
		
		/* Genero il cubo di cubi (distribuiti intorno al punto 0,0,0) e lo
		aggiungo al gruppo di trasformazione "ruotabile" */
		CubeGroup cubeGroup = new CubeGroup(CUBE_COUNT, CUBE_EDGE);
		cubeGroupRotator.addChild(cubeGroup.getGroup());
		
		BoundingSphere infinity = new BoundingSphere(new Point3d(), Double.POSITIVE_INFINITY);
		MouseRotate rotator = new MouseRotate(cubeGroupRotator);
		rotator.setSchedulingBounds(infinity);
		
		/* Creo una radice per i miei elementi 3d... */
		BranchGroup root = new BranchGroup();
		
		/* Aggiungo alla radice il gruppo di rotazione (a cui è connesso il
		cubo di cubi) */
		root.addChild(cubeGroupRotator);
		root.addChild(rotator);
		
		/* Creo un canvas3d e un universo 3d, aggiungo all'universo la radice
		della mia scena 3d e fine. */
		Canvas3D canvas = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
		SimpleUniverse universe = new SimpleUniverse(canvas);
		
		Transform3D viewTranslation = new Transform3D();
		viewTranslation.setTranslation(new Vector3f(0, 0, 5 * CUBE_COUNT * CUBE_EDGE));
		universe.getViewingPlatform().getViewPlatformTransform().setTransform(viewTranslation);
		
		universe.addBranchGraph(root);
		
		Frame window = new Frame("Test Cubi");
		window.add(canvas);
		window.setSize(400, 400);
		window.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) { System.exit(0); }
		});
		window.setVisible(true);
	}
}

Giusto per provare ti incollo anche CubeGroup ma questa classe è indifferente: tu i cubi li generi come preferisci, l'importante è che il super-cubo risulti centrato rispetto all'origine degli assi.

package cubi;

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.geometry.*;

public class CubeGroup {
	private BranchGroup group = new BranchGroup();
	private final float EDGE;
	private final int CUBE_COUNT;
	
	public CubeGroup(int cubeCount, float cubeEdge) {
		/* Genera un cubo di cubeCount cubi, ognuno di lato cubeEdge. I cubi sono
		distribuiti intorno al punto (0,0,0). */
		
		EDGE = cubeEdge;
		CUBE_COUNT = cubeCount;
		float groupEdge = 2.1f * CUBE_COUNT * EDGE;
		float offset = groupEdge / 2 - EDGE;
		for(int x = 0; x < cubeCount; x++) {
			for(int y = 0; y < cubeCount; y++) {
				for(int z = 0; z < cubeCount; z++) {
					Appearance appearance = new Appearance();
					Material material = new Material();
					Color3f color = new Color3f(x / (float)CUBE_COUNT, y / (float)CUBE_COUNT, z / (float)CUBE_COUNT);
					material.setEmissiveColor(color);
					appearance.setMaterial(material);
					Box box = new Box(EDGE, EDGE, EDGE, appearance);
					Transform3D transform = new Transform3D();
					Vector3f translation = new Vector3f(offset - 2.1f * x, offset - 2.1f * y, offset - 2.1f * z);
					transform.setTranslation(translation);
					TransformGroup boxLocator = new TransformGroup(transform);
					boxLocator.addChild(box);
					group.addChild(boxLocator);
				}
			}
		}
		
		group.compile();
	}
	
	public BranchGroup getGroup() {
		return group;
	}
}

E questo è l'effetto che fa.

[Marbury]

grazie mille!

Ormai che ci sei volevo chiederti ancora una cosa: se provo a creare un cubo di 27*27 quindi 27*27 cubi, si pappa tutto lo heap. E' un problema di come li ho implementati e cioè uno per transformGroup?? Grazie ancora.


edit: secondo te è fattibile fare in modo che se uno clicca su un cubo poi può trascinare tutta la "sfoglia" all'esterno, cliccare su uno dei cubi e rimetterla "al suo posto"?

[PGI-Bis]

Prova ad aumentare la dimensione dell'heap. Per farlo quando lanci il programma da console aggiungi l'opzione -Xmx seguita dal numero di megabyte che pensi ti servano. Ad esempio per dare in pasto alla JVM fino a 512 megabyte di RAM:

java -Xmx512m ...eccetera

Se ritieni che la dimensione massima dell'heap sia interamente necessaria puoi usare anche l'opzione -Xms che definisce la dimensione iniziale dell'heap. Ad esempio:

java -Xmx512m -Xms512m ...eccetera

In questo caso stabilisci che la JVM possa usare al massimo 512 megabyte di ram e che tutti e 512 i megabyte siano riservati già all'avvio.

E' senz'altro possibile aggiungere il tipo di interazione che desideri ed esistono una varietà di modi per realizzarla. Uno di questi modi è usare un TransformGroup per ogni cubetto - vale a dire aggiungere il cubetto ad un TransformGroup ed aggiungere il TransformGroup al gruppo del super-cubo. Il gruppo di trasformazione opportunamente abilitato ti permette di spostare il cubetto, il resto è una questione di "picking" e collegamento tra il movimento del mouse e lo spostamento del cubo correntemente selezionato.