Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Sa Jul 12, 2025 23:10

Foren-Übersicht » Programmierung » Allgemein 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 4 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
BenBE
BeitragVerfasst: Di Nov 25, 2008 12:46 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 17, 2005 13:19
Beiträge: 98
Wohnort: Jahnsdorf
Ich hab da eine kleine Frage. Für ein Beleg für Grafiksysteme bau ich an einem Simulationstool für Neuronale Netze. Das Ganze ist in Java geschrieben und funktioniert soweit auch. Als Knoten nehm ich Kugeln her, die ich über eine optimierte Version der gluQuadrics rendere (Performance optimiert, Funktionalität identisch).

Die Grafik wird ohne Light gerendert (derzeit), ich würde aber gerne, dass die Kugeln nicht so flach aussehen, wie es derzeit der Fall ist, sondern, dass diese so gerendert werden, als ob links oberhalb des Betrachters eine Lichtquelle vorhanden wäre.

Hier mal die relevanten Abschnitte:

Code:
  1.  
  2.     private class InternalRenderer implements GLEventListener {
  3.  
  4.         private GL gl = null;
  5.  
  6.         private GLU glu = null;
  7.  
  8.         private TextRenderer text = null;
  9.  
  10.         private long fpsLastTime = System.nanoTime();
  11.  
  12.         private int fpsLastCount = 0;
  13.  
  14.         private float fpsLastFPS = -1;
  15.  
  16.         private GLAutoDrawable gld;
  17.  
  18.         private int angle = 0;
  19.  
  20.         private final float[] lineColor = new float[] {0.2f, 0.2f, 0.2f};
  21.  
  22.         private static final float ALPHA_BLENDING = 0.50f;
  23.  
  24.         /*
  25.          * (Kein Javadoc)
  26.          *
  27.          * @see javax.media.opengl.GLEventListener#display(javax.media.opengl.GLAutoDrawable)
  28.          */
  29.         public void display(GLAutoDrawable drawable) {
  30.             fpsLastCount++;
  31.  
  32.             gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
  33.  
  34.             // Antialiasing aktivieren ^^
  35.             gl.glEnable(GL.GL_POINT_SMOOTH);
  36.             gl.glEnable(GL.GL_LINE_SMOOTH);
  37.             gl.glEnable(GL.GL_POLYGON_SMOOTH);
  38.  
  39.             gl.glDisable(GL.GL_DITHER);
  40.  
  41.             gl.glMatrixMode(GL.GL_MODELVIEW);
  42.             gl.glLoadIdentity();
  43.  
  44.             gl.glRotatef(angle / 1f, 0, 0, 1);
  45.             angle++;
  46.             angle %= 360;
  47.  
  48.             gl.glPushMatrix();
  49.  
  50.             drawCoordSys();
  51.  
  52.             drawNetworkEdges();
  53.  
  54.             drawNetworkNodes();
  55.             gl.glPopMatrix();
  56.  
  57.             drawFPSCounter(drawable);
  58.         }
  59.  
  60.  
  61.         private void drawCoordSys() {
  62. //... Code für's Zeichnen des Koordinatensystems. Nutzt Lines und Triangles zum Zeichnen.
  63.         }
  64.  
  65.         private void drawNetworkNodes() {
  66.             gl.glPushMatrix();
  67.             try {
  68.                 gl.glScalef(10f, 10f, 10f);
  69.                 if (null != net) {
  70.                     for (INetworkNode node : net.getNetworkNodes()) {
  71.                         float[] nodePos = node.getNodeLocation().getVecAbs();
  72.                         INetworkNodeDrawer nodeDraw = node.getNodeDrawer();
  73.                         if (null == nodeDraw) {
  74.                             nodeDraw = net.getDefaultNodeDrawer();
  75.                         }
  76.  
  77.                         gl.glPushMatrix();
  78.                         try {
  79.                             gl.glTranslatef(nodePos[0], nodePos[1], nodePos[2]);
  80.                             gl.glScalef(0.5f, 0.5f, 0.5f);
  81.                             nodeDraw.drawNode(gl, glu, node);
  82.                         } finally {
  83.                             gl.glPopMatrix();
  84.                         }
  85.                     }
  86.                 }
  87.             } finally {
  88.                 gl.glPopMatrix();
  89.             }
  90.         }
  91.  
  92.         private void drawNetworkEdges() {
  93.             gl.glPushMatrix();
  94.             try {
  95.                 gl.glScalef(10f, 10f, 10f);
  96.                 if (null != net) {
  97.                     for (INetworkEdge edge : net.getNetworkEdges()) {
  98.                         INetworkEdgeDrawer edgeDraw = edge.getEdgeDrawer();
  99.                         if (null == edgeDraw) {
  100.                             edgeDraw = net.getDefaultEdgeDrawer();
  101.                         }
  102.  
  103.                         gl.glPushMatrix();
  104.                         try {
  105.                             // gl.glScalef(0.5f, 0.5f, 0.5f);
  106.                             edgeDraw.drawEdge(gl, glu, edge);
  107.                         } finally {
  108.                             gl.glPopMatrix();
  109.                         }
  110.                     }
  111.                 }
  112.             } finally {
  113.                 gl.glPopMatrix();
  114.             }
  115.         }
  116.  
  117.         private void drawFPSCounter(GLAutoDrawable drawable) {
  118.             //Do the FPS counting <!-- s;-) --><img src=\"{SMILIES_PATH}/icon_wink.gif\" alt=\";-)\" title=\"Wink\" /><!-- s;-) -->
  119.             long tmpTime = System.nanoTime();
  120.             if(tmpTime - fpsLastTime > 1000000000L) {
  121.                 //More than a second passed, update the counter ...
  122.                 fpsLastTime = tmpTime - fpsLastTime;
  123.                 fpsLastFPS = 1000000000f * (float)fpsLastCount / (float)fpsLastTime;
  124.                 fpsLastCount = 0;
  125.                 fpsLastTime = tmpTime;
  126.             }
  127.             text.beginRendering(drawable.getWidth(), drawable.getHeight());
  128.             text.setColor(1.0f, 1.0f, 1.0f, 1.0f);
  129.             text.draw(String.format("%.2f fps", fpsLastFPS), 4, drawable.getHeight() - (int)text.getFont().getStringBounds("M", text.getFontRenderContext()).getHeight() - 4);
  130.             text.endRendering();
  131.         }
  132.  
  133.         /*
  134.          * (Kein Javadoc)
  135.          *
  136.          * @see javax.media.opengl.GLEventListener#displayChanged(javax.media.opengl.GLAutoDrawable,
  137.          *      boolean, boolean)
  138.          */
  139.         public void displayChanged(GLAutoDrawable drawable,
  140.                 boolean modeChanged, boolean deviceChanged) {
  141.             new Exception("displayChanged").printStackTrace(System.out);
  142.         }
  143.  
  144.         /*
  145.          * (Kein Javadoc)
  146.          *
  147.          * @see javax.media.opengl.GLEventListener#init(javax.media.opengl.GLAutoDrawable)
  148.          */
  149.         public void init(GLAutoDrawable drawable) {
  150.                 gld = drawable;
  151.  
  152.                 gl = gld.getGL();
  153.                 //gld.setGL(new DebugGL(gld.getGL()));
  154.                 //gl = gld.getGL();
  155.                 //gld.setGL(new TraceGL(gld.getGL(), System.out));
  156.                 //gl = gld.getGL();
  157.                 glu = new GLU();
  158.  
  159.                 text = new TextRenderer(NetVizDisplay.this.getFont(), true);
  160.         }
  161.  
  162.         /*
  163.          * (Kein Javadoc)
  164.          *
  165.          * @see javax.media.opengl.GLEventListener#reshape(javax.media.opengl.GLAutoDrawable,
  166.          *      int, int, int, int)
  167.          */
  168.         public void reshape(GLAutoDrawable drawable, int x, int y, int width,
  169.                 int height) {
  170.             gl.glViewport(0, 0, width, height);
  171.             gl.glMatrixMode(GL.GL_PROJECTION);
  172.             gl.glLoadIdentity();
  173.             glu.gluPerspective(45.0, (1.0f * width) / height, 0.01, 10.0);
  174.             gl.glScalef(0.01f, 0.01f, 0.01f);
  175.             gl.glDepthRange(-200, 200);
  176.             glu.gluLookAt(110, 0, 50, 0, 0, 0, 0, 0, 1);
  177.             gl.glRotatef(90, 0, 0, 1);
  178.         }
  179.     }
  180.  


gld ist das Drawable auf dem Gezeichnet wird.

Und hier noch das Zeichnen eines bestimmten Knotens:

Code:
  1.  
  2.     private static class NeuronDrawer implements INetworkNodeDrawer {
  3.  
  4.         private final float[] start = new float[] {1,0,0};
  5.         private final float[] mid = new float[] {0.5f,0.5f,0.5f};
  6.         private final float[] end = new float[] {0,1,0};
  7.  
  8.         private static final FastGLUquadric.FastGLUquadricSphere SPHERE_QUADRIC =
  9.             new FastGLUquadric.FastGLUquadricSphere(8,8);
  10.  
  11.         /* (Kein Javadoc)
  12.          *
  13.          * @see de.htwm.netviz.common.INetworkNodeDrawer#drawNode(javax.media.opengl.GL, javax.media.opengl.glu.GLU, de.htwm.netviz.common.INetworkNode)
  14.          */
  15.         public void drawNode(GL gl, GLU glu, INetworkNode node) {
  16.             Neuron n = (Neuron)node;
  17.             float[] c = ColorUtils.mixColors(start, mid, end, n.getValue());
  18.             gl.glDisable(GL.GL_DEPTH_TEST);
  19.             gl.glColor4f(c[0], c[1], c[2], 0.5f);
  20.             SPHERE_QUADRIC.drawSphere(gl, 0.25f);
  21.             gl.glEnable(GL.GL_DEPTH_TEST);
  22.         }
  23.  
  24.     }
  25.  


Das Funktioniert in der Form reibungslos, aber ohne den gewünschten Effekt, dass die Kugeln wie Glaskugeln wirken (eher wie Milchglas ;-)). Ich weiß, dass da an der Stelle noch Lightning notwendig ist, aber wie genau hier setzen???

Bin über jegliche Hinweise dankbar; wer den vollen Source brauch, schreibe mir bitte eine PN.

TIA,
BenBE.

_________________
Administrator of Project Omorphia
Bild
Nach oben
 Profil  
Mit Zitat antworten  
BenBE
 Betreff des Beitrags:
BeitragVerfasst: Do Nov 27, 2008 20:12 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 17, 2005 13:19
Beiträge: 98
Wohnort: Jahnsdorf
Bin nach ein wenig Stöbern in den Tuts und ein paar kleinen Hinweisen von oc2k1 nun etwas vorwärts gekommen, aber so ganz will es irgendwie noch nicht.

Code:
  1.     private static class NeuronDrawer implements INetworkNodeDrawer {
  2.  
  3.         private final float[] start = new float[] {1,0,0};
  4.         private final float[] mid = new float[] {0.5f,0.5f,0.5f};
  5.         private final float[] end = new float[] {0,1,0};
  6.  
  7.         private final FloatBuffer mat_specular   = FloatBuffer.wrap(new float[] {1.0f, 1.0f, 1.0f, 1.0f});
  8.         private       FloatBuffer mat_ambient;
  9.         private       FloatBuffer mat_diffuse;
  10.         private final FloatBuffer mat_shininess  = FloatBuffer.wrap(new float[] {50.0f});
  11.         private final FloatBuffer mat_shininess2 = FloatBuffer.wrap(new float[] {25.0f});
  12.  
  13.         private final FloatBuffer light_ambient  = FloatBuffer.wrap(new float[] {0.1f, 0.1f, 0.1f, 0.1f});
  14.         private final FloatBuffer light_diffuse  = FloatBuffer.wrap(new float[] {0.2f, 0.2f, 0.2f, 0.1f});
  15.         private final FloatBuffer light_specular = FloatBuffer.wrap(new float[] {1.0f, 1.0f, 1.0f, 1.0f});
  16.  
  17.         private static final FastGLUquadric.FastGLUquadricSphere SPHERE_QUADRIC;
  18.  
  19.         static {
  20.             SPHERE_QUADRIC = new FastGLUquadric.FastGLUquadricSphere(8,8);
  21.             SPHERE_QUADRIC.setNormals(GLU.GLU_OUTSIDE);
  22.         }
  23.  
  24.         /* (Kein Javadoc)
  25.          *
  26.          * @see de.htwm.netviz.common.INetworkNodeDrawer#drawNode(javax.media.opengl.GL, javax.media.opengl.glu.GLU, de.htwm.netviz.common.INetworkNode)
  27.          */
  28.         public void drawNode(GL gl, GLU glu, INetworkNode node) {
  29.             Neuron n = (Neuron)node;
  30.             float[] c = ColorUtils.mixColors(start, mid, end, n.getValue());
  31.             gl.glDisable(GL.GL_DEPTH_TEST);
  32.             gl.glColor4f(c[0], c[1], c[2], 0.25f);
  33.  
  34.             gl.glEnable(GL.GL_LIGHTING);
  35.             gl.glEnable(GL.GL_LIGHT0);
  36.  
  37.             //Farben für Ambient und Difuse setzen ...
  38.             mat_ambient = FloatBuffer.wrap(new float[] {c[0], c[1], c[2], 0.5f});
  39.             mat_diffuse = FloatBuffer.wrap(new float[] {1.0f, 1.0f, 1.0f, 0.5f});
  40.  
  41.             gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat_specular);
  42.             gl.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, mat_shininess);
  43.             gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, mat_ambient);
  44.             gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, mat_diffuse);
  45.  
  46.             gl.glMaterialfv(GL.GL_BACK, GL.GL_SPECULAR, mat_specular);
  47.             gl.glMaterialfv(GL.GL_BACK, GL.GL_SHININESS, mat_shininess2);
  48.             gl.glMaterialfv(GL.GL_BACK, GL.GL_AMBIENT, mat_ambient);
  49.             gl.glMaterialfv(GL.GL_BACK, GL.GL_DIFFUSE, mat_diffuse);
  50.  
  51.             gl.glLightf(GL.GL_LIGHT0, GL.GL_CONSTANT_ATTENUATION, 1.0f);
  52.             gl.glLightf(GL.GL_LIGHT0, GL.GL_LINEAR_ATTENUATION, 0.0f);
  53.             gl.glLightf(GL.GL_LIGHT0, GL.GL_QUADRATIC_ATTENUATION, 0.0f);
  54.  
  55.             gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, light_ambient);
  56.             gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, light_diffuse);
  57.             gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, light_specular);
  58.  
  59.             SPHERE_QUADRIC.drawSphere(gl, 0.25f);
  60.  
  61.             gl.glDisable(GL.GL_LIGHT0);
  62.             gl.glDisable(GL.GL_LIGHTING);
  63.  
  64.             gl.glEnable(GL.GL_DEPTH_TEST);
  65.         }
  66.  
  67.     }


Die Initialisierung der Licht-Position erfolgt so:

Code:
  1.         /*
  2.          * (Kein Javadoc)
  3.          *
  4.          * @see javax.media.opengl.GLEventListener#reshape(javax.media.opengl.GLAutoDrawable,
  5.          *      int, int, int, int)
  6.          */
  7.         public void reshape(GLAutoDrawable drawable, int x, int y, int width,
  8.                 int height) {
  9.             gl.glViewport(0, 0, width, height);
  10.             gl.glMatrixMode(GL.GL_PROJECTION);
  11.             gl.glLoadIdentity();
  12.             glu.gluPerspective(45.0, (1.0f * width) / height, 0.01, 10.0);
  13.             gl.glScalef(0.01f, 0.01f, 0.01f);
  14.  
  15.             //Hier Position und Richtung setzen
  16.             gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, FloatBuffer.wrap(new float[] {0.0f, -100.0f, 0.0f, 1.0f}));
  17.             gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPOT_DIRECTION, FloatBuffer.wrap(new float[] {0.0f, 100.0f, 0.0f, 1.0f}));
  18.  
  19.             gl.glDepthRange(-200, 200);
  20.             glu.gluLookAt(110, 0, 50, 0, 0, 0, 0, 0, 1);
  21.             gl.glRotatef(90, 0, 0, 1);
  22.         }
  23.  


Aber wirklich sehen tut man nichts ... :( (Einzig das Einfärben der Knoten über das Material funktioniert schon mal).

_________________
Administrator of Project Omorphia
Bild
Nach oben
 Profil  
Mit Zitat antworten  
revolte
 Betreff des Beitrags:
BeitragVerfasst: Do Nov 27, 2008 20:46 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 16, 2008 20:26
Beiträge: 158
Wohnort: Berlin
Programmiersprache: c++,c#,java,ruby,php
FloatBuffer.wrap(new float[] {0.0f, 100.0f, 0.0f, 1.0f}) wozu?
new float[] {0.0f, 100.0f, 0.0f, 1.0f} reicht vollkommen aus ^^ wenn er mekert, dann noch als drittes argument, 0 anhängen, klappt oft xD
Außerdem musst du aufpassen, ob die wrap Funktion auch Nativ arbeitet und Little_Endian benutzt (wird von opengl verwendet oder war das big_endian?)
Hatte des öfteren aufgrund falscher Buffer keine richtigen ergebnisse.
Das einer der großen nachteile an Java/Jogl das man nicht wirklich mit Pointern arbeiten kann. ^^

Das einzige was ich dir empfehlen kann ist vll eine Testumgebung für das licht zu machen, mit einfachen objekten und gucken, ob das mit dem Licht überhaupt geht, eigentlich sieht das ja ganz okay aus, auch wenn ich viele Parameter noch nie selber genutzt habe, sondern auf Shaderlicht setze ^^
Ich fand sowieso das einfache Licht hat schon ziemlich viel Probleme gebracht und wollt nie so richtig. eventuell fidnest du ja im offiziellen forum etwas dazu
http://www.javagaming.org/index.php?board=25.0

_________________
System: Phenom XII X4 955 3,21Ghz , GTX 560 TI, 4GB-Ram, Windows 7 64x
Nach oben
 Profil  
Mit Zitat antworten  
BenBE
 Betreff des Beitrags:
BeitragVerfasst: Fr Nov 28, 2008 19:20 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Aug 17, 2005 13:19
Beiträge: 98
Wohnort: Jahnsdorf
@revolte: Thx für den Tipp, werd's bei Gelegenheit mal testen

@Problem: Hatte vergessen, glEnable(GL_NORMALIZE); zu aktivieren, da ich in meiner ModelView-Matrix ne Skalierung drin hab.

_________________
Administrator of Project Omorphia
Bild
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 4 Beiträge ] 
Foren-Übersicht » Programmierung » Allgemein


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 5 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.018s | 16 Queries | GZIP : On ]