Jump to content
n3mesi83

Curva Di Rotazione Opengl

Recommended Posts

Buongiorno a tutti,

sto cominciando ora ad interessarmi al mondo delle openGL.

Quello che vorrei fare è una cosa credo abbastanza semplice, ovvero da una curva generare una superficie di rotazione.

Utilizzo c come linguaggio di programmazione.

Per ottenere questa superficie, utilizzo gli "evaluators" e la mapgrip:

glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 8, &array[0][0][0]);

glEnable(GL_MAP2_VERTEX_3);

glEnable(GL_AUTO_NORMAL); //per l'illuminazione

glMapGrid2f(50.0, 0.0, 1.0, 50.0, 0.0, 1.0);

dove array è un array dei punti di controllo.

Questo array lo riempio dinamicamente prima di crearmi la finestra con la scena. Mi spiego meglio:

Nella prima parte del programma inserisco le coordinate x e z dei punti di controllo e vado a riempire l'array calcolandomi tutti i punti di controllo per la rotazione attorno all'asse z:

double x, y, z;

int i,j;

int k=0;

float angolo = 36*3.141593/180; //trasformo l'angolo in radianti (l'argomento del sin e cos è in radianti)

printf("\n Inserisci il numero dei punti di controllo della curva: ");

scanf("%i", &numVertici);

for(i=0; i<numVertici; i++)

{

printf("\n punto %i, ordinata x: ", i);

scanf("%lf", &x);

printf("\n punto %i, ordinata z: ", i);

scanf("%lf", &z);

for (j = 0; j < 50; j++)

{

float ang = angolo * (j);

array[j][0] = x*cos(ang);

array[j][1] = x*sin(ang);

array[j][2] = z;

}

}

Poi nella display utilizzo la glEvalMesh2(GL_FILL, 0, 50, 0, 50);

Ecco il mio problema: questo è ciò che mi esce fuori:

figura1.jpg

Sembra che la rotazione si fermi intorno ai 240 gradi, anzichè continuare fino a 360. Qualcuno di voi sa spiegarmi il motivo?

Sbaglio procedura (nel senso c'è un altro modo per ottenere una superficie di rotazione ruotando per l'asse z una curva), oppure sbaglio qualche parametro?

Grazie per l'attenzione.

Share this post


Link to post
Share on other sites

Non si vede l'immagine. :(

Premetto che non ho mai usato gli evalutator (non vengono accelerati via hardware e sono deprecati).

Comunque, tu inserisci n punti e poi li ruoti attorno ad un asse.

Array come è inizializzato? come fai a indizzarlo per i se non sai la dimensione a priori? Da come sembra si direbbe che l'array non sia contiguo.

Inoltre j lo fai variare da 0 a 50, questo vuol dire che ang varierà tra 0 e (1/5 * pi * 50) = 10*pi. Sembra che tu gli faccia fare 5 giri. :-\

Share this post


Link to post
Share on other sites

Grazie per la risposta.

Provo a riallegare l'immagine:

post-57079-1240475163_thumb.jpg

Mi spiego meglio...l'array è così istanziato: float array[50][4][3].

Lo so che gli faccio fare 5 giri, avevo provato con un solo giro, ma la rotazione non si chiudeva, allora mi sono ostinato, ho provato con 5 giri ma stesso risultato.Quando intendo che la rotazione non si chiude intendo ciò che si vede (ora spero di si) nell'immagine allegata.

La stampa dell'array è questa, per i dati in input:

P0(1.5, 0.0, 3.5)

P1(2.3,0.0, -1.2)

P2(4.1, 0.0, 2.1)

P3(6.0, 0.0, 5.1)

