Helo JOGL

Selama beberapa tahun sekarang, pengaturcara yang ingin membuat program intensif grafik yang dapat dijual kepada pengguna sistem operasi yang berlainan mempunyai satu pilihan — OpenGL. GL bermaksud perpustakaan grafik. OpenGL adalah tanda dagangan berdaftar SGI. OpenGL menampakkan dirinya sebagai API pengaturcaraan cross platform C. Sebenarnya, ia adalah spesifikasi bebas perkakasan untuk antara muka pengaturcaraan.

OpenGL adalah untuk membuat grafik. Ia pantas. Sebilangan besar masa, perkakasan dipercepat. Nampaknya OpenGL dapat melakukan apa sahaja secara visual yang anda mahu lakukan.

Malangnya, OpenGL ditulis untuk C. Mari kita hadapi, C bukan bahasa yang paling popular untuk pengaturcaraan aplikasi yang kompleks. Salah satu kelemahan terbesar untuk OpenGL ialah anda tidak dapat membuatnya tanpa apa-apa tanpa jendela untuk meletakkan grafik anda, tetapi OpenGL tidak menyediakan cara untuk anda membuat windows. Ini menjadikan OpenGL sukar dipelajari untuk pemula.

Nasib baik, GLUT (OpenGL Utility Toolkit) diperkenalkan dan dibuat dengan menangani tingkap, butang, dan acara yang dihasilkan oleh pengguna lebih mudah. Namun, belajar OpenGL dalam C atau bahkan C ++ boleh menyakitkan bagi pengaturcara baru atau pengaturcara yang ingin menggunakan pengaturcaraan berorientasikan objek yang sebenarnya.

Kemudian datang JOGL

Java mungkin merupakan bahasa pengaturcaraan berorientasikan objek yang paling popular. Terdapat banyak percubaan untuk menikahi OpenGL dengan Java, tetapi yang pertama membuat semua orang berdiri dan memperhatikan adalah Java Bindings untuk OpenGL, atau JOGL. Sebabnya adalah bahawa usaha ini disokong oleh Sun Microsystems (pencipta Java) dan SGI (pencipta OpenGL).

Pada masa ini, JOGL dikembangkan oleh kumpulan teknologi permainan di Sun. Ia memulakan kehidupan sebagai Jungle yang dikembangkan oleh Ken Russel dan Chris Kline. Russell adalah pekerja Sun yang bekerja di HotSpot Virtual Machine dengan pengalaman 3D selama bertahun-tahun. Kline berfungsi untuk Permainan Irasional dan juga sangat berpengalaman dengan grafik 3D.

Saya secara peribadi berterima kasih atas usaha dan usaha mereka semua yang bekerja di JOGL. Ada beberapa percubaan untuk menyediakan akses ke OpenGL melalui Java API yang ramah — di antaranya adalah Java 3D, OpenGL untuk Java Technology (gl4java), dan Lightweight Java Game Library (LWJGL). JOGL adalah yang pertama yang saya rasa selesa.

JOGL adalah kumpulan pengikatan kelas Java yang disokong oleh Matahari untuk OpenGL. Wah! Itu sangat sedap.

OpenGL digunakan untuk memaparkan model 3D. Ia kuat, cepat, dan mungkin perkara paling hebat yang berlaku pada Java sejak Swing diperkenalkan. Dengan menggunakan OpenGL melalui JOGL, anda akan dapat membuat permainan keren atau situasi model yang mungkin terlalu mahal untuk dibuat. Jumlah tebal telah ditulis menggambarkan OpenGL. Mereka akan berguna setelah anda mengetahui jalan keluar, tetapi belum. Anda perlu belajar bagaimana semua ini berlaku untuk API Java yang memperlihatkan OpenGL kepada anda. Anda juga memerlukan beberapa pengenalan asas untuk net.java.games.jogl.*dan mungkin beberapa penyegar mengenai matematik.

Ada JOGL?

Sekiranya anda ingin menggunakan JOGL, anda perlu mendapatkan jogl.jardan kod asli yang disertakan. Saya mengimpikan hari ini adalah standard dengan pemasangan Java, tetapi buat masa ini hanyalah impian yang baik.

Silap mata pertama adalah mencari binari untuk OS anda dan mengekstraknya. Saya menjumpainya di //games-binaries.dev.java.net/build/index.html. Setiap OS berbeza, tetapi ada dua bahagian untuk dipasang. Yang jogl.jarmesti diletakkan di classpath sistem dan perpustakaan binari mesti diletakkan di mana sahaja perpustakaan pergi dalam OS anda. Sekiranya anda bernasib baik, anda akan mempunyai pemasang untuk melakukannya untuk anda. Sekiranya anda tidak mempunyai pemasang dan tidak tahu di mana hendak mencari maklumat mengenai meletakkan semuanya di komputer anda, anda boleh memulakan dengan pautan yang saya berikan di Sumber. Contoh kod pertama kami akan ditulis secara khusus untuk menguji sama ada anda telah memasang semuanya dengan betul, jadi anda tidak perlu menekankan untuk menguji pemasangan anda sehingga saat itu.

