Java - OpenGL: 1 = 0.333 ???

[PGI]

Non trovo neanche le parole per spiegarlo. Al 99.9 percento mi sono perso in un bicchier d'acqua, tuttavia sto affogando e allora... HELP.

Ecco cosa succede:

in OpenGL creo una cassa di 1x1x1 e la posizione nel punto (0,0,0)

a questo punto creo una seconda cassa, sempre di 1x1x1. Per non sovrapporla all'altra trasformo le sue coordinate spostandola di 1 lungo l'asse delle X, direzione positiva. Transformo pertanto il solido aggiungendo il vettore (1, 0, 0) ad ogni suo punto.

Logico, no? No, perchè per spostare una cassa lunga 1 di 1 devo aggiungere 0.3 periodico...

Quello che non capisco è perchè diavolo se il cubo è alto una unità e viene visualizzato come alto una unità, per spostarlo di una unità devo aggiungere-togliere 0.3333.

Il codice per la trasformazione dei 4 vertici (v0, v1, v2, v3, "tuple" da 3 float) mi sembra ok:

public final void translate(final float x, final float y, final float z) {
	v0.x += x;
	v0.y += y;
	v0.z += z;
		
	v1.x += x;
	v1.y += y;
	v1.z += z;
		
	v2.x += x;
	v2.y += y;
	v2.z += z;
		
	v3.x += x;
	v3.y += y;
	v3.z += z;
}

eppure non mi pare di aver letto di questa stranezza nei vari blue-red book...

aita, aita!

Ciao.

[Mason]

Logico, no? No, perchè per spostare una cassa lunga 1 di 1 devo aggiungere 0.3 periodico...

O_o
o_O

una scatola lunga 1 di 1 e' lunga 1, usa cubo unitario, non scatola di 1 x 1 x 1
per spostarla la trasli, non ci aggiungi 0.3 peridoico

di solito si procede cosi in open gl

setti modelviev
resetti la matrice
gli setti tramite una glTranslate di quanto vuoi traslare(tramite il vettore di traslate supposto 1 0 0)
gli passi la primitiva del cubo.

supposto tutto l'init di opengl sia +o- giusto

prendi con calma, mi sembra stia facendo un po di confusione

cmq dai un occhio ai tutorial di nehe, se leggi leggi il red book, il bluebook sono le man pages.

cmq posta al max tutto il codice o mettilo da qualche parte, la procedura che hai messo non e molto esplicativa

[cionci]

Giusto... Dovresti usare glTranslate per spostarla

[PGI]

grazie per essere venuti in soccorso.

Per l'init ho usato il codice di Nehe (la svista è sempre dietro l'angolo ma mi sembra sia ok).

Posto quelle parti di codice che, nell'ordine, compongono la scena (i nomi dei metodi chiamati su "gl" corrispondono alle funzioni OpenGL)

inizializzazione di OpenGL

	public final void init(GLDrawable drawable) {
		System.out.println("INIT");
		GL gl = drawable.getGL();
		GLU glu = drawable.getGLU();
		
		gl.glShadeModel(GL.GL_SMOOTH);
		gl.glClearColor(0f, 0f, 0f, 0f); // sfondo nero
		gl.glClearDepth(1f); //buffer di profondità
		gl.glEnable(GL.GL_DEPTH_TEST);
		gl.glDepthFunc(GL.GL_LEQUAL);
		gl.glEnable(GL.GL_TEXTURE_2D);
		// prospettiva migliore
		gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);

sempre nell'init, di seguito, creo un "muro" ed un "tetto"

                //muro
		box = new Box(10, 3, 1);
		box.mulTexCoords(10, 3, Box.FACE_BACK | Box.FACE_FRONT);
		box.mulTexCoords(1, 3, Box.FACE_RIGHT | Box.FACE_LEFT);
		box.setTexture(texture1);
		boxes.add(box);

		//tetto
		Box box4 = new Box(10, 0.1f, 10);
		box4.translate(0, WeirdMath.weirdUnit(3), WeirdMath.weirdUnit(10));
		box4.mulTexCoords(10, 10, Box.FACE_TOP | Box.FACE_BOTTOM);
		box4.setTexture(texture3);
		boxes.add(box4);

Quel "WeirdMath.weirdUnit(3)" moltiplica 3x0.333. Il primo oggetto (box) è alto 3. Per piazzargli sopra il secondo dovrei "alzarlo" di 3. Nel mio mondo tutto strano devo alzarlo di 3x0.333.

