Halo JOGL

Selama beberapa tahun sekarang, seorang programmer yang ingin membuat program intensif grafis yang dapat dijual ke pengguna sistem operasi yang berbeda memiliki satu pilihan — OpenGL. GL adalah singkatan dari pustaka grafis. OpenGL adalah merek dagang terdaftar SGI. OpenGL memanifestasikan dirinya sebagai API pemrograman C lintas platform. Pada kenyataannya, ini adalah spesifikasi yang tidak bergantung pada perangkat keras untuk antarmuka pemrograman.

OpenGL untuk membuat grafik. Cepat. Sebagian besar waktu, ini adalah akselerasi perangkat keras. Tampaknya OpenGL dapat melakukan apapun secara visual yang Anda ingin lakukan.

Sayangnya, OpenGL ditulis untuk C. Mari kita hadapi itu, C bukanlah bahasa yang paling populer untuk aplikasi pemrograman kompleks. Salah satu kelemahan terbesar OpenGL adalah Anda tidak dapat membuatnya melakukan apa pun tanpa jendela untuk meletakkan grafik Anda, tetapi OpenGL tidak menyediakan sarana bagi Anda untuk membuat jendela. Hal ini membuat OpenGL sulit dipelajari untuk pemula.

Untungnya, GLUT (OpenGL Utility Toolkit) diperkenalkan dan dibuat untuk menangani jendela, tombol, dan acara yang dibuat oleh pengguna dengan lebih mudah. Namun, mempelajari OpenGL dalam C atau bahkan C ++ bisa menyakitkan bagi pemrogram baru atau pemrogram yang ingin menggunakan pemrograman berorientasi objek yang sebenarnya.

Lalu datanglah JOGL

Java mungkin adalah bahasa pemrograman berorientasi objek yang paling populer. Sudah banyak upaya untuk mengawinkan OpenGL dengan Java, tetapi yang pertama yang membuat semua orang berdiri dan memperhatikan adalah Java Bindings untuk OpenGL, atau JOGL. Alasannya adalah karena upaya ini didukung oleh Sun Microsystems (pencipta Java) dan SGI (pencipta OpenGL).

Saat ini, JOGL dikembangkan oleh grup teknologi game di Sun. Ini memulai kehidupan sebagai Jungle yang dikembangkan oleh Ken Russel dan Chris Kline. Russell adalah karyawan Sun yang mengerjakan HotSpot Virtual Machine dengan pengalaman 3D selama bertahun-tahun. Kline bekerja untuk Game Irasional dan juga sangat berpengalaman dengan grafik 3D.

Saya secara pribadi berterima kasih atas upaya mereka dan upaya semua orang yang bekerja di JOGL. Ada beberapa upaya untuk menyediakan akses ke OpenGL melalui Java API yang bersahabat — di antaranya adalah Java 3D, OpenGL untuk Teknologi Java (gl4java), dan Lightweight Java Game Library (LWJGL). JOGL adalah yang pertama yang saya rasa nyaman.

JOGL adalah kumpulan binding kelas Java yang didukung Sun untuk OpenGL. Wow! Itu seteguk.

OpenGL digunakan untuk menampilkan model 3D. Ini sangat kuat, cepat, dan mungkin hal terbesar yang terjadi di Java sejak Swing diperkenalkan. Menggunakan OpenGL melalui JOGL, Anda akan dapat membuat game keren atau membuat model situasi yang mungkin terlalu mahal untuk dibuat. Buku tebal telah ditulis menggambarkan OpenGL. Mereka akan berguna setelah Anda mengetahui jalannya, tetapi belum. Anda perlu mempelajari bagaimana ini semua berlaku untuk Java API yang mengekspos OpenGL kepada Anda. Anda juga perlu beberapa perkenalan dasar net.java.games.jogl.*dan mungkin penyegar tentang matematika.

Punya JOGL?

Jika Anda ingin menggunakan JOGL, Anda perlu mendapatkan jogl.jardan kode asli yang menyertainya. Saya memimpikan hari itu adalah standar dengan instalasi Java, tetapi untuk saat ini itu hanya mimpi yang ditempatkan dengan baik.

Trik pertama adalah menemukan binari untuk OS Anda dan mengekstraknya. Saya menemukannya di //games-binaries.dev.java.net/build/index.html. Setiap OS berbeda, tetapi ada dua bagian untuk diinstal. The jogl.jarharus ditempatkan dalam sistem classpath, dan perpustakaan biner harus ditempatkan di mana pun perpustakaan masuk OS Anda. Jika Anda beruntung, Anda akan memiliki penginstal untuk melakukannya untuk Anda. Jika Anda tidak memiliki penginstal dan tidak tahu di mana mencari informasi tentang menempatkan segala sesuatu di komputer Anda, Anda dapat mulai dengan tautan yang saya berikan di Sumber. Contoh kode pertama kami akan ditulis secara khusus untuk menguji apakah Anda telah menginstal semuanya dengan benar, jadi Anda tidak perlu stres untuk menguji instalasi Anda sampai saat itu.