Javadocs untuk JOGL

Javadocs boleh didapati di lokasi yang sama dengan pengedaran binari JOGL. Javadocs akan dinamakan sesuatu yang serupa dengan jogl-1.0-usrdoc.tar.

Sekiranya anda melihat net.java.games.joglpakej, anda akan cepat mengetahui bahawa beberapa kelas sangat besar. GL adalah contoh sempurna dari ini. Jangan ditangguhkan oleh ini. Anda akan mengetahui dengan cepat bahawa anda dapat melakukan kerja yang cukup canggih walaupun hanya dengan sedikit pengetahuan tentang JOGL. Kelas yang mungkin ingin anda lihat sekarang adalah:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Ini akan menjadi antara muka asas anda ke dalam dunia grafik. Sekiranya anda ingat, sebelumnya saya menyebutkan bahawa salah satu kelemahan terbesar bagi pemula belajar OpenGL adalah kekurangan standard sistem penggulungan. GLUT banyak membantu rakan sejawat C, tetapi kami mempunyai Swing dan AWT (Abstract Window Toolkit). Kemungkinan besar anda sudah menggunakan AWT atau Swing, jadi anda tidak akan merasa seperti mempelajari segala sesuatu dari awal. Ini adalah perkara yang baik. Selepas pengenalan yang sangat singkat untuk mendapatkan komponen untuk JOGL di skrin, kami tidak memerlukan banyak usaha untuk menjadikan anda menjalankan aplikasi yang hebat dan hebat!

GlueGen ... hampir sekerap JOGL?

Seperti yang anda sedia maklum, OpenGL ditulis untuk pengaturcara C. Ini bermaksud bahawa untuk Java memanfaatkannya, harus ada beberapa antara muka asli. Ini bermaksud JNI (Java Native Interface), yang tidak menyeronokkan atau cantik, mesti ditulis untuk membuat sambungan ini. OpenGL cukup besar. Menulis semua sambungan memerlukan masa. Untuk membuat keadaan menjadi lebih sukar, terdapat banyak ciri khusus vendor dan OpenGL terus bertambah baik, yang bermaksud ada perubahan yang harus diikuti. Ringkasnya, sangat sukar bagi "sesiapa" yang berusaha mengikuti OpenGL untuk menulis antara muka Java ke asli yang semuanya merangkumi.

Masukkan orang-orang JOGL. Mereka memutuskan untuk memanfaatkan fail header C dan menulis beberapa kod yang akan berfungsi untuk semua JNI. Mereka memanggilnya GlueGen. GlueGen menguraikan fail header C dan kemudian secara ajaib membuat kod Java dan JNI yang diperlukan untuk menyambung ke perpustakaan asli tersebut. Ini bermakna kemas kini ke OpenGL dapat ditambahkan dengan cepat ke JOGL.

Hai dunia!

Saya sangat percaya pada tradisi, jadi sudah tentu kita akan memulakan dengan "Hello World." Hello World ini akan memeriksa pemasangan kami dan memberitahu kami sama ada semua atau sebahagian dipasang dengan betul. Ingatlah bahawa terdapat dua bahagian untuk pemasangan JOGL. Terdapat perpustakaan Java dalam fail jar dan kod asli di perpustakaan lain.

Inilah program kami:

import net.java.games.jogl.*;

public class HelloWorld { public static void main (String args[]) { try { System.loadLibrary("jogl"); System.out.println( "Hello World! (The native libraries are installed.)" ); GLCapabilities caps = new GLCapabilities(); System.out.println( "Hello JOGL! (The jar appears to be available.)" ); } catch (Exception e) { System.out.println(e); } } }

Pertama, program ini menguji untuk melihat apakah perpustakaan asli dan Java dipasang dengan betul. JOGL dipasang dengan betul hanya apabila jogl.jarperpustakaan asli dan yang dinamakan seperti libjogl.jnilibatau jogl.dllkedua-duanya dipasang. Sekiranya perpustakaan asli tidak dapat diakses, program ini akan memberikan java.lang.UnsatisfiedLinkErrorpengecualian. Sekiranya JAR tidak dipasang di classpath, maka program ini juga tidak akan disusun. Penyusun javac akan mengatakan sesuatu yang serupa dengan "pakej net.java.games.jogltidak wujud." Apabila kelas ini menyusun dan berjalan tanpa pengecualian, anda sudah bersedia untuk terus belajar JOGL.

Templat yang baik