Il ciclo di rendering poi è breve. "boxes" è una lista di tutti gli oggetti "Box" da visualizzare:

	public final void display(GLDrawable drawable) {
		GL gl = drawable.getGL();
		GLU glu = drawable.getGLU();
		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
		gl.glLoadIdentity();
		
		time1 = System.currentTimeMillis();
		dTime = time0 - time1;
		
		player.update(dTime);
		
		gl.glRotatef(360 - player.getYAngle(), 0, 1, 0);
		gl.glTranslatef(-player.getX(), -player.getY(), -player.getZ());
		
		for(Box b : boxes) {
			if(player.distanceSquare(b.getLocation()) < 400f)
				b.draw(gl);
		}
		time0 = time1;
	}

La fantomatica classe Box è un parallelepipedo. Incollo la parte significativa.

	public Box(float x, float y, float z) {
		bound = new RectBound2f(0, 0, x, z);
		
		Tuple3f v0 = new Tuple3f(0, 0, 0);
		Tuple3f v1 = new Tuple3f(x, 0, 0);
		Tuple3f v2 = new Tuple3f(x, y, 0);
		Tuple3f v3 = new Tuple3f(0, y, 0);
		Tuple3f v4 = new Tuple3f(0, y, -z);
		Tuple3f v5 = new Tuple3f(x, y, -z);
		Tuple3f v6 = new Tuple3f(x, 0, -z);
		Tuple3f v7 = new Tuple3f(0, 0, -z);
		
		faces[0] = new Quad(v1, v2, v0, v3);
		faces[1] = new Quad(v6, v5, v1, v2);
		faces[2] = new Quad(v7, v4, v6, v5);
		faces[3] = new Quad(v0, v3, v7, v4);
		faces[4] = new Quad(v1, v6, v0, v7);
		faces[5] = new Quad(v2, v5, v3, v4);
	}
	
	public void setTexture(int texture) {
		this.texture = texture;
	}
	
	public void draw(GL gl) {
		if(texture >= 0)
			gl.glBindTexture(GL.GL_TEXTURE_2D, texture);
		faces[0].draw(gl);
		faces[1].draw(gl);
		faces[2].draw(gl);
		faces[3].draw(gl);
		faces[4].draw(gl);
		faces[5].draw(gl);
	}

anche Quad non ha molta fantasia:

	public Quad(Tuple3f v0, Tuple3f v1, Tuple3f v2, Tuple3f v3) {
		this.v0 = v0;
		this.v1 = v1;
		this.v2 = v2;
		this.v3 = v3;
		
		t0 = new Tuple2f(1, 0);
		t1 = new Tuple2f(1, 1);
		t2 = new Tuple2f(0, 0);
		t3 = new Tuple2f(0, 1);
	}
	
	public final void draw(GL gl) {
		gl.glBegin(GL.GL_TRIANGLE_STRIP);
		gl.glTexCoord2f(t0.x, t0.y);
		gl.glVertex3f(v0.x, v0.y, v0.z);
		
		gl.glTexCoord2f(t1.x, t1.y);
		gl.glVertex3f(v1.x, v1.y, v1.z);
		
		gl.glTexCoord2f(t2.x, t2.y);
		gl.glVertex3f(v2.x, v2.y, v2.z);
		
		gl.glTexCoord2f(t3.x, t3.y);
		gl.glVertex3f(v3.x, v3.y, v3.z);
		gl.glEnd();
	}

Non uso glTranslate per le "casse" perchè vorrei definire lo spostamento una volta sola, anzichè inserire nel ciclo di rendering una trasformazione per ogni oggetto Box. Il costruttore di Box crea una "cassa" (insisto ) di lunghezza (x, y, z) inizialmente collocata nel punto (0,0,0). Potrei benissimo definire un costruttore che permetta di specificare il punto di partenza anzichè trasformare le coordinate successivamente alla creazione (e sono quasi certo che lì 1 sarebbe uguale a 1 e non a 0.33), ma non riesco a capire perchè la trasformazione successiva (è il metodo "translate" che ho postato precedentemente e che appartiene alla classe Quad) dia quel bizzarro risultato.

aita2.

[Mason]

mm ho riletto il tuo msg tipo 4 volte ,sta cosa del 3*1/3 mi e stata di difficile comprensione

per il fatto di "cassa" figurati solo non quotarla piu io era solo perche trovavo buffo cassa 1x1x1, l'importante e capirsi nel definito, poi se li chiamano mucchepazze o metri poco cambia

alcune precisazioni, il cubo non e proprio centrato in 0,0,0 ma in x/2 ,y/2 ,0, per crearlo centrato devi cambiare le minime coordinate della primitiva a -x -y e -z al posto che 0, questo te lo dico perche' , pur essendo un trascurabile errore geometrico, mi fa sospettare che tu non abbia ben chiara la distinzione tra coordinate globali(o mondo) e coordinate locali.(ps il -z lo fai, perche non fai anche -z e -y?, strana primitiva )

