Wie dynamisch 3D-Objekt zu konstruieren, indem Pfade Zugabe? (Java, OpenGL)

Question

Also ich einige Bahngenerator haben, die nun wie folgt funktioniert

http://www.openprocessing.org/visuals/?visualID=2615 (Es gibt Quelle; WQRNING - Java-Applet)

Ich möchte einige 3D-Objekt erstellen, Pfade unter Verwendung von I erzeugt, so dass es in einem der Perspektiven ähnlich wie gesperrt, was ich jetzt in 2D.

So wie ich dynamisch konstruieren 3D-Objekt durch Pfade hinzufügen?

BTW: eigentlich habe ich ment-Algorithmus wie folgt: http://www.derschmale.com/2009/07/20/slice-based-volume-rendering-using-pixel-bender/

Also habe ich von solchen PATH erstellen möchten (ich will nicht, Bilder verwenden, und ich will nicht zu verwenden Flash Ich möchte Java + OpenGl verwenden)

solches 3D-Bild (Beachten Sie aber ich openGL Java und Path will))

Answer 1

Ich bin nicht sicher, ob ich verstehe, was Sie nach.

Das Beispiel Sie geliefert zieht 2d Pfade, sondern nur verwendet z. Skalierung hätte gearbeitet in ähnlicher Weise.

  

Wie also zu dinamicly konstruieren 3d   Objekt durch den Pfad der Zugabe?

Wollen Sie damit sagen Extrudieren / Lattung ein Objekt oder das Knirschen Skizze zu replizieren?

einen Pfad Zeichnung ist einfach in der Verarbeitung, die Sie gerade Platz Vertex Objekte, in ein für Schleife zwischen beginShape () und endShape () Anrufe.

Hier ist das Bit-Code, der in dem Beispiel tut, dass Sie gesendet haben:

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

Sie können auch Vertex nennen (x, y, z)

Ich wollte einen Weg ein extrudieren, während zurück, hier meine Frage ist , falls es hilft.

Prinzipskizze Uploaded hier .

EDIT: Wenn Sie ein Array von 2 Polygone haben, können Sie nur eine Schleife durch sie und ziehen mit etwas Ähnliches wie beginShape () und endShape (), GL_POLYGON könnte sehr nützlich sein.

z.

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();
}

Die Idee ist, dass Sie eine Schleife durch jede Scheibe, und für jede Scheibe der Schleife durch alle seine Punkte. Offensichtlich Scheiben und die Anzahl der 3D-Vektoren innerhalb jeder Scheibe ist auf die Daten auf. Apropos, wo sich Ihre Daten stammen aus?

Wenn Scheiben ist nicht das, was Ihr nach Voltron nützlich sein könnte: Voltron http://dm.ncl.ac.uk/joescully/voltronlib /images/s2.jpg

HTH, George