Come costruire dinamicamente oggetti 3D con l'aggiunta di percorsi? (Java; OpenGL)

Question

Così ho qualche generatore di percorso che ora funziona in questo modo

http://www.openprocessing.org/visuals/?visualID=2615 (Non v'è fonte; WQRNING - Applet Java)

Voglio creare un oggetto 3D utilizzando percorsi ho generato in modo bloccato in uno dei punti di vista simile a quello che ho ora in 2D.

Allora, come faccio in modo dinamico costruisco oggetti 3D con l'aggiunta di percorsi?

A proposito: in realtà mi MENT algoritmo come questo http://www.derschmale.com/2009/07/20/slice-based-volume-rendering-using-pixel-bender/

Quindi voglio creare da tale percorso (non voglio usare le immagini e non voglio usare il flash voglio usare Java + OpenGL)

come immagine 3D (ma nota che voglio jogl e percorso di))

Answer 1

Non sono sicuro di capire quello che stai dopo.

L'esempio che hai fornito disegna percorsi 2d, ma semplicemente utilizza z. ridimensionamento avrebbe funzionato in modo simile.

  

Come dinamicly costruire 3d   oggetto con l'aggiunta di percorso di?

Vuoi dire estrusione / tornitura di un oggetto, o replicare lo schizzo Scrunch?

disegno di un percorso è facile in lavorazione, è sufficiente posizionare vertex oggetti, in un per il ciclo tra beginShape () e endShape () le chiamate.

Ecco il pezzo di codice che fa che nell'esempio che hai inviato:

 beginShape(); 
  for (int p=0; p<pcount; p++){ 
    vertex(Ring[p].position().x(),Ring[p].position().y()); 
  } 
  endShape(CLOSE);

è possibile contattare vertice (x, y, z)

ho voluto estrudere un percorso un po 'indietro, ecco la mia domanda in caso aiuta.

schizzo di base viene caricato qui .

EDIT: Se si dispone di una serie di 2 poligoni, si può solo ciclo attraverso di loro, e disegnare usando qualcosa di simile a beginShape () e endShape (), GL_POLYGON potrebbe essere a portata di mano.

per es.

import processing.opengl.*;
import javax.media.opengl.*;

int zSpacing = 10;
PVector[][] slices;

void setup() {
  size(600, 500, OPENGL);

  slices = new PVector[3][3];
  //dummy slice 1
  slices[0][0] = new PVector(400, 200,-200);
  slices[0][1] = new PVector(300, 400,-200);
  slices[0][2] = new PVector(500, 400,-200);
  //dummy slice 2
  slices[1][0] = new PVector(410, 210,-200);
  slices[1][1] = new PVector(310, 410,-200);
  slices[1][2] = new PVector(510, 410,-200);
  //dummy slice 3
  slices[2][0] = new PVector(420, 220,-200);
  slices[2][1] = new PVector(320, 420,-200);
  slices[2][2] = new PVector(520, 420,-200);
}

void draw() {
  background(255);

  PGraphicsOpenGL pgl = (PGraphicsOpenGL) g;  // g may change
  GL gl = pgl.beginGL();  // always use the GL object returned by beginGL

  for(int i = 0 ; i < slices.length; i ++){
    gl.glColor3f(0, .15 * i, 0);
    gl.glBegin(GL.GL_POLYGON);
    for(int j = 0; j < slices[i].length; j++){
      gl.glVertex3f(slices[i][j].x, slices[i][j].y,slices[i][j].z + (zSpacing * i));
    }
    gl.glEnd();
  }
  pgl.endGL();
}

L'idea è che si ciclo attraverso ogni fetta, e per ogni sezione il vostro ciclo attraverso tutti i suoi punti. Ovviamente fette e il numero di vettori 3d all'interno di ogni fetta è fino ai dati. A proposito, da dove viene i dati provengono da?

Se fette non è quello che il vostro dopo Voltron potrebbe tornare utile: Voltron http://dm.ncl.ac.uk/joescully/voltronlib /images/s2.jpg

HTH, George