con quella traslate, modificanod proprio i vertici dell oggetto, non l'oggetto, tu perdi il sistema di riferimento locale dell'oggetto, o per lo meno, lo fai conicidere col sistema mondo, quindi diventa poco significativo.

metti di avere un modello di bernarda:
la sua geometria interna e definita come un tot di vertici attorno ad un suo centro
questo e il centro del sistema di riferimento locale

ora mettiamo sta bernarda in uno spazio e volgiamo che la bernarda si sposta in 2,2,0.

metti ora di volere ruotare la bernarda di 90 risp a z
settata la matrice di rotazione, tu non puoi ruotare i punti che hai perche senno ruoteresti anche la distanza 2 dal centro del tuo mondo, quindi dovresti sottrarre 2,2,0 ruotare e poi ritraslare a 2,2,0.

incece di aggiungere a tutti i vertici bernarda all'inzio 2,2,0 costruiamo un vettore tras(per tenere in memoria per te la traslazione di questa istanza di bernarda,non per opengl),al inizio tras sara 0,0,0, quidni la modelview(supposta identita') non cambiera.
settata a 2,2,0 e comunicata a opengl tramite la transalte sara' piu o meno simile al tuo codice.
ora supponiamo di ruotare.
a me basta resettare la modelview e metterci nel ordine una rotare e poi traslare tramite il vect che avevo(supponi un altro vect per il rotate e uno scalare per lo scale). tu dovresti come detto sopra sottrarre prima ruotare e poi ritraslare

metti ora di voler ritraslare, ruotare rispetto a y(rispetto al suo punto) ritraslare
a me basta resettare la modelview, ruoto z, ruoto y (...), traslo il tutto in 5 linee di codice tipo
col tuo metodo dovresti tenere traccia di tutti i cambiamenti dei vertici se vuoi metterci un operazione in mezzo

e un po come se modificando la geometria dei punti bernardi aggiungendoci 2,2,0 modifichi proprio la classe berndarda, dicendo "tutte le bernarde sono distanti 2,2,0 dal centro", come idea.

giusto perche spiego(parlo) come mangiare pane e prociutto(parole di un mio prof) ti faccio un altro esempio di come vedo i 2 metodi.

per me e come se tu avessi un cubo di ferro sotto la mano sx,e vuoi spostarlo di un 50 cm piu a sx.
io ci vedo 2 metodi:
prendi l'oggeto in se e lo sposti di 50 cm.
prendi un martello e spsoti tutti gli atomi singolarmente del cubo di 50 cm.
il risultato sara' quello, tutti gli atomi del cubo son spostati di 50 cm, la strada per spostarli non proprio.

secondo me quello che fai tu e piu da geometria computazionale che da opengl con quella translate, e cmq ti consiglio per esercizio di passarla a matrice 4x4.

tornando al prob di questo 1/3 che gira e non si sa bene del perche' fai una cosa: posta tutto il codice tipo allegato se possibile , almeno eseguo proprio e non ci penso sopra troppo, anche perche sara il fascino del periodico nel 3 ma mi sembra molto strano(come dici anche tu mi pare).

ultima cosa, da quel player.getdistance<400 sembra tu voglia settare una profondita' massima di visualizzazione, in opengl ci son gia queste chiamate nella gluperspective o cmq nell primitive di proiezione.

[PGI]

Grazie per aver avuto la pazienza di leggere il codice.

Il -z era un residuato bellico, prima erano tutti "-", avrebbero dovuto diventare tutti "+", ho perso un pezzo per strada.

Potrei applicare la trasformazione nel ciclo di rendering associando ad ogni oggetto 3D un secondo oggetto Transform usandolo poi come riferimento per glTranslate & rotate tuttavia così facendo introduco 4 operazioni per oggetto ad ogni passaggio nel ciclo di rendering, per visualizzare elementi di cui conosco in partenza le coordinate finali e la cui posizione non sarà modificata (salvo le trasformazione globali, ma mi viene più facile pensare che sia il giocatore a muoversi e non tutto il mondo intorno al giocatore ).

E' lecito dire: "e perchè cavolo non costruisci direttamente l'oggetto a (x,y,z) anzichè a (0,0,0) per poi spostarlo a (x,y,z)?". Beh, perchè se lo costruisco direttamente a x,y,z...funziona, mentre se lo costruisco a 0 e poi lo sposto salta fuori quel malefico 0.3 periodico.

Adesso vedo un po' la questione delle coordinate locali e globali, forse ho fatto qualche trasformazione inconsapevole. Se non ne salto fuori posto una versione condensata di tutto il motore per centrare il problema.

Ciao.