सर्वश्रेष्ठ ओपनजीएल जावा बाध्यकारी क्या है?

Question

मैं अपने जावा एसडब्ल्यूटी एप्लीकेशन के लिए बेहतर प्रदर्शन प्राप्त करने की कोशिश कर रहा हूं, और मुझे पता चला कि एसडब्ल्यूटी में ओपनजीएल का उपयोग करना संभव है। ऐसा लगता है कि ओपनजीएल के लिए एक से अधिक जावा बाध्यकारी हैं। तुम्हें कौन सा पसंद है?

ध्यान दें कि मैं ओपन से पहले इस्तेमाल कभी नहीं किया है, और आवेदन विंडोज पर काम करने की जरूरत है कि, लिनक्स और मैक ओएस एक्स

Answer 1

JOGL

मेरे कारणों बंद पहले से जुड़ा हुआ साइट उद्धृत किया जा सकता है:

JOGL ओपन 2.0 विनिर्देश में एपीआई के लिए पूरा उपयोग के साथ ही लगभग सभी विक्रेता एक्सटेंशन प्रदान करता है, और साथ एकीकृत करता है एडब्ल्यूटी और स्विंग विजेट सेट।

इसके अलावा, अगर आप कुछ मज़ा सीखने और आसपास poking करना चाहते हैं, Processing एक शानदार तरीका शुरू करने के लिए, हल्के है (प्रसंस्करण भी btw JOGL का उपयोग करता है ...)

Answer 2

व्यक्तिगत रूप से, मैं JOGL से ओपन अन्य के लिए जावा बाइंडिंग का भी पता नहीं कर रहा हूँ - - मुझे लगता है कि जॉबएल जावा ओपनजीएल के लिए काफी मानक है।

यह विंडोज, लिनक्स और ओएस एक्स में काम करता है, लेकिन आप प्रत्येक प्लेटफार्म में विशिष्ट मुद्दों के बारे में कुछ नोट्स के लिए आधिकारिक दस्तावेज़ीकरण को पढ़ना चाहेंगे।

ध्यान रखें कि ओपनजीएल प्रतिमान स्विंग/एडब्ल्यूटी या जावा 2 डी एपीआई से काफी अलग है; ओपनजीएल स्विंग के लिए ड्रॉप-इन प्रतिस्थापन नहीं है।

Answer 3

मैं LWJGL बाहर की जाँच के सुझाव देंगे जावा गेम लाइब्रेरी। इसे ओपनजीएल बाइंडिंग मिल गया है, लेकिन इसमें ओपनल बाइंडिंग और कुछ बेहतरीन ट्यूटोरियल भी हैं जो आपको शुरू करने के लिए हैं।

बस ध्यान रखें कि स्विंग/एसडब्ल्यूटी और ओपनजीएल आमतौर पर पूरी तरह से अलग-अलग चीजों के लिए उपयोग किया जाता है। आप दोनों के संयोजन का उपयोग करना चाहते हैं। बस एलडब्ल्यूजेजीएल को आज़माएं और देखें कि आप जो कर रहे हैं उसके साथ यह कितना अच्छा है।

Answer 4

जॉगएल शायद विचार करने का एकमात्र विकल्प है। ध्यान दें कि इसे एक SWT एप्लिकेशन में एकीकृत करने के लिए कम से कम दो विकल्प हैं। एक जीएलकणवास है जो एसडब्ल्यूटी और एक जीएलकणवास से संबंधित है जो एडब्ल्यूटी से संबंधित है। एसडब्ल्यूटी में से एक सुविधा पूरी नहीं है और वास्तव में इसे बनाए रखा नहीं है। एक SWT_AWT कंटेनर के अंदर AWT GLCanvas का उपयोग करना बेहतर है। हाल ही में एक परियोजना से कुछ कोड:

import org.eclipse.swt.*; 
import org.eclipse.swt.layout.*; 
import org.eclipse.swt.widgets.*; 

import javax.media.opengl.*; 
import javax.media.opengl.glu.*; 

import org.eclipse.swt.awt.SWT_AWT; 
import org.eclipse.swt.events.*; 