Javadocs untuk JOGL

Javadocs dapat diperoleh di lokasi yang sama dengan distribusi biner JOGL. Javadocs akan diberi nama yang mirip dengan jogl-1.0-usrdoc.tar.

Jika Anda menelusuri net.java.games.joglpaket tersebut, Anda akan segera melihat bahwa beberapa kelas sangat besar. GL adalah contoh sempurna untuk ini. Jangan menunda dengan ini. Anda akan segera mengetahui bahwa Anda dapat melakukan pekerjaan yang cukup canggih bahkan hanya dengan sedikit pengetahuan JOGL. Kelas yang mungkin ingin Anda lihat sekarang adalah:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Ini akan menjadi antarmuka dasar Anda ke dunia grafis. Jika Anda ingat, sebelumnya saya telah menyebutkan bahwa salah satu kelemahan terbesar bagi pemula yang mempelajari OpenGL adalah kurangnya standar sistem windowing. GLUT sangat membantu dalam hal itu untuk rekan-rekan C kami, tetapi kami memiliki Swing dan AWT (Abstract Window Toolkit). Kemungkinan besar Anda telah menggunakan AWT atau Swing, jadi Anda tidak akan merasa mempelajari semuanya dari awal. Ini hal yang bagus. Setelah pengantar yang sangat singkat untuk menampilkan komponen JOGL di layar, kami tidak memerlukan banyak pekerjaan agar Anda menjalankan aplikasi yang cukup keren dan keren!

GlueGen ... hampir sekeren JOGL?

Seperti yang harus Anda ketahui, OpenGL ditulis untuk programmer C. Ini berarti agar Java dapat memanfaatkannya, harus ada beberapa antarmuka asli. Ini berarti JNI (Java Native Interface), yang tidak menyenangkan atau cantik, harus ditulis untuk membuat sambungan ini. OpenGL cukup besar. Menulis semua koneksi itu membutuhkan waktu. Untuk membuat segalanya menjadi sedikit lebih sulit, ada banyak fitur khusus vendor dan OpenGL terus meningkat, yang berarti ada perubahan yang harus diikuti. Singkatnya, cukup sulit bagi "siapa pun" yang mencoba mengikuti OpenGL untuk menulis Java ke antarmuka asli yang mencakup semuanya.

Masukkan orang-orang JOGL. Mereka memutuskan untuk memanfaatkan file header C dan menulis beberapa kode yang akan melakukan semua pekerjaan JNI untuk mereka. Mereka menyebutnya GlueGen. GlueGen mem-parsing file header C dan kemudian secara ajaib membuat kode Java dan JNI yang diperlukan untuk menyambungkan ke pustaka asli tersebut. Artinya, pembaruan OpenGL dapat ditambahkan dengan cepat ke JOGL.

Halo Dunia!

Saya sangat percaya pada tradisi, jadi tentu saja kita akan mulai dengan "Halo Dunia." Hello World ini akan memeriksa instalasi kami dan memberi tahu kami apakah semua atau sebagian telah diinstal dengan benar. Ingatlah ada dua bagian untuk instalasi JOGL. Ada pustaka Java di file jar dan kode asli di pustaka 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 pustaka asli dan Java diinstal dengan benar. JOGL diinstal dengan benar hanya jika jogl.jardan pustaka asli, diberi nama seperti libjogl.jnilibatau jogl.dll, keduanya diinstal. Jika perpustakaan asli tidak dapat diakses, program ini akan mengeluarkan java.lang.UnsatisfiedLinkErrorpengecualian. Jika JAR tidak diinstal di classpath, maka program bahkan tidak akan dapat dikompilasi. Kompiler javac akan mengatakan sesuatu yang mirip dengan "paket net.java.games.jogltidak ada". Saat kelas ini mengompilasi dan berjalan tanpa pengecualian, Anda siap untuk terus belajar JOGL.

Template yang bagus

Mari beralih ke beberapa kelas yang mungkin berguna bagi Anda untuk digunakan sebagai template saat bermain-main dengan JOGL. Saya telah menggunakannya sebagai template lebih dari sekali. Jangan ragu untuk menggunakannya sesuka Anda.

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.

Ini aplikasi Anda berikutnya. Pastikan Anda mengetik ini dan semua contoh masuk. Debugging dan mengotak-atiknya akan berfungsi untuk mengajari Anda cara kerjanya dengan cepat.