e array (per un solo giro (cioè j=10, tanto poi i punti di controllo si ripetono):

(1.500000, 0.000000, 3.500000) (2.300000, 0.000000, -1.200000) (4.100000, 0.000000, 2.100000) (6.000000, 0.000000, 5.100000)

(1.213525, 0.881678, 3.500000) (1.860739, 1.351906, -1.200000) (3.316969, 2.409920, 2.100000) (4.854102, 3.526712, 5.100000)

(0.463525, 1.426585, 3.500000) (0.710739, 2.187430, -1.200000) (1.266969, 3.899332, 2.100000) (1.854101, 5.706339, 5.100000)

(-0.463526, 1.426585, 3.500000) (-0.710740, 2.187430, -1.200000) (-1.266971, 3.899332, 2.100000) (-1.854104, 5.706338, 5.100000)

(-1.213526, 0.881678, 3.500000) (-1.860739, 1.351905, -1.200000) (-3.316970, 2.409919, 2.100000) (-4.854103, 3.526710, 5.100000)

(-1.500000, 0.000000, 3.500000) (-2.300000, -0.000001, -1.200000) (-4.100000, 0.000000, 2.100000) (-6.000000, -0.000002, 5.100000)

(-1.213525, -0.881679, 3.500000) (-1.860738, -1.351907, -1.200000) (-3.316968, -2.409921, 2.100000) (-4.854100, -3.526714, 5.100000)

(-0.463525, -1.426585, 3.500000) (-0.710738, -2.187430, -1.200000) (-1.266968, -3.899330, 2.100000) (-1.854100, -5.706340, 5.100000)

(0.463526, -1.426584, 3.500000) (0.710740, -2.187430, -1.200000) (1.266972, -3.899331, 2.100000) (1.854105, -5.706338, 5.100000)

(1.213526, -0.881677, 3.500000) (1.860740, -1.351905, -1.200000) (3.316972, -2.409917, 2.100000) (4.854102, -3.526707, 5.100000)

Si può fare la stessa cosa senza l'uso degli evaluators?

Grazie mille per l'attenzione!

Share this post


Link to post
Share on other sites

ho letto un po' la documentazione di glMap2f ed è l'ordine che controlla la dimensione della griglia di punti di controllo.

Tu hai impostato l'ordine u corretto(4) ma l'ordine v sbagliato (8), ho provato e ho visto che oltre l'ottavo grado non disegna niente. In pratica tu puoi mettere anche mille control point, ma ti vengono presi solo i primi otto.

Se vuoi puoi fare diverse patch contigue, ma a questo punto immagino tu debba creare un evalutatore per le normali per renderle contigue.

Sono riuscito a fare una forma chiusa mettendo l'angolo a 90° e ho usato 5 control point e poi ho chiamato in questa maniera

glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 5, controlPoints[0]);

notare che c'è 5 al ordine V.

Ma così facendo i bordi non vengono contigui.

Visto che gli evalutatori sono deprecati e sono stati eliminati in openGL 3.1 ti consiglio di calcolarti la posizione di tutti i punti e delle normali a mano con un po' di matematica, calcolarti gli indici dei poligoni e mettere tutto in un paio di buffer, in questa maniera hai pieno controllo di quello che va alla scheda video e va anche più veloce. :)

Ciaoo!!

Share this post


Link to post
Share on other sites
Visto che gli evalutatori sono deprecati e sono stati eliminati in openGL 3.1 ti consiglio di calcolarti la posizione di tutti i punti e delle normali a mano con un po' di matematica, calcolarti gli indici dei poligoni e mettere tutto in un paio di buffer, in questa maniera hai pieno controllo di quello che va alla scheda video e va anche più veloce. :)

Prima di tutto grazie mille per il tuo interesse...

quindi se ho capito bene, dovrei in primis con i 4 punti di controllo generare una curva (quindi glmap1f ecc) e usare per questa curva gli evaluator, poi parametrizzare la curva e per ogni punto (all'interno di una glbegin e glend quad_strip) della curva calcolarmi le nuove coordinate per ogni spicchio fino a ottenere una rotazione di 360° sull'asse z.

Scusa un'altra domanda banale, ma come faccio a calcolarmi la posizione di tutti i punti?

Grazie ancora.

Share this post


Link to post
Share on other sites

Appunto con un po' di matematica

la rotazione antioraria attorno a Y è:

x = cos(alpha) * x - sin(alpha) * z;

z = sin(alpha) * x + cos(alpha) * z;

o se vuoi sotto forma matriciale

   |cos(alpha) 0 -sin(alpha)|

m =|0		  1		   0|

   |sin(alpha) o  cos(alpha)|

p' = m*p;

dove p è un vettore colonna con il tuo punto. m è la matrice non il determinante ovviamente.

Altra cosa, la glBegin è un refuso di openGL 1.0 e non andrebbe mai usata nei programmi moderni. Guardati queste due pagine sui vertex buffer object:

http://www.songho.ca/opengl/gl_vbo.html

http://developer.nvidia.com/object/using_VBOs.html

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.


  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...