public class Main implements GLEventListener 
{ 
    public static void main(String[] args) 
    { 
     Display display = new Display(); 
    Main main = new Main(); 
    main.runMain(display); 
    display.dispose(); 
} 

void runMain(Display display) 
{ 
    final Shell shell = new Shell(display); 
    shell.setText("Q*bert 3D - OpenGL Exercise"); 
    GridLayout gridLayout = new GridLayout(); 
    gridLayout.marginHeight = 0; 
    gridLayout.marginWidth = 0; 

    shell.setLayout(gridLayout); 

    // this allows us to set particular properties for the GLCanvas 
    GLCapabilities glCapabilities = new GLCapabilities(); 

    glCapabilities.setDoubleBuffered(true); 
    glCapabilities.setHardwareAccelerated(true); 

    // instantiate the canvas 
    final GLCanvas canvas = new GLCanvas(glCapabilities); 

    // we can't use the default Composite because using the AWT bridge 
    // requires that it have the property of SWT.EMBEDDED 
    Composite composite = new Composite(shell, SWT.EMBEDDED); 
    GridData ld = new GridData(GridData.FILL_BOTH); 
    composite.setLayoutData(ld); 

    // set the internal layout so our canvas fills the whole control 
    FillLayout clayout = new FillLayout(); 
    composite.setLayout(clayout); 

    // create the special frame bridge to AWT 
    java.awt.Frame glFrame = SWT_AWT.new_Frame(composite); 
    // we need the listener so we get the GL events 
    canvas.addGLEventListener(this); 

    // finally, add our canvas as a child of the frame 
    glFrame.add(canvas); 

    // show it all 
    shell.open(); 
    // the event loop. 
    while (!shell.isDisposed()) { 
     if (!display.readAndDispatch()) display.sleep(); 
    } 
} 

Answer 5

JOGL आप सबसे अच्छा प्रदर्शन और पोर्टेबिलिटी दे देंगे। लेकिन ध्यान रखें कि जॉगएल सीखना, जो अनिवार्य रूप से ओपनजीएल सीखने जैसा ही है, आसान नहीं है।

Answer 6

हमारे पास JOGL का उपयोग करके काम पर बहुत भाग्य है। नया 2.0 संस्करण http://jogamp.org/ पर है (अंतिम "पुराना" संस्करण http://download.java.net/media/jogl/builds/archive/jsr-231-1.1.1a/ पर है)।

एसडब्ल्यूटी के साथ जॉग 2 के लिए विशेष रूप से, मुझे http://wadeawalker.wordpress.com/2010/10/09/tutorial-a-cross-platform-workbench-program-using-java-opengl-and-eclipse/ से शुरू होने वाले ट्यूटोरियल की एक श्रृंखला मिली है जो कि क्रॉस-प्लेटफार्म जॉगएल एसडब्ल्यूटी अनुप्रयोगों को कैसे स्थापित करने के लिए बिल्कुल सही तरीके से प्रदर्शित करता है, जो स्थापित करने योग्य देशी बाइनरी के साथ पूरा होता है।

या यदि आप एक्लिप्स आरसीपी का उपयोग नहीं करना चाहते हैं, तो यहां एक आसान उदाहरण है जो सिर्फ जॉग 2 और एसडब्ल्यूटी के साथ एक त्रिकोण खींचता है। इसे बनाने के लिए, इसे swt.jar के साथ एक प्रोजेक्ट में रखें (http://www.eclipse.org/swt/ से) और नवीनतम जॉग ऑटोबॉल्ड .jar और।डीएलएल फाइलें (http://jogamp.org/ से)। इस सरल उदाहरण के साथ एकमात्र समस्या यह है कि यह कुछ अतिरिक्त सहायता के बिना क्रॉस-प्लेटफार्म नहीं होगा - आपको उस क्षमता की आवश्यकता है जो ग्रहण आरसीपी आपको एक परियोजना में एक साथ मंच पुस्तकालयों के कई सेटों को बंडल करने की अनुमति देता है।

package name.wadewalker.onetriangle; 

import org.eclipse.swt.SWT; 
import org.eclipse.swt.events.PaintEvent; 
import org.eclipse.swt.events.PaintListener; 
import org.eclipse.swt.graphics.Rectangle; 
import org.eclipse.swt.layout.FillLayout; 
import org.eclipse.swt.opengl.GLCanvas; 
import org.eclipse.swt.opengl.GLData; 
import org.eclipse.swt.widgets.Composite; 
import org.eclipse.swt.widgets.Display; 
import org.eclipse.swt.widgets.Event; 
import org.eclipse.swt.widgets.Listener; 
import org.eclipse.swt.widgets.Shell; 

import javax.media.opengl.GL; 
import javax.media.opengl.GLProfile; 
import javax.media.opengl.GL2; 
import javax.media.opengl.GLContext; 
import javax.media.opengl.GLDrawableFactory; 
import javax.media.opengl.glu.GLU; 

public class OneTriangle { 

    public static void main(String [] args) { 
     GLProfile.initSingleton(true); 

     GLProfile glprofile = GLProfile.get(GLProfile.GL2); 

     Display display = new Display(); 
     Shell shell = new Shell(display); 
     shell.setLayout(new FillLayout()); 
     Composite composite = new Composite(shell, SWT.NONE); 
     composite.setLayout(new FillLayout()); 

     GLData gldata = new GLData(); 
     gldata.doubleBuffer = true; 
     // need SWT.NO_BACKGROUND to prevent SWT from clearing the window 
     // at the wrong times (we use glClear for this instead) 
     final GLCanvas glcanvas = new GLCanvas(composite, SWT.NO_BACKGROUND, gldata); 
     glcanvas.setCurrent(); 
     final GLContext glcontext = GLDrawableFactory.getFactory(glprofile).createExternalGLContext(); 

     // fix the viewport when the user resizes the window 
     glcanvas.addListener(SWT.Resize, new Listener() { 
      public void handleEvent(Event event) { 
       setup(glcanvas, glcontext); 
      } 
     }); 

     // draw the triangle when the OS tells us that any part of the window needs drawing 
     glcanvas.addPaintListener(new PaintListener() { 
      public void paintControl(PaintEvent paintevent) { 
       render(glcanvas, glcontext); 
      } 
     }); 

     shell.setText("OneTriangle"); 
     shell.setSize(640, 480); 
     shell.open(); 

     while(!shell.isDisposed()) { 
      if(!display.readAndDispatch()) 
       display.sleep(); 
     } 

     glcanvas.dispose(); 
     display.dispose(); 
    } 

    private static void setup(GLCanvas glcanvas, GLContext glcontext) { 
     Rectangle rectangle = glcanvas.getClientArea(); 

     glcanvas.setCurrent(); 
     glcontext.makeCurrent(); 

     GL2 gl = glcontext.getGL().getGL2(); 
     gl.glMatrixMode(GL2.GL_PROJECTION); 
     gl.glLoadIdentity(); 

     // coordinate system origin at lower left with width and height same as the window 
     GLU glu = new GLU(); 
     glu.gluOrtho2D(0.0f, rectangle.width, 0.0f, rectangle.height); 

     gl.glMatrixMode(GL2.GL_MODELVIEW); 
     gl.glLoadIdentity(); 

     gl.glViewport(0, 0, rectangle.width, rectangle.height); 
     glcontext.release();   
    } 

    private static void render(GLCanvas glcanvas, GLContext glcontext) { 
     Rectangle rectangle = glcanvas.getClientArea(); 

     glcanvas.setCurrent(); 
     glcontext.makeCurrent(); 

     GL2 gl = glcontext.getGL().getGL2(); 
     gl.glClear(GL.GL_COLOR_BUFFER_BIT); 

     // draw a triangle filling the window 
     gl.glLoadIdentity(); 
     gl.glBegin(GL.GL_TRIANGLES); 
     gl.glColor3f(1, 0, 0); 
     gl.glVertex2f(0, 0); 
     gl.glColor3f(0, 1, 0); 
     gl.glVertex2f(rectangle.width, 0); 
     gl.glColor3f(0, 0, 1); 
     gl.glVertex2f(rectangle.width/2, rectangle.height); 
     gl.glEnd(); 

     glcanvas.swapBuffers(); 
     glcontext.release();   
    } 
}