Mari beralih ke beberapa kelas yang mungkin berguna untuk dijadikan templat semasa bermain-main dengan JOGL. Saya telah menggunakannya sebagai templat lebih dari sekali. Jangan ragu untuk menggunakannya walaupun anda suka.

This template is made up of two classes. The first is SimpleJoglApp shown below, and the second is SimpleGLEventListener shown after a brief description. You will need to type both in to compile the template. The main app:

import java.awt.*; import java.awt.event.*; import javax.swing.*; import net.java.games.jogl.*;

/** * This is a basic JOGL app. Feel free to * reuse this code or modify it. */ public class SimpleJoglApp extends JFrame { public static void main(String[] args) { final SimpleJoglApp app = new SimpleJoglApp();

// show what we've done SwingUtilities.invokeLater ( new Runnable() { public void run() { app.setVisible(true); } } ); }

public SimpleJoglApp() { //set the JFrame title super("Simple JOGL Application");

//kill the process when the JFrame is closed setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//only three JOGL lines of code ... and here they are GLCapabilities glcaps = new GLCapabilities(); GLCanvas glcanvas = GLDrawableFactory.getFactory().createGLCanvas(glcaps); glcanvas.addGLEventListener(new SimpleGLEventListener());

//add the GLCanvas just like we would any Component getContentPane().add(glcanvas, BorderLayout.CENTER); setSize(500, 300);

//center the JFrame on the screen centerWindow(this); }

public void centerWindow(Component frame) { Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Dimension frameSize = frame.getSize();

if (frameSize.width > screenSize.width ) frameSize.width = screenSize.width; if (frameSize.height > screenSize.height) frameSize.height = screenSize.height;

frame.setLocation ( (screenSize.width - frameSize.width ) >> 1, (screenSize.height - frameSize.height) >> 1 ); } }

That is it. Let's focus on the three lines of JOGL-specific code in this first class. To start:

GLCapabilities glcaps = new GLCapabilities();

This determines what OpenGL/graphics features are available to our JOGL libraries and the JVM.

Next:

GLCanvas glcanvas = GLDrawableFactory.getFactory().createGLCanvas(glcaps);

We cannot create GLCanvases or GLJPanels. We need to have them created for us by a GLDrawableFactory. So, we retrieve a GLDrawableFactory using GLDrawableFactory's static method, getFactory().

Now we have a GLDrawableFactory, so we use its createGLCanvas() method to create a GLCanvas to draw on. We could have used the createGLJPanel() method instead if we had wanted a Swing component instead of an AWT component.

Notice that we passed in the GLCapabilities object we created earlier. This allows the GLDrawable we're having created to be created properly.

Finally, we are ready to add a GLEventListener to the GLCanvas:

glcanvas.addGLEventListener(new SimpleGLEventListener());

Our implementation of GLEventListener is SimpleGLEventListener. It will take care of any drawing that needs to be done when it receives a call from the GLDrawable and our one and only GLCanvas. As you will see, I decided not to draw anything in this program. Now for the GLEventListener:

import java.awt.*; import java.awt.event.*; import net.java.games.jogl.*;

/** * For our purposes only two of the * GLEventListeners matter. Those would * be init() and display(). */ public class SimpleGLEventListener implements GLEventListener {

/** * Take care of initialization here. */ public void init(GLDrawable drawable) {

}

/** * Take care of drawing here. */ public void display(GLDrawable drawable) {

}

/** * Called when the GLDrawable (GLCanvas * or GLJPanel) has changed in size. We * won't need this, but you may eventually * need it -- just not yet. */ public void reshape( GLDrawable drawable, int x, int y, int width, int height ) {}

/** * If the display depth is changed while the * program is running this method is called. * Nowadays this doesn't happen much, unless * a programmer has his program do it. */ public void displayChanged( GLDrawable drawable, boolean modeChanged, boolean deviceChanged ) {} }

That is the heart of the JOGL work we will do. Notice the UML graphic below. SimpleJoglApp is a JFrame. It contains our GLDrawable, which is actually a GLCanvas, but don't tell him that. We add the SimpleGLEventListener, which implements GLEventListener to the GLCanvas so the GLCanvas knows we care if he wants any OpenGL work done. GLDrawables can talk your ear off, so you'll want to make sure your GLEventListener is optimized…for real.

This app may look a bit scrambled depending on your OS. This is to be expected because you are just displaying random bits of memory at this point. So congratulations on your new-found graphics talents.

You're ready for the real thing

After you've familiarized yourself with the previous example, make a pretty picture.

Berikut adalah aplikasi anda yang seterusnya. Pastikan anda menaip ini dan semua contohnya. Menyahpepijat dan bermain-main dengan mereka akan berguna untuk mengajar anda bagaimana ia berfungsi dengan cepat.