Jogl-quick-guide
JOGL-概要
この章では、OpenGL、その機能、javaのOpenGLバインディング（GL4java、LWJGL、JOGL）、および他のOpenGLバインディングに対するJOGLの利点を紹介します。
- O pen GL （JOGL）の J * avaバインディングは、JavaのOpenGLグラフィックスAPIの最近のバインディングです。 OpenGL APIにアクセスできるラッパーライブラリであり、Javaでコーディングされた2Dおよび3Dグラフィックアプリケーションを作成するように設計されています。 JOGLは、元MITの大学院生ケンラッセルとクリスクラインによって最初に開発されたオープンソースライブラリです。 その後、Sun Microsystemsのゲーミンググループに採用され、現在はJava on Graphics Audio and Processing（JOGAMP）によって管理されています。 JOGLは、Windows、Solaris、Mac OS X、Linux（x86）などのさまざまなオペレーティングシステムで機能します。
OpenGLとは何ですか？
OpenGLはOpen Graphics Libraryの略で、2Dおよび3Dグラフィックを作成するコマンドのコレクションです。 OpenGLでは、ポイント、ライン、ポリゴン、ビットマップ、画像などの非常に基本的なプリミティブを使用して、複雑な3D形状を作成できます。
ここにOpenGLのいくつかの機能があります-
- 複数のプラットフォームで動作します。
- C ++、Pythonなどのいくつかの言語のバインディングがあります。
- 2Dおよび3Dベクターグラフィックスをレンダリングできます。
- 迅速かつ迅速に達成するために、Graphical Processing Unit（GPU）と相互作用 高品質のレンダリング。 レンダリングは、2Dまたは3Dモデルから画像を作成するプロセスです。
- 3Dグラフィックアプリケーションを作成するための業界標準APIです。 たとえば、ゲーム、スクリーンセーバーなど。
- 約150個のコマンドが含まれており、プログラマはこれらを使用して、アプリケーションを開発するオブジェクトと操作を指定できます。
- 2次曲面やNURBS曲線などのさまざまなモデリング機能を提供するOpenGLユーティリティライブラリ（GLU）が含まれています。 GLUはOpenGLの標準コンポーネントです。
- OpenGLの設計は、効率、有効性、および複数の言語を使用する複数のプラットフォームでの実装に焦点を当てています。 OpenGL APIのシンプルさを維持するために、ウィンドウ処理タスクは含まれていません。
そのため、OpenGLはウィンドウ処理タスクについて他のプログラミング言語に依存しています。
OpenGL APIのJavaバインディング
これはJava Specification Request（JSR）API仕様であり、JavaプラットフォームでOpenGLを使用できます。
| Specifications | Details |
|---|---|
| JSR 231 | This Java binding package supports Java SE platform. |
| JSR 239 | This Java binding package supports Java ME platform. |
JavaにはさまざまなOpenGLバインディングがあります。 以下で説明します
GL4java
OpenGL for Javaテクノロジーとして知られています。 OpenGL 1.3およびほぼすべてのベンダー拡張機能へのリンクがあります。 また、Abstract Window Toolkit（AWT）およびSwingsで使用できます。 これはゲームに特化したOpenGLバインディングであり、フルスクリーンアプリケーションを表示する単一のウィンドウです。
LWJGL
- Light Weight Java Game Library（LWJGL）は、OpenGL 1.5を使用し、最新バージョンのjavaで動作します。
- JSE 1.4のフルスクリーン機能を使用できます。 AWT/Swingsのサポートは限定されています。
- 携帯電話、組み込みデバイスなどの軽量デバイスに適しています。
JOGL
- JOGLは2Dおよび3Dレンダリングのみに焦点を当てています。 サウンドと入出力を処理するインターフェイスは、JOGLに含まれていません。
- グラフィックユーティリティライブラリ（GLU）、GLユーティリティツールキット（GLUT）、および独自のAPI-Native Windowing Toolkit（NEWT）が含まれています。
JOGLを選ぶ理由
- OpenGL API（バージョン1.0、4.3、ES 1、ES 2および ES 3）およびほぼすべてのベンダー拡張。 したがって、OpenGLのすべての機能はJOGLに含まれています。
- JOGLは、AWT、Swing、およびStandard Widget Toolkit（SWT）と統合します。 また、独自のNative Windowing Toolkit（NEWT）も含まれています。 したがって、ウィンドウ化の完全なサポートを提供します。
JOGLの歴史
- 1992-Silicon Graphics Inc. 最初のOpenGL仕様をリリースしました。
- 2003-新しい機能を備えたJava.net Webサイトが立ち上げられ、JOGLが同じWebサイトで初めて公開されました。
- 2010-2010年以来、コンピューターソフトウェアのリベラルライセンスであるBSDライセンスに基づく独立したオープンソースプロジェクトです。
JOGL-インストール
この章では、さまざまな統合開発環境（IDE）を使用してシステムでJOGLを使用するための環境の設定について説明します。
JOGLのインストール
JOGLインストールの場合、次のシステム要件が必要です-
システム要求
最初の要件は、Java Development Kit（JDK）をマシンにインストールすることです。
| Requirement | Description |
|---|---|
| JDK Version | 1.4 or above |
| Memory | no minimum requirement |
| Disk Space | no minimum requirement |
| Operating System | no minimum requirement |
JOGLアプリケーション開発を開始するには、指定された手順に従って環境をセットアップする必要があります-
ステップ1-マシンでのJavaインストールの検証
システムのコンソールを開き、次のJavaコマンドを実行します-
| Platform | TASK | COMMAND |
|---|---|---|
| Windows | Open Command Console | C:\>java-version |
| Linux | Open Command terminal | $ java -version |
| MAC | Open Terminal | Machine:~ joseph$ java -version |
各オペレーティングシステムの出力を確認します。
| Platform | Output |
|---|---|
| Windows |
Java “1.6.0.21” java（TM）SE Runtime Environment（build 1..6.0_21-b07）Java HotSpot（TM）Client VM（build 17.0-b7、混合モード、共有） |
| Linux |
Java “1.6.0.21” java（TM）SE Runtime Environment（build 1..6.0_21-b07）Java HotSpot（TM）Client VM（build 17.0-b7、混合モード、共有） |
| MAC |
Java “1.6.0.21” java（TM）SE Runtime Environment（build 1..6.0_21-b07）Java HotSpot（TM）Client VM（build 17.0-b7、混合モード、共有） |
ステップ2 – Java Development Kit（JDK）のセットアップ
マシンにJavaがインストールされていない場合は、Oracle Webサイト（http://www.oracle.com/technetwork/java/javase/downloads/indexl[Oracle]）からJava SDKをインストールする必要があります。 ダウンロードしたファイルからJDKをインストールする手順を見つけることができます。 指定された指示に従って、セットアップをインストールおよび構成する必要があります。 最後に、PATHおよびJAVA_HOME環境変数を設定して、java.exeおよびjavac.exeファイルを含むディレクトリを参照します。通常、それぞれjava_install_dir/binおよびjava_install_dirです。
*Java-home* 環境変数を、Javaがマシンにインストールされている同じパス上のベースディレクトリの場所を指すように設定します。| Platform | Command |
|---|---|
| Windows | Set the environment variable JAVA_HOME to C:\ProgramFiles\Java\Jdk1.6.0_21 |
| Linux | Export JAVA_HOME=/usr/local/java-current |
| MAC | Export JAVA_HOME=/Library/Java/Home |
次のようにJavaコンパイラの場所をシステムパスに追加します-
| Platform | Command |
|---|---|
| Windows | Append the string ;%JAVA_HOME% bin at the end of the system variable and path |
| Linux | Export PATH=$PATH:$JAVA_HOME/bin/ |
| MAC | Not required |
ステップ3 – JOGLのダウンロード
- JOGLの最新バージョンは、Webサイトhttp://jogamp.org/[www.jogamp.org]からダウンロードできます。
- www.jogamp.orgのホームページに移動します
- [ビルド/ダウンロード]> [現在（zip）]をクリックします。
これにより、Webサイトで管理されているすべてのAPIの.jarファイルのリストが表示されます。
- ライブラリ.jarファイル jogamp-all-platforms.7z 、OpenGLネイティブライブラリ glugen-javadoc.7z 、およびJOGL * jogl-javadocs.7z。*のJavaドキュメントをダウンロードします。
- zip抽出ソフトウェアを使用して、ダウンロードした.jarファイルを抽出します。
抽出されたフォルダーを開くと、jarフォルダー、ソースコード、およびその他のファイルが見つかります。
IDEをサポートするためのソースコード gluegen-java-src.zip および jogl-java-src.zip を入手します。 これはオプションです。
- jarフォルダー内には、複数の.jarファイルがあります。 このファイルのコレクションは、GlugenとJOGLに属します。
- JOAMPは、Windows、Solaris、Linux、Androidなどのさまざまなオペレーティングシステムをサポートするネイティブライブラリを提供します。 したがって、目的のプラットフォームで実行できる適切なjarファイルを取得する必要があります。 たとえば、Windows 64ビットオペレーティングシステムを使用している場合は、jarフォルダーから次の.jarファイルを取得します-
- gluegenrt.jar
- jogl-all.jar
- gluegen-rt-natives-windows-amd64.jar
- jogl-all-natives-windowsamd64.jar
Eclipse 4.4用のJOGLのセットアップ
JOGLを設定するための所定の手順に従ってください-
ライブラリを追加する
- ステップ1 *-Eclipseを開きます。
- ステップ2 *-新しいプロジェクトを作成します。
- ステップ3 *-プロジェクトフォルダーに_lib_という名前の新しいフォルダーを作成します。
ステップ4 *-ファイル_gluegen-rt-natives-windows-amd64.jar、gluegenrt.jar、jogl-all-natives-windowsamd64.jar_および *jogl-all.jar を_lib_フォルダーにコピーします。
- ステップ5 *-これらのファイルを選択し、マウスボタンを右クリックします。 *ビルドパス>ビルドパスに追加*を含むショートカットメニューが表示されます。
- ステップ6 *-すべての.jarファイルを他のプロジェクトで使用できるようにするには、メインメニューに移動します。 [ウィンドウ]> [設定]を選択します。 [設定]ウィンドウが表示されます。
画像：/jogl/images/eclipse3.jpg [Eclipse3]画像：/jogl/images/eclipse4.jpg [Eclipse4]
- 設定ウィンドウの左側のドロップダウンメニューで、階層-Java→ビルドパス→ユーザーライブラリの順に進みます。
- 「新規…」ボタンをクリックします。
- ダイアログボックスが開きます。 ライブラリ名をjogl2.1として入力します。
- 「Add External JARs …」ボタンを使用して、jarファイル glugen-rt.jar および jogl-all.jar を追加します。
- * jogl2.1。*という名前の新しいユーザーライブラリが作成されます。
同様に、added.jarファイルのJavaドキュメントとソースコードを追加できます。
ネイティブライブラリの追加
- ステップ1 *-jogl-all.jarノードを展開し、Javadocの場所（なし）を選択します。
- ステップ2 *-「新規…」ボタンをクリックします。 JOGL Javaドキュメントの名前を入力します。
- ステップ3 *-[外部JARの追加…]ボタンをクリックします。
- ステップ4 *-既にダウンロード済みのJOGL Javaドキュメントの場所を選択する必要があるダイアログボックスが開きます。
ソースコードを追加する
- ステップ1 *-ノードのネイティブライブラリの場所を選択：（なし）。
- ステップ2 *-「新規…」ボタンをクリックします。
- ステップ3 *-ネイティブライブラリの名前を入力し、[OK]ボタンをクリックします。
- ステップ4 *-[外部JARの追加…]ボタンをクリックします。
- ステップ5 *-ネイティブライブラリファイル_（ 'gluegen-rt-natives-windows-amd64.jarおよびjoglall-natives-windows-amd64.jar'）_が配置されているパスを選択します。
- ステップ6 *-ソースコードについても同じ手順を繰り返します。
ステップ7 *-ネイティブライブラリファイル *glegen-rt.jar および* glugen-natives-windows-amd64.jar。*の両方に対して、上記と同じ方法でJavadoc、ソースコード、およびjarファイルの場所を設定できます。
NetBeans 4.4用のJOGLのセットアップ
NetBeans 4.4のJOGLを設定する手順を見てみましょう-
ライブラリを追加する
- ステップ1 *-メインメニューで、*ツール>ライブラリ*を選択します。
ステップ2 *- *Ant Library Manager に移動します。
- ステップ3 *-*クラスパス*タブで、左下隅にある*新規ライブラリ*ボタンをクリックします。 小さなダイアログボックスが開きます。
ステップ4 *-ライブラリ名を JoGl2.0。*として入力します
- ステップ5 *-[OK]ボタンをクリックします。
- ステップ6 *-「JAR/フォルダを追加…」ボタンをクリックします。
ステップ7 *-.jarファイル *jogl.all.jar および gluegen-rt.jar が配置されているパスを選択します。
JOGLライブラリを各プロジェクトに含めるには、以下の手順に従ってください-
- ステップ1 *-*プロジェクト名*を右クリックします。 ショートカットメニューが表示されます。
ステップ2 *-*プロパティを選択します。 *プロジェクトプロパティ*という名前のウィンドウが開きます。
- ステップ3 *-左側の[カテゴリ]から[ライブラリ]を選択します。
- ステップ4 *-*コンパイルタブ*を選択し、「ライブラリを追加…」ボタンをクリックします。 [ライブラリの追加]ダイアログボックスが表示されます。
- ステップ5 *-さきほど作成したJOGL2.0ライブラリを追加します。
各プロジェクトにネイティブライブラリを含める
指定された手順に従って、各プロジェクトにネイティブライブラリを含めます-
- ステップ1 *-プロジェクトを右クリックします。
ステップ2 *-[設定の設定]> [カスタマイズ…]を選択します
[プロジェクトプロパティ]ウィンドウに移動します。
ステップ3 *-右側の[ *VMオプション] で、[カスタマイズ]ボタンをクリックします。
ステップ4 *-JOGLネイティブライブラリ *gluegen-rtnatives-windows-amd64.jar および* 'jogl-all-natives-windowsamd64.jar。*を含むパスを参照します
ネイティブライブラリのJavaドキュメントの追加
各プロジェクトでソースとJavadocを使用できるようにするには、Antライブラリマネージャーを再度開く必要があります。 指定された手順に従ってください-
- ステップ1 *-*メインメニュー*を開きます。
ステップ2 *-*ツール>ライブラリ*を選択します。 これにより、 *Library manager に移動します。
ステップ3 *- *JavaDoc タブの下で、「新規ライブラリ…」ボタンをクリックします。
ステップ4 *- *JOGLJavadoc 名を入力します。 （任意の名前を入力できます。）
- ステップ5 *-「jar/ライブラリの追加…」ボタンをクリックします。
ステップ6 *-解凍された JOGLドキュメント*コードが配置されているパスを選択します。
ネイティブライブラリのソースコードの追加
ステップ1 *-*ソース*タブで、「新規ライブラリ…」ボタンをクリックします。 *JOGLsources の名前を入力します。
- ステップ2 *-「jar/ライブラリの追加…」ボタンをクリックします。 解凍されたソースコードがあるパスを選択します。
JDKエディターのカスタマイズ
ステップ1 *-ファイル *jogl.all.jar および* gluegen-rt.jar。の *Classpath を設定する
ステップ2 *-ネイティブライブラリ_gluegen-rt-natives-windows-amd64.jar_および_joglall-natives-windowsamd64.jar_へのパスを設定するか、ダウンロードしたフォルダーからすべてのjarファイルをコピーして *jseに貼り付けますlib フォルダー。
JOGL-基本テンプレート用のAPI
JOGLプログラミングを使用すると、直線、三角形、回転、照明、色などの特殊効果を含む3D図形などのさまざまなグラフィカル図形を描画できます。 最初にJOGLでオブジェクトを描画するには、基本的なJOGLフレームを作成する必要があります。 以下は、基本的なフレームを構築するために必要なクラスです。
GLEventListenerインターフェイス
プログラムでJOGLグラフィカルAPIを使用できるようにするには、 GLEventListener インターフェイスを実装する必要があります。 GLEventListener インターフェースは、 javax.media.opengl パッケージにあります。
次の表は、さまざまなメソッドの詳細と GLEventListener インターフェイスの説明を示しています-
| Sr.No. | Methods and Descriptions |
|---|---|
| 1 |
Void display(GLAutoDrawable drawable) クライアントによるOpenGLレンダリングを開始するために、GLAutoDrawableインターフェイスのオブジェクトによって呼び出されます。 つまり、このメソッドには、OpenGL APIを使用してグラフィカル要素を描画するために使用されるロジックが含まれています。 |
| 2 |
Void dispose(GLAutoDrawable drawable) このメソッドは、メモリバッファやGLSLプログラムなど、各GLContextごとにすべてのOpenGLリソースのリリースを実行するようリスナーに通知します。 |
| 3 |
Void init(GLAutoDrawble drawable) OpenGLコンテキストが初期化された直後に、GLAutoDrawableインターフェイスのオブジェクトによって呼び出されます。 |
| 4 |
Void reshape(GLAutoDrawble drawble, int x, int y, int width, int height) コンポーネントのサイズが変更された後の最初の再描画中に、GLAutoDrawableインターフェイスのオブジェクトによって呼び出されます。 また、ウィンドウ上のコンポーネントの位置が変更されるたびに呼び出されます。 |
*GLEventListener* のすべてのメソッドには、パラメーターとして *GLAutoDrawable* インターフェイスのオブジェクトが必要です。GLAutoDrawableインターフェイス
このインターフェイスは、OpenGLレンダリングを実行するためのイベントベースのメカニズム*（GLEventListener）を提供します。 *GLAutoDrawable は、オブジェクトの存続期間中に GLAutoDrawable に関連付けられたプライマリレンダリングコンテキストを自動的に作成します。
次の表は、さまざまなメソッドの詳細と GLAutoDrawable インターフェイスの説明を示しています-
| Sr.No | Methods and Descriptions |
|---|---|
| 1 |
GL getGL() GLAutoDrawableインターフェイスの現在のオブジェクトによって使用されるGLパイプラインオブジェクトを返します。 |
| 2 |
void addGLEventListener(GLEventListener Listener) 指定されたリスナーを現在のドロアブルキューの最後に追加します。 |
| 3 |
void addGLEventListener(int index, GLEventListener listener) このドロアブルキューの指定されたインデックスに指定されたリスナーを追加します。 |
| 4 |
void destroy() GLContextを含む、GLAutoDrawableインターフェイスのこのオブジェクトに関連付けられているすべてのリソースを*破棄*します。 |
注意-このパッケージには他のメソッドがあります。 このインターフェイスでは、テンプレートに関連するいくつかの重要なメソッドのみが説明されています。
GLCanvasクラス
*GLCanvas* と *GLJpanel* は、OpenGLコマンドの描画面として利用できる *GLAutoDrawable* インターフェイスを実装するJOGL GUIの2つの主要なクラスです。GLCanvasは、OpenGLレンダリングサポートを提供するヘビーウェイトAWTコンポーネントです。 これは、 AWTAutoGLDrawable インターフェイスの主要な実装です。 また、 java.awt.Canvas クラスを継承します。 重いコンポーネントであるため、特定の場合、 GLJCanvas はswingコンポーネントと正しく統合されない場合があります。 したがって、Swingで使用する場合は注意が必要です。 GLJCanvas で問題が発生した場合は、 GLJPanel クラスを使用する必要があります。
クラス GLCanvas の階層図は以下のようになります-
- GLEventistener インターフェースは、 GLCanvas クラスとともに機能します。 GLCanvas クラスの変更と、それらによって行われた描画要求に応答します。
- GLCanvas クラスがインスタンス化されるたびに、 GLEventListener の* init（）*メソッドが呼び出されます。 このメソッドをオーバーライドして、OpenGL状態を初期化できます。
- GLCanvas が最初に描画（インスタンス化）またはサイズ変更されるたびに、 GLEventListener の* reshape（）*メソッドが実行されます。 OpenGLビューポートと投影行列を初期化するために使用されます。 また、コンポーネントの場所が変更されるたびに呼び出されます。
- GLEventListener のdisplay（）メソッドには、3Dシーンをレンダリングするためのコードが含まれています。 GLCanvas のdisplay（）メソッドが呼び出されるたびに呼び出されます。
以下は、GLCanvasクラスをインスタンス化するために必要なコンストラクターです。
| Sr.No | Constructor and Description |
|---|---|
| 1 |
GLCanvas() デフォルトのOpenGL機能選択メカニズムを使用して、デフォルトのOpenGL機能のデフォルトのセットを使用して、デフォルトの画面デバイス上に新しいGLCanvasコンポーネントを作成します。 |
| 2 |
GLCanvas(GLCapabilitiesImmutable) デフォルトの画面デバイスでデフォルトのOpenGL機能選択メカニズムを使用して、要求されたOpenGL機能のセットで新しいGLCanvasコンポーネントを作成します。 |
以下は、GLCanvasクラスのイベント処理に使用されるメソッドです。
| Sr. No. | Methods and Description |
|---|---|
| 1 |
void addGLEventListener(GLEventListener listener) 指定されたリスナーをこのドロアブルキューの最後に追加します。 |
| 2 |
void addGLEventListener(int indexGLEventListener listener) このドロアブルキューの指定されたインデックスに指定されたリスナーを追加します。 |
*GLCanvas* クラスをインスタンス化するには、OpenGL機能の不変のセットを指定する *GLCapabilitiesImmutable* インターフェイスのオブジェクトが必要です。*CapabilitiesImmutable* インターフェースのオブジェクトを取得する方法の1つは、インターフェースを実装する *GLCapabilities* クラスをインスタンス化することです。 *GLCapabilities* クラスのインスタンスを使用して目的を果たすことができます。GLCapabilitiesクラス
このクラスは、OpenGL機能のセットを指定します。 GLCapabilitiesオブジェクトをパラメーターとして受け取ります。 GLCapabilities クラスは、OpenGLプロファイルなど、レンダリングコンテキストがサポートする必要がある機能を記述します。
以下は、GLCapabilitiesクラスをインスタンス化するコンストラクタです。
| Sr. No. | Methods and Description |
|---|---|
| 1 |
GLCapabilities(GLProfile glprofile) GLCapabilitiesオブジェクトを作成します。 |
*GLCanvas* クラスをインスタンス化するには、OpenGL機能の不変のセットを指定するGLCapabilitiesImmutableインターフェイスのオブジェクトが必要です。*CapabilitiesImmutable* インターフェースのオブジェクトを取得する方法の1つは、インターフェースを実装する *GLCapabilities* クラスをインスタンス化することです。 *GLCapabilities* クラスのインスタンスを使用して目的を果たすことができます。また、 GLCapabilities クラスには GLProfile オブジェクトが必要です。
GLProfileクラス
OpenGL APIのいくつかのバージョンがリリースされたため。プログラムで使用されているOpenGL APIの正確なバージョンをJava仮想マシン（JVM）に指定する必要があります。 これは、 GLProfile クラスを使用して行われます。
このクラスの* get（）メソッドは、事前定義されたさまざまな *String オブジェクトをパラメーターとして受け入れます。 各Stringオブジェクトはインターフェイスの名前であり、各インターフェイスはOpenGLの特定のバージョンをサポートしています。 このクラスを静的およびシングルトンとして初期化すると、使用可能なJOGLプロファイルごとにシングルトン GLProfile オブジェクトが提供されます。
以下は、GLProfileクラスのgetメソッドのプロトタイプです。
| Sr.No. | Method and Description |
|---|---|
| 1 |
Static GLProfile get(String profile) デフォルトのデバイスを使用します。 |
これは静的メソッドであるため、クラス名を使用して呼び出す必要があり、パラメーターとして定義済みの静的文字列変数が必要です。 このクラスには12個のそのような変数があり、それぞれがGLインターフェイスの個々の実装を表します。
GLProfile.get(GLProfile.GL2);get（）メソッドのパラメーター
次の表は、 GLProfile クラスの* get（）*メソッドのStringパラメーターを示しています-
| Sr.No | Predefined String value (Interface name) and Description |
|---|---|
| 1 |
GL2 このインターフェイスには、すべてのOpenGL [1.0…3.0]メソッドと、この仕様の時点で定義されているほとんどの拡張機能が含まれています。 |
| 2 |
GLES1 このインターフェイスには、すべてのOpenGL ES [1.0 … 1.1]メソッドと、この仕様の時点で定義されているほとんどの拡張機能。 |
| 3 |
GLES2 このインターフェースには、すべてのOpenGL ES 2.0メソッドと、この仕様の時点で定義されているほとんどの拡張機能が含まれています。 |
| 4 |
GLES3 このインターフェイスには、すべてのOpenGL ES 3.0メソッドと、この仕様の時点で定義されているほとんどの拡張機能が含まれています。 |
| 5 |
GL2ES1 このインターフェイスには、GL2およびGLES1の共通サブセットが含まれています。 |
| 6 |
GL2ES2 このインターフェイスには、GL3、GL2、およびGLES2の共通サブセットが含まれています。 |
| 7 |
GL2GL3 このインターフェイスには、コアGL3（OpenGL 3.1+）およびGL2の共通サブセットが含まれています。 |
| 8 |
GL3 このインターフェイスには、すべてのOpenGL [3.1 … 3.3]この仕様の時点で定義されている_core_メソッドとその拡張のほとんど。 |
| 9 |
GL3bc このインターフェイスには、すべてのOpenGL [3.1 … 3.3] _compatibility_メソッド、およびこの仕様の時点で定義されているほとんどの拡張機能。 |
| 10 |
GL3ES3 このインターフェイスには、コアGL3（OpenGL 3.1+）およびGLES3（OpenGL ES 3.0）の共通サブセットが含まれています。 |
| 11 |
GL4 このインターフェイスには、すべてのOpenGL [4.0 … 4.3] _core_メソッド、およびこの仕様の時点で定義されているほとんどの拡張。 |
| 12 |
GL4bc このインターフェイスには、すべてのOpenGL [4.0 … 4.3] 互換性プロファイル、この仕様の時点で定義されている拡張機能のほとんどと同様。 |
| 13 |
GL4ES3 コアGL4（OpenGL 4.0+）およびGLES3（OpenGL ES 3.0）の共通サブセットを含むインターフェース。 |
GLJPanelクラス
OpenGLレンダリングサポートを提供する軽量のSwingコンポーネントです。 Swingとの互換性のために提供されています。
GLJPanelクラス階層
以下は、GLJPanelクラスのクラス階層を表す図です。
以下は、GLJPanelクラスのさまざまなコンストラクタです。
| Sr. No. | Constructors and Description |
|---|---|
| 1 |
GJPanel() OpenGL機能のデフォルトセットを使用して、新しいGLJPanelコンポーネントを作成します。 |
| 2 |
(GLCapabilitiesImmutable) 要求されたOpenGL機能のセットを使用して、新しいGLJPanelコンポーネントを作成します。 |
| 3 |
GLJPanel(GLCapabilitiesImmutable userCapsRequest, GLCapabilitiesChooser chooser) 新しいGLJPanelコンポーネントを作成します。 |
以下は、GLJPanelクラスのメソッドです。
| Sr.No. | Methods and Description |
|---|---|
| 1 |
void addGLEventListener(GLEventListener listener) このメソッドは、指定されたリスナーをこのドロアブルキューの最後に追加します。 |
| 2 |
void addGLEventListener(int indexGLEventListener listener) このメソッドは、このドロアブルキューの指定されたインデックスに指定されたリスナーを追加します。 |
JOGL-AWTを備えたキャンバス
この章では、Canvas with AWT frameを使用してJOGL基本フレームを描画する方法について説明します。 ここでは、AWTフレームを構築し、フレームクラスの* add（）*メソッドを使用してキャンバスオブジェクトをAWTフレームに追加します。
以下は、JOGLのCanvasクラスとAWTのFrameクラスの組み合わせでJOGL基本フレームを作成するプログラムを作成する手順です。
ステップ1：クラスの作成
最初に GlEventListener インターフェースを実装するクラスを作成し、パッケージjavax.media.openglをインポートします。 4つのメソッドをすべて実装します* display（）、dispose（）、* * reshape（）、init（）。これは基本フレームなので、キャンバスクラスの作成、フレームへの追加などの基本的なタスクについて説明しました。 すべての *GLEVentListener インターフェイスメソッドは実装されていません。
ステップ2：キャンバスの準備
（a） GLCanvas クラスオブジェクトの構築
final GLCanvas glcanvas = new GLCanvas( xxxxxxx );
//here capabilities obj should be passed as parameter（b） GLCapabilities クラスのインスタンス化
GLCapabilities capabilities = new GLCapabilities( xxxxx );
//here profile obj should be passed as parameter（c） GLProfile オブジェクトの生成
これは静的メソッドであるため、クラス名を使用して呼び出されます。 このチュートリアルはJOGL2に関するものなので、GL2インターフェイスオブジェクトを生成しましょう。
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
//both, variable and method are static hence both are called using class name.canvasのコードスニペットを見てみましょう。
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);（d） * addGLEventListener（）メソッドを使用して *GLEventListener をキャンバスに追加します。 このメソッドには、パラメータとして GLEventListener インターフェイスのオブジェクトが必要です。 したがって、 GLEventListener を実装するクラスのオブジェクトを渡します。
BasicFrame basicframe = newBasic Frame( );//class which implements
GLEventListener interface
glcanvas.addGLEventListener( basicframe );（e） javax.media.opengl.awt.AWTGLAutoDrawableからGLCanvasによって継承されたsetSize（）メソッドを使用してフレームのサイズを設定します。
glcanvas.setSize( 400, 400 );これで、 GLCanvas の準備が整いました。
ステップ3：フレームの作成
JSE AWTフレームコンポーネントの Frame クラスオブジェクトをインスタンス化してフレームを作成します。
キャンバスを追加して、フレームを表示します。
//creating frame
final Frame frame = new frame( " Basic Frame" );
//adding canvas to frame
frame.add( glcanvas );
frame.setVisible( true );ステップ4：フレームを全画面表示する
フレームを全画面で表示するには、 java.awt.Toolkit クラスを使用してデフォルトの画面サイズを取得します。 次に、これらのデフォルトの画面サイズの寸法を使用して、* setSize（）*メソッドを使用してフレームサイズを設定します。
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
frame.setSize(screenSize.width, screenSize.height);AWTを使用して基本的なフレームを生成するプログラムを見てみましょう-
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class BasicFrame implements GLEventListener {
@Override
public void display(GLAutoDrawable arg0) {
//method body
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
//method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
BasicFrame b = new BasicFrame();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final Frame frame = new Frame (" Basic Frame");
//adding canvas to frame
frame.add(glcanvas);
frame.setSize( 640, 480 );
frame.setVisible(true);
}
}上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 AGLで GLCanvas クラスを使用すると形成される基本的なフレームを示しています-
JOGL-Swingを使用したキャンバス
この章では、 Canvas およびjavax.swingパッケージの JFrame クラスを使用してJOGL基本フレームを描画する方法について説明します。 ここで、JFrameをインスタンス化し、* add（）*メソッドを使用してJFrameのインスタンスにキャンバスオブジェクトを追加します。
CanvasをAWTで使用すると、ヘビーウェイト機能を備えたグラフィカルフレームが得られます。 軽量のグラフィカルフレームを使用するには、Swingで GLCanvas を使用する必要があります。 Swingで GLCanvas を使用しているときに、 JFrame ウィンドウに GLCanvas を直接配置するか、 JPanel に追加できます。
以下に示すのは、JOGLの GLCanvas クラスと_javax.swing_パッケージの JFrame クラスの組み合わせでJOGL基本フレームを作成するプログラムです。
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class BasicFrame implements GLEventListener {
@Override
public void display(GLAutoDrawable arg0) {
//method body
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
//method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
BasicFrame b = new BasicFrame();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" Basic Frame");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 Swingウィンドウで GLCanvas を使用したときに形成される基本的なフレームを示しています。
JOGL-GLJPanelクラス
この章では、GLJpanelクラスを使用してJOGL基本フレームを描画する方法について説明します。 OpenGLレンダリングサポートを提供する軽量のSwingコンポーネントです。 Swingとの互換性のために提供されています。 ここでは、JFrameをインスタンス化し、* add（）*メソッドを使用してGLJpanelオブジェクトをJFrameのインスタンスに追加します。
次のプログラムは、スイングウィンドウで GLJPanel を使用して基本フレームを生成します-
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class BasicFrame implements GLEventListener {
@Override
public void display(GLAutoDrawable arg0) {
//method body
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
//method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The GLJpanel class
GLJPanel gljpanel = new GLJPanel( glcapabilities );
BasicFrame b = new BasicFrame();
gljpanel.addGLEventListener(b);
gljpanel.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" Basic Frame");
//adding canvas to it
frame.getContentPane().add( gljpanel);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 これは、スイングウィンドウで GLJPanel を使用したときに形成される基本的なフレームを示しています-
JOGL-描画の基本
OpenGL APIは、ポイント、頂点、ラインなどの基本的なグラフィック要素を描画するためのプリミティブメソッドを提供しています。 これらの方法を使用して、三角形、多角形、円などの形状を作成できます。 2Dおよび3Dの両方の次元。 この章では、JavaプログラムでJOGLを使用して基本的な線を描く方法を説明します。
描画オブジェクト
ハードウェアおよびオペレーティングシステムプラットフォームに固有であり、ライブラリがCやC ++（ネイティブアプリケーション）などの他の言語で記述されているプログラムにアクセスするために、Javaは* Java Native Interface（JNI）*と呼ばれるプログラミングフレームワークを使用します。 JOGLはこのインターフェイスを内部的に使用して、次の図に示すようにOpenGL関数にアクセスします。
*GLEventListener* インターフェースの4つのメソッドにはすべて、OpenGL関数を内部的に呼び出すコード（java JOGLメソッド）があります。 これらのJOGLメソッドの命名も、OpenGLの命名規則に似ています。 OpenGLの関数名が* glBegin（）*の場合、* gl.glBegin（）*として使用されます。java JOGLの* gl.glBegin（）メソッドが呼び出されると、OpenGLの glBegin（）*メソッドが内部的に呼び出されます。 これが、JOGLのインストール時にユーザーシステムにネイティブライブラリファイルをインストールする理由です。
Display（）メソッド
これは、グラフィックを開発するためのコードを保持する重要な方法です。 パラメータとして GLAutoDrawable インターフェイスオブジェクトが必要です。
- display（）*メソッドは、最初にGLインターフェイスのオブジェクトを使用してOpenGLコンテキストを取得します（GLは、すべてのOpenGLコンテキストオブジェクトを生成するメソッドを含むGLBaseインターフェイスを継承します）。 このチュートリアルはJOGL2に関するものなので、GL2オブジェクトを生成しましょう。
次のコードスニペットは、GL2オブジェクトを生成する方法を示しています-
//Generating GL object
GL gl = drawable.getGL();
GL gl = drawable.getGL();
//Using this Getting the Gl2 Object
//this can be written in a single line like
final GL2 gl = drawable.getGL().getGL2();GL2インターフェースのオブジェクトを使用すると、このインターフェースのメンバーにアクセスでき、OpenGL [1.0 … 3.0]機能。
線を引く
GL2インターフェースにはメソッドの膨大なリストが含まれていますが、ここでは3つの重要なメソッド、つまり* glBegin（）、 glVertex（）、および glEnd（）*について説明します。
| Sr.No. | Methods and Description |
|---|---|
| 1 |
glBegin() このメソッドは、線を描画するプロセスを開始します。 これは、GLインターフェイスから継承される定義済みの文字列整数「GL_LINES」をパラメーターとして受け取ります。 |
| 2 |
glVertex3f()/glVertex2f() このメソッドは頂点を作成し、3次元浮動小数点座標と2次元浮動小数点座標をそれぞれ示すパラメーター3fと2fとして座標を渡す必要があります。 |
| 3 |
glEnd() 行を終了します |
以下は、JOGLを使用して基本的な線を描画するプログラムです-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Line implements GLEventListener {
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINES);//static field
gl.glVertex3f(0.50f,-0.50f,0);
gl.glVertex3f(-0.50f,0.50f,0);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Line l = new Line();
glcanvas.addGLEventListener(l);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame ("straight Line");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;JOGL-GLラインを使用した描画
前の章では、JOGLを使用して基本的な線を引く方法を学びました。 事前定義フィールド Gl_lines を_glBegin（）_メソッドに渡すことで線を描画します。
この章では、glBegin（）メソッドとGL_Linesを使用して、三角形、菱形、家のような形状を描く例を示します。
GL_LINESを使用して三角形を描くプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Triangle implements GLEventListener {
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINES);
//drawing the base
gl.glBegin (GL2.GL_LINES);
gl.glVertex3f(-0.50f, -0.50f, 0);
gl.glVertex3f(0.50f, -0.50f, 0);
gl.glEnd();
//drawing the right edge
gl.glBegin (GL2.GL_LINES);
gl.glVertex3f(0f, 0.50f, 0);
gl.glVertex3f(-0.50f, -0.50f, 0);
gl.glEnd();
//drawing the lft edge
gl.glBegin (GL2.GL_LINES);
gl.glVertex3f(0f, 0.50f, 0);
gl.glVertex3f(0.50f, -0.50f, 0);
gl.glEnd();
gl.glFlush();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
//method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Triangle l = new Triangle();
glcanvas.addGLEventListener(l);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame ("Triangle");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 * glBegin（）*メソッドのGL_LINESを使用して描かれた三角形を示しています。
GL_LINESを使用して菱形を描くプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Rhombus implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
//edge1
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0.0f,0.75f,0 );
gl.glVertex3f( -0.75f,0f,0 );
gl.glEnd();
//edge2
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.75f,0f,0 );
gl.glVertex3f( 0f,-0.75f, 0 );
gl.glEnd();
//edge3
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0f,-0.75f, 0 );
gl.glVertex3f( 0.75f,0f, 0 );
gl.glEnd();
//edge4
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0.75f,0f, 0 );
gl.glVertex3f( 0.0f,0.75f,0 );
gl.glEnd();
gl.glFlush();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init(GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
//method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Rhombus rhombus = new Rhombus();
glcanvas.addGLEventListener( rhombus );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame ( "Rhombus" );
//adding canvas to frame
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}
}上記のプログラムをコンパイルして実行すると、次の出力が得られます。 * glBegin（）*メソッドのGL_LINESを使用して生成された菱形を示しています。
GL_LINESを使用して家を描くプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class House implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
//drawing top
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( -0.3f, 0.3f, 0 );
gl.glVertex3f( 0.3f,0.3f, 0 );
gl.glEnd();
//drawing bottom
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.3f,-0.3f, 0 );
gl.glVertex3f( 0.3f,-0.3f, 0 );
gl.glEnd();
//drawing the right edge
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.3f,0.3f, 0 );
gl.glVertex3f( -0.3f,-0.3f, 0 );
gl.glEnd();
//drawing the left edge
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0.3f,0.3f,0 );
gl.glVertex3f( 0.3f,-0.3f,0 );
gl.glEnd();
//building roof
//building lft dia
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0f,0.6f, 0 );
gl.glVertex3f( -0.3f,0.3f, 0 );
gl.glEnd();
//building rt dia
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( 0f,0.6f, 0 );
gl.glVertex3f( 0.3f,0.3f, 0 );
gl.glEnd();
//building door
//drawing top
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( -0.05f, 0.05f, 0 );
gl.glVertex3f( 0.05f, 0.05f, 0 );
gl.glEnd();
//drawing the left edge
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( -0.05f, 0.05f, 0 );
gl.glVertex3f( -0.05f, -0.3f, 0 );
gl.glEnd();
//drawing the right edge
gl.glBegin ( GL2.GL_LINES );
gl.glVertex3f( 0.05f, 0.05f, 0 );
gl.glVertex3f( 0.05f, -0.3f, 0 );
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
//method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
House house = new House();
glcanvas.addGLEventListener( house );
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame( "House" );
//adding canvas to frame
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の出力が得られます。 GL_LINES（）メソッドを使用して生成された家の図を示しています。
JOGL-事前定義された形状
前の章で、JOGLを使用して線、三角形、菱形などの図形を描画する方法を学習しました。 事前定義フィールド Gl_lines を_glBegin（）_メソッドに渡すことで線を描画します。
*GL_LINES* 以外に、* glBegin（）*メソッドはさらに8つのパラメーターを受け入れます。 それらを使用して、さまざまな形状を描くことができます。 これらはGL_LINESと同じ方法で使用されます。次の表は、* glBegin（）*メソッドのパラメーターとその説明を示しています-
| Sr.No | Parameters and Description |
|---|---|
| 1 |
GL_LINES 頂点の各ペアを独立したラインセグメントとして作成します。 |
| 2 |
GL_LINE_STRIP 最初の頂点から最後までの線セグメントの接続グループを描画します。 |
| 3 |
GL_LINE_LOOP 最初の頂点から最後まで線セグメントの接続グループを描画し、再び最初に戻します。 |
| 4 |
GL_TRIANGLES 頂点の各トリプレットを独立した三角形として扱います。 |
| 5 |
GL_TRIANGLE_STRIP 接続された三角形のグループを描画します。 最初の2つの頂点の後に表示される各頂点に対して1つの三角形が定義されます。 |
| 6 |
GL_TRIANGLE_FAN 接続された三角形のグループを描画します。 最初の2つの頂点の後に表示される各頂点に対して1つの三角形が定義されます。 |
| 7 |
GL_QUADS 4つの頂点の各グループを独立した四辺形として扱います。 |
| 8 |
GL_QUAD_STRIP 接続された四角形のグループを描画します。 最初のペアの後に表示される頂点の各ペアに対して、1つの四角形が定義されます。 |
| 9 |
GL_POLYGON 単一の凸多角形を描画します。 頂点1、…、nはこのポリゴンを定義します。 |
- glBegin（）*パラメーターを使用した例をいくつか見てみましょう。
ラインストリップを描くプログラム
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class LineStrip implements GLEventListener {
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINE_STRIP);
gl.glVertex3f(-0.50f,-0.75f, 0);
gl.glVertex3f(0.7f,0.5f, 0);
gl.glVertex3f(0.70f,-0.70f, 0);
gl.glVertex3f(0f,0.5f, 0);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
//method body
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
LineStrip r = new LineStrip();
glcanvas.addGLEventListener(r);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame ("LineStrip");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;上記のコードをコンパイルして実行すると、次の出力が生成されます-
ラインループを描画するdisplay（）メソッドのコードスニペット
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_LINE_LOOP);
gl.glVertex3f( -0.50f, -0.75f, 0);
gl.glVertex3f(0.7f, .5f, 0);
gl.glVertex3f(0.70f, -0.70f, 0);
gl.glVertex3f(0f, 0.5f, 0);
gl.glEnd();
}基本テンプレートプログラムのいずれかの* display（）*メソッドを上記のコードで置き換え、コンパイルして実行すると、次の出力が生成されます-
GL_TRIANGLESを使用して三角形を描画するdisplay（）メソッドのコードスニペット
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin(GL2.GL_TRIANGLES); //Drawing Using Triangles
gl.glVertex3f(0.5f,0.7f,0.0f); //Top
gl.glVertex3f(-0.2f,-0.50f,0.0f); //Bottom Left
gl.glVertex3f(0.5f,-0.5f,0.0f); //Bottom Right
gl.glEnd();
}基本テンプレートプログラムのいずれかの* display（）*メソッドを上記のコードで置き換え、コンパイルして実行すると、次の出力が生成されます-
三角形ストリップを描画するdisplay（）メソッドのコードスニペット
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin (GL2.GL_TRIANGLE_STRIP);
gl.glVertex3f(0f,0.5f,0);
gl.glVertex3f(-0.50f,-0.75f,0);
gl.glVertex3f(0.28f,0.06f,0);
gl.glVertex3f(0.7f,0.5f,0);
gl.glVertex3f(0.7f,-0.7f,0);
gl.glEnd();
}基本テンプレートプログラムのいずれかの* display（）*メソッドを上記のコードで置き換え、コンパイルして実行すると、次の出力が生成されます-
四角形を描画するdisplay（）メソッドのコードスニペット
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin(GL2.GL_QUADS);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(0f,-0.75f,0);
gl.glVertex3f(0.75f,0f,0);
gl.glEnd();
}基本テンプレートプログラムのいずれかの* display（）*メソッドを上記のコードで置き換え、コンパイルして実行すると、次の出力が生成されます-
ポリゴンを描画するdisplay（）メソッドのコードスニペット
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin(GL2.GL_POLYGON);
gl.glVertex3f(0f,0.5f,0f);
gl.glVertex3f(-0.5f,0.2f,0f);
gl.glVertex3f(-0.5f,-0.2f,0f);
gl.glVertex3f(0f,-0.5f,0f);
gl.glVertex3f(0f,0.5f,0f);
gl.glVertex3f(0.5f,0.2f,0f);
gl.glVertex3f(0.5f,-0.2f,0f);
gl.glVertex3f(0f,-0.5f,0f);
gl.glEnd();
}基本テンプレートプログラムのいずれかの* display（）*メソッドを上記のコードに置き換え、コンパイルして実行すると、次の出力が生成されます-
JOGL-変換
OpenGLは、オブジェクトへの色の適用、スケーリング、照明、オブジェクトの回転など、より多くの機能を提供します。 この章では、JOGLを使用したオブジェクトのいくつかの変換について説明します。
ウィンドウ上のオブジェクトの移動
前の章で、線を描画し、単純な線を使用してさまざまな形状を描画するプログラムについて説明しました。 この方法で作成された図形は、ウィンドウ内の任意の場所に表示できます。 メソッド* glTranslatef（float x、float y、float z）*を使用して行われます。
このメソッドは、 javax.media.opengl.fixedfunc パッケージに含まれる GLMatrixFunc インターフェースに属します。
GLMatrixFuncインターフェース
インターフェース-GLMatrixFunc
パッケージ-javax.media.opengl.fixedfunc
次の表は、このインターフェイスのいくつかの重要なメソッドを示しています-
| Sr.No. | Methods and Description |
|---|---|
| 1 |
void glRotatef(float angle, float x, float y, float z) 現在のマトリックスを回転します。 |
| 2 |
void glScalef(float x, float y, float z) 現在のマトリックスのスケーリングに使用されます。 |
| 3 |
void glTranslatef(float x, float y,float z) 現在のマトリックスを変換するために使用されます。 |
| 4 |
void glLoadIdentity() 現在の行列に単位行列をロードします。 |
- glTranslate（）メソッドは、座標系の原点をパラメーター（x、y、z）で指定された点に移動し、 glTranslate（）*メソッドに次のように渡されます。
引数。 未変換の座標系を保存および復元するには、* glPushMatrix（）および glPopMatrix（）*メソッドが使用されます。
gl.glTranslatef(0f, 0f, -2.5f);- glTranslate（）が使用されるたびに、画面上のコンポーネントの位置が変更されます。 したがって、 *GLEventListener インターフェイスの* reshape（）*メソッドをオーバーライドし、OpenGLビューポートと投影行列を初期化する必要があります。
次のコードは、ビューポートと投影行列を初期化するテンプレートを示しています-
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
//get the OpenGL 2 graphics object
if(height <= 0) height = 1;
//preventing devided by 0 exception height = 1;
final float h = (float) width/(float) height;
//display area to cover the entire window
gl.glViewport(0, 0, width, height);
//transforming projection matrix
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
//transforming model view gl.glLoadIdentity();
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}JOGL-ぬりえ
この章では、JOGLを使用してオブジェクトに色を適用する方法を説明します。 オブジェクトに色を適用するには、 GL2 の* glColor（）*メソッドを使用します。 以下は、glColorメソッドを使用するための構文です。
構文
gl.glColorXY(1f,0f,0f);どこで、
*Xは、使用される色の数を示します。3（赤、緑、青）または4（赤、緑、青、アルファ）。 さまざまな色の組み合わせを取得するために、これらの色の値がパラメーターとして渡されます。 カラーパラメータの順序は、この順序で維持する必要があります。
+* 例* +色の値を（1、0、0）として渡すと、赤色になります。 同様に、（1、1、0）は黄色になります。
* Yは、byte（b）、double（d）、float（f）、int（i）、short（s）、ubyte（ub）、uint（ui）、ushort（us）などのパラメーターを受け入れるデータ型を示します。gl.glColor3f(1f,0f,0f); //gives us red
gl.glColor3f(0f,1f,0f); //gives us green
gl.glColor3f(0f,0f,1f); //gives us blue三角形の場合、頂点ごとに異なる色を適用できます。
私たちは三角形に色を適用するプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class TriangleColor implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glBegin( GL2.GL_TRIANGLES );
//Drawing Using Triangles
gl.glColor3f( 1.0f, 0.0f, 0.0f ); //Red
gl.glVertex3f( 0.5f,0.7f,0.0f ); //Top
gl.glColor3f( 0.0f,1.0f,0.0f ); //green
gl.glVertex3f( -0.2f,-0.50f,0.0f );//Bottom Left
gl.glColor3f( 0.0f,0.0f,1.0f ); //blue
gl.glVertex3f( 0.5f,-0.5f,0.0f ); //Bottom Right
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
//method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
TriangleColor triangle = new TriangleColor();
glcanvas.addGLEventListener( triangle );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" Colored Triangle");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize());
frame.setVisible( true );
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の色付きの三角形が表示されます-
ポリゴンに色を適用する
多角形に色を適用するプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class PolygonColor implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glColor3f( 1f,0f,0f );//applying red
gl.glBegin( GL2.GL_POLYGON );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( -0.5f,0.2f,0f );
gl.glVertex3f( -0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( 0.5f,0.2f,0f );
gl.glVertex3f( 0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
//method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
PolygonColor polygon = new PolygonColor();
glcanvas.addGLEventListener( polygon );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame ( "Colored Polygon" );
//adding canvas to frame
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の色付きのポリゴンが得られます-
JOGL-スケーリング
この章では、JOGLを使用してオブジェクトを拡大縮小する方法、つまりオブジェクトのサイズを拡大または縮小する方法について説明します。
オブジェクトのスケーリングは、 GLMatrixFunc インターフェイスの* glScalef（float x、float y、float z）*メソッドを使用して行われます。 このメソッドは、x、y、z軸に沿ってそれぞれスケール係数を指定する3つの浮動小数点パラメーターを受け入れます。
たとえば、次のプログラムでは、三角形が50％に縮小されます。 ここでは、値50がすべての軸に沿ってパラメーターとして渡されます。
私たちは三角形をスケーリングするためにプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
public class Scaling implements GLEventListener {
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glScalef( 0.50f,0.25f,0.50f );
gl.glBegin( GL2.GL_TRIANGLES );
//Drawing Using Triangles
gl.glColor3f( 1.0f, 0.0f, 0.0f ); //Red
gl.glVertex3f( 0.5f,0.7f,0.0f ); //Top
gl.glColor3f( 0.0f,1.0f,0.0f ); //blue
gl.glVertex3f( -0.2f,-0.50f,0.0f );//Bottom Left
gl.glColor3f( 0.0f,0.0f,1.0f ); //green
gl.glVertex3f( 0.5f,-0.5f,0.0f ); //Bottom Right
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
//method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Scaling scaling = new Scaling();
glcanvas.addGLEventListener( scaling );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" Dimnished Triangle (Scaling )");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;上記のプログラムをコンパイルして実行すると、次の出力が得られます。 ここでは、TriangleColor.javaによって生成された元の三角形と比較して、減少した三角形を観察できます-
JOGL-回転
この章では、JOGLを使用してオブジェクトを回転させる方法を説明しました。 オブジェクトの回転は、 GLMatrixFunc インターフェイスの* glRotatef（float angle、float x、float y、float z）*メソッドを使用して、3つの軸のいずれかに沿って行うことができます。 このメソッドのパラメーターとして回転角とx、y、z軸を渡す必要があります。
次の手順は、オブジェクトを正常に回転させるためのガイドです-
- * gl.glClear（GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT）*メソッドを使用して、最初にカラーバッファーと深度バッファーをクリアします。 このメソッドは、オブジェクトの以前の状態を消去し、ビューを明確にします。
- * glLoadIdentity（）*メソッドを使用して投影行列をリセットします。
アニメータークラスをインスタンス化し、* start（）*メソッドを使用してアニメーターを開始します。
FPSAnimatorクラス
以下に、FPSAnimatorクラスのさまざまなコンストラクターを示します。
| Sr.No. | Methods and Descriptions |
|---|---|
| 1 |
FPSAnimator(GLAutoDrawable drawable, int fps) 指定された1秒あたりのターゲットフレーム値とアニメーション化する初期ドローアブルでFPSAnimatorを作成します。 |
| 2 |
FPSAnimator(GLAutoDrawable drawable, int fps, boolean cheduleAtFixedRate) 与えられた1秒あたりのターゲットフレーム値、アニメーション化する初期ドロアブル、および固定レートスケジューリングを使用するかどうかを示すフラグを使用して、FPSAnimatorを作成します。 |
| 3 |
FPSAnimator(int fps) 指定されたターゲットフレーム/秒値でFPSAnimatorを作成します。 |
| 4 | It creates an FPSAnimator with a given target frames-per-second value and a flag indicating whether to use fixed rate scheduling. |
特定の1秒あたりのターゲットフレーム値と固定レートスケジューリングを使用するかどうかを示すフラグを使用して、FPSAnimatorを作成します。
- start（）および stop（）*は、このクラスの2つの重要なメソッドです。 次のプログラムは、FPSAnimatorクラスを使用して三角形を回転させる方法を示しています-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class TriangleRotation implements GLEventListener {
private float rtri; //for angle of rotation
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glClear (GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT );
//Clear The Screen And The Depth Buffer
gl.glLoadIdentity(); //Reset The View
//triangle rotation
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
//Drawing Using Triangles
gl.glBegin( GL2.GL_TRIANGLES );
gl.glColor3f( 1.0f, 0.0f, 0.0f ); //Red
gl.glVertex3f( 0.5f,0.7f,0.0f ); //Top
gl.glColor3f( 0.0f,1.0f,0.0f ); //blue
gl.glVertex3f( -0.2f,-0.50f,0.0f );//Bottom Left
gl.glColor3f( 0.0f,0.0f,1.0f ); //green
gl.glVertex3f( 0.5f,-0.5f,0.0f ); //Bottom Right
gl.glEnd();
gl.glFlush();
rtri += 0.2f; //assigning the angle
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities);
TriangleRotation triangle = new TriangleRotation();
glcanvas.addGLEventListener( triangle );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame ("Rotating Triangle");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane() .getPreferredSize());
frame.setVisible( true );
//Instantiating and Initiating Animator
final FPSAnimator animator = new FPSAnimator(glcanvas, 300,true);
animator.start();
}
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 ここでは、x軸を中心に色付きの三角形を回転させるさまざまなスナップショットを見ることができます。
JOGL-照明
この章では、JOGLを使用してオブジェクトに照明効果を適用する方法について説明します。
照明を設定するには、最初に* glEnable（）メソッドを使用して照明を有効にします。 次に、 *GLLightingFunc インターフェイスの* glLightfv（int light、int pname、float [] params、int params_offset）*メソッドを使用して、オブジェクトに照明を適用します。 このメソッドは4つのパラメーターを取ります。
次の表に、* gllightfv（）*メソッドのパラメーターを示します。
| Sr.No. | Parameter Name and Description |
|---|---|
| 1 |
Light ライトを指定します。 ライトの数は実装によって異なりますが、少なくとも8つのライトがサポートされます。 10個の値を受け入れます。これらのパラメーターは、以下に示す「光源パラメーター」という名前の別の表で説明されています。 |
| 2 |
Pname 単一値の光源パラメーターを指定します。 光源については、以下で説明する10個のパラメーターがあります。 |
| 3 |
Params 光源_light_のパラメーター_pname_に設定されている値へのポインターを指定します。 |
| 4 |
Light source parameter 以下に示す任意の光源パラメーターを使用できます。 |
光源パラメーター
次の表は、光源パラメータを示しています-
| Sr.No. | Parameter and Description |
|---|---|
| 1 |
GL_AMBIENT これには、光の周囲の強度を指定するパラメーターが含まれています。 |
| 2 |
GL_DIFFUSE これには、光の拡散強度を指定するパラメーターが含まれています。 |
| 3 |
GL_SPECULAR これには、光の鏡面反射強度を指定するパラメーターが含まれています。 |
| 4 |
GL_POSITION 同種のオブジェクト座標でのライトの位置を指定する4つの整数値または浮動小数点値が含まれます。 |
| 5 |
GL_SPOT_DIRECTION 同種のオブジェクト座標で光の方向を指定するパラメーターが含まれています。 |
| 6 |
GL_SPOT_EXPONENT そのパラメーターは、光の強度分布を指定します。 |
| 7 |
GL_SPOT_CUTOFF この単一のパラメーターは、光の最大広がり角を指定します。 |
| 8 |
GL_CONSTANT_ATTENUATION or GL_LINEAR_ATTENUATION or GL_QUADRATIC_ATTENUATION これらの減衰係数はいずれも使用でき、単一の値で表されます。 |
照明は、引数 GL_LIGHTING を指定した* glEnable（）および *glDisable （）メソッドを使用して有効または無効にします。
次のテンプレートは、照明のために与えられています-
gl.glEnable(GL2.GL_LIGHTING);
gl.glEnable(GL2.GL_LIGHT0);
gl.glEnable(GL2.GL_NORMALIZE);
float[] ambientLight = { 0.1f, 0.f, 0.f,0f }; //weak RED ambient
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambientLight, 0);
float[] diffuseLight = { 1f,2f,1f,0f }; //multicolor diffuse
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuseLight, 0);回転するポリゴンに光を当てる
回転するポリゴンに光を当てるには、指定された手順に従います。
glRotate（）メソッドを使用してポリゴンを回転します
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
//Clear The Screen And The Depth Buffer
gl.glLoadIdentity();
//Reset The View
gl.glRotatef(rpoly, 0.0f, 1.0f, 0.0f);回転するポリゴンに光を当てるプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class PolygonLighting implements GLEventListener {
private float rpoly;
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glColor3f(1f,0f,0f);//applying red
//Clear The Screen And The Depth Buffer
gl.glClear( GL2.GL_COLOR_BUFFER_BIT |
GL2.GL_DEPTH_BUFFER_BIT );
gl.glLoadIdentity(); //Reset The View
gl.glRotatef( rpoly, 0.0f, 1.0f, 0.0f );
gl.glBegin( GL2.GL_POLYGON );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( -0.5f,0.2f,0f );
gl.glVertex3f( -0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glVertex3f( 0f,0.5f,0f );
gl.glVertex3f( 0.5f,0.2f,0f );
gl.glVertex3f( 0.5f,-0.2f,0f );
gl.glVertex3f( 0f,-0.5f,0f );
gl.glEnd();
gl.glFlush();
rpoly += 0.2f; //assigning the angle
gl.glEnable( GL2.GL_LIGHTING );
gl.glEnable( GL2.GL_LIGHT0 );
gl.glEnable( GL2.GL_NORMALIZE );
//weak RED ambient
float[] ambientLight = { 0.1f, 0.f, 0.f,0f };
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient-Light, 0);
//multicolor diffuse
float[] diffuseLight = { 1f,2f,1f,0f };
gl.glLightfv( GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse-Light, 0 );
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4 ) {
//method body
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
PolygonLighting polygonlighting = new PolygonLighting();
glcanvas.addGLEventListener( polygonlighting );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" Polygon lighting ");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize());
frame.setVisible( true );
//Instantiating and Initiating Animator
final FPSAnimator animator = new FPSAnimator(glcanvas, 300,true );
animator.start();
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 ここでは、回転ポリゴンのさまざまなスナップショットを照明で観察できます。
JOGL-3Dの基本
前の章では、2Dオブジェクトを作成し、エフェクトを適用し、オブジェクトを変換する方法を見てきました。 この章では、3次元の線といくつかの形状を描く方法について説明します。
z軸で簡単な線を描き、2Dと3Dの線の違いを見てみましょう。 最初に単純な線を引き、次にウィンドウに3単位で2番目の線を引きます。
私たちは3Dラインを描くためにプログラムを見てみましょう-
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
public class Line3d implements GLEventListener {
private GLU glu = new GLU();
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glTranslatef( 0f, 0f, -2.5f );
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.75f,0f,0 );
gl.glVertex3f( 0f,-0.75f, 0 );
gl.glEnd();
//3d line
gl.glBegin( GL2.GL_LINES );
gl.glVertex3f( -0.75f,0f,3f );//3 units into the window
gl.glVertex3f( 0f,-0.75f,3f );
gl.glEnd();
}
@Override
public void dispose( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void init( GLAutoDrawable arg0 ) {
//method body
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
GL2 gl = drawable.getGL().getGL2();
if( height <= 0 )
height = 1;
final float h = ( float ) width/( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Line3d line3d = new Line3d();
glcanvas.addGLEventListener( line3d );
glcanvas.setSize( 400, 400 );
//creating frame
final JFrame frame = new JFrame (" 3d line");
//adding canvas to it
frame.getContentPane().add( glcanvas );
frame.setSize(frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の出力が生成されます-
上記のビューを生成する* glVertex3f（）*メソッドのz象限にゼロ以外の値を与えることにより、3D形状を描画できます。 残りの線を結合すると、3Dエッジになります。
次に、同じ方法で3次元のエッジを開発します。
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
public class Edge1 implements GLEventListener {
private GLU glu = new GLU();
@Override
public void display(GLAutoDrawable drawable) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
gl.glTranslatef(0f, 0f, -2.5f);
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(0f,-0.75f, 0);
gl.glEnd();
//3d line
gl.glBegin(GL2.GL_LINES);
//3 units in to the window
gl.glVertex3f(-0.75f,0f,3f);
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
//top
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
//bottom
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
//TODO Auto-generated method stubfinal
GL2 gl = drawable.getGL().getGL2();
if(height <= 0)
height = 1;
final float h = (float) width/(float) height;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Edge1 b = new Edge1();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" 3d edge");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of class上記のプログラムをコンパイルして実行すると、次の出力が生成されます-
同様に、2D四辺形の対応する辺に3Dエッジを展開し、隣接する頂点を結合することにより、3D四辺形を取得できます。
以下は、JOGLを使用して菱形を描くプログラムです。
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
public class Rhombus implements GLEventListener {
private GLU glu = new GLU();
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glTranslatef(0f, 0f, -2.5f);
//drawing edge1.....
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(0f,-0.75f, 0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,3f);//3 units into the window
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
//top
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
//bottom
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0f,-0.75f,3f);
gl.glEnd();
//edge 2....
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0.75f,0f, 0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 3f);
gl.glVertex3f(0.75f,0f, 3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0f,-0.75f, 0);
gl.glVertex3f(0f,-0.75f, 3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f, 0);
gl.glVertex3f(0.75f,0f, 3f);
gl.glEnd();
//Edge 3.............
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f(-0.75f,0f,0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(-0.75f,0f,0);
gl.glVertex3f(-0.75f,0f,3f);
gl.glEnd();
//final edge
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f, 0);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f,3f);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f(0.75f,0f, 0);
gl.glVertex3f(0.75f,0f,3f);
gl.glEnd();
gl.glBegin(GL2.GL_LINES);
gl.glVertex3f( 0.0f,0.75f,0);
gl.glVertex3f( 0.0f,0.75f,3f);
gl.glEnd();
}
@Override
public void dispose(GLAutoDrawable arg0) {
//method body
}
@Override
public void init(GLAutoDrawable arg0) {
//method body
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
//TODO Auto-generated method stub final
GL2 gl = drawable.getGL().getGL2();
if(height lt;= 0)
height = 1;
final float h = (float) width/(float) height;
gl.glViewport(3, 6, width, height);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public static void main(String[] args) {
//getting the capabilities object of GL2 profile
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
Rhombus b = new Rhombus();
glcanvas.addGLEventListener(b);
glcanvas.setSize(400, 400);
//creating frame
final JFrame frame = new JFrame (" Rhombus 3d");
//adding canvas to it
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}//end of main
}//end of classimport javax.media.opengl.GL2;上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 3Dラインを使用して描画された菱形を示しています。
- glBegin（）*メソッドの定義済みパラメーターは、3D形状の描画に使用できます。
JOGL-3Dトライアングル
前の章では、3Dシェイプの描画方法を見てきましたが、この章では、3D三角形の描画方法と回転方法について説明します。
以下は、3D三角形を描画して回転させるプログラムです。
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class Triangle3d implements GLEventListener {
private GLU glu = new GLU();
private float rtri = 0.0f;
@Override
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
//Clear The Screen And The Depth Buffer
gl.glClear( GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT );
gl.glLoadIdentity();//Reset The View
gl.glTranslatef( -0.5f, 0.0f, -6.0f );//Move the triangle
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
gl.glBegin( GL2.GL_TRIANGLES );
//drawing triangle in all dimensions
//Front
gl.glColor3f( 1.0f, 0.0f, 0.0f );//Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top Of Triangle (Front)
gl.glColor3f( 0.0f, 1.0f, 0.0f );//Green
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Left Of Triangle (Front)
gl.glColor3f( 0.0f, 0.0f, 1.0f );//Blue
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Right Of Triangle (Front)
//Right
gl.glColor3f( 1.0f, 0.0f, 0.0f );//Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top Of Triangle (Right)
gl.glColor3f( 0.0f, 0.0f, 1.0f );//Blue
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Left Of Triangle (Right)
gl.glColor3f( 0.0f, 1.0f, 0.0f );//Green
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Right Of Triangle (Right)
//Left
gl.glColor3f( 1.0f, 0.0f, 0.0f );//Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top Of Triangle (Back)
gl.glColor3f( 0.0f, 1.0f, 0.0f );//Green
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Left Of Triangle (Back)
gl.glColor3f( 0.0f, 0.0f, 1.0f );//Blue
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Right Of Triangle (Back)
//left
gl.glColor3f( 0.0f, 1.0f, 0.0f );//Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top Of Triangle (Left)
gl.glColor3f( 0.0f, 0.0f, 1.0f );//Blue
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Left Of Triangle (Left)
gl.glColor3f( 0.0f, 1.0f, 0.0f );//Green
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Right Of Triangle (Left)
gl.glEnd();//Done Drawing 3d triangle (Pyramid)
gl.glFlush();
rtri += 0.2f;
}
@Override
public void dispose( GLAutoDrawable drawable ) {
//method body
}
@Override
public void init( GLAutoDrawable drawable ) {
//method body
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if(height lt;=;)
height = 1;
final float h = ( float ) width/( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
//TODO Auto-generated method stub
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Triangle3d triangle = new Triangle3d();
glcanvas.addGLEventListener( triangle );
glcanvas.setSize( 400, 400 );
final JFrame frame = new JFrame ( "3d Triangle (shallow)" );
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
final FPSAnimator animator = new FPSAnimator(glcanvas,300,true);
animator.start();
}
}上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 ここには、回転する3D三角形のスナップショットがあります。 このプログラムには深度テストが含まれていないため、三角形は中空に生成されます。
三角形を固くするには、* glEnable（GL_DEPTH_TEST）を使用して深度テストを有効にする必要があります。 深度バッファを有効にすると、空白の画面が表示されます。 これは、 glClear（GL_COLOR_BUFFERBIT | GL_DEPTH_BUFFER_BIT）メソッドを使用して色をクリアすることでクリアできます。 init（）メソッドまたは glDisplay（）*メソッドで深度テストを有効にするには、次のコードを記述します-
public void init(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel(GL2.GL_SMOOTH);
gl.glClearColor(0f, 0f, 0f, 0f);
gl.glClearDepth(1.0f);
gl.glEnable(GL2.GL_DEPTH_TEST);
gl.glDepthFunc(GL2.GL_LEQUAL);
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
}以下は、深度テストで3D三角形を描画するプログラムです。
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class Triangledepthtest implements GLEventListener {
private GLU glu = new GLU();
private float rtri = 0.0f;
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel( GL2.GL_SMOOTH );
gl.glClearColor( 0f, 0f, 0f, 0f );
gl.glClearDepth( 1.0f );
gl.glEnable( GL2.GL_DEPTH_TEST );
gl.glDepthFunc( GL2.GL_LEQUAL );
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
//Clear The Screen And The Depth Buffer
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();//Reset The View
gl.glTranslatef( -0.5f,0.0f,-6.0f );//Move the triangle
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );
gl.glBegin( GL2.GL_TRIANGLES );
//drawing triangle in all dimensions
//front
gl.glColor3f( 1.0f, 0.0f, 0.0f );//Red
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top
gl.glColor3f( 0.0f, 1.0f, 0.0f );//Green
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Left
gl.glColor3f( 0.0f, 0.0f, 1.0f );//Blue
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Right)
//right
gl.glColor3f( 1.0f, 0.0f, 0.0f );
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top
gl.glColor3f( 0.0f, 0.0f, 1.0f );
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Left
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Right
//left
gl.glColor3f( 1.0f, 0.0f, 0.0f );
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Left
gl.glColor3f( 0.0f, 0.0f, 1.0f );
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Right
//top
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( 1.0f, 2.0f, 0.0f );//Top
gl.glColor3f( 0.0f, 0.0f, 1.0f );
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Left
gl.glColor3f( 0.0f, 1.0f, 0.0f );
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Right
gl.glEnd();//Done Drawing 3d triangle (Pyramid)
gl.glFlush();
rtri += 0.2f;
}
@Override
public void dispose( GLAutoDrawable drawable ) {
}
@Override
public void init( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel( GL2.GL_SMOOTH );
gl.glClearColor( 0f, 0f, 0f, 0f );
gl.glClearDepth( 1.0f );
gl.glEnable( GL2.GL_DEPTH_TEST );
gl.glDepthFunc( GL2.GL_LEQUAL );
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST );
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height ) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if( height <= 0 )
height = 1;
final float h = ( float ) width/( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
//TODO Auto-generated method stub
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Triangledepthtest triangledepthtest = new Triangledepthtest();
glcanvas.addGLEventListener( triangledepthtest );
glcanvas.setSize( 400, 400 );
final JFrame frame = new JFrame ( "3d Triangle (solid)" );
frame.getContentPane().add(glcanvas);
frame.setSize( frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
final FPSAnimator animator = new FPSAnimator( glcanvas, 300,true);
animator.start();
}
}上記のプログラムをコンパイルして実行すると、次の出力が生成されます。
ここでは、回転する3D三角形のスナップショットを見ることができます。 このプログラムには深度テスト用のコードが含まれているため、三角形はソリッドで生成されます。
JOGL-3Dキューブ
前の章では、3D三角形を描画して回転させる方法を見てきました。 この章では、3Dキューブの作成方法、回転方法、3Dキューブに画像を添付する方法を学習できます。 同様に、この章では、3Dキューブを描画し、それに色を適用して画像を添付する例を示します。
以下は、3Dキューブを描画し、それに色を適用するプログラムです。
import java.awt.DisplayMode;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
public class Cube implements GLEventListener {
public static DisplayMode dm, dm_old;
private GLU glu = new GLU();
private float rquad = 0.0f;
@Override
public void display( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT );
gl.glLoadIdentity();
gl.glTranslatef( 0f, 0f, -5.0f );
//Rotate The Cube On X, Y & Z
gl.glRotatef(rquad, 1.0f, 1.0f, 1.0f);
//giving different colors to different sides
gl.glBegin(GL2.GL_QUADS);//Start Drawing The Cube
gl.glColor3f(1f,0f,0f);//red color
gl.glVertex3f(1.0f, 1.0f, -1.0f);//Top Right Of The Quad (Top)
gl.glVertex3f( -1.0f, 1.0f, -1.0f);//Top Left Of The Quad (Top)
gl.glVertex3f( -1.0f, 1.0f, 1.0f );//Bottom Left Of The Quad (Top)
gl.glVertex3f( 1.0f, 1.0f, 1.0f );//Bottom Right Of The Quad (Top)
gl.glColor3f( 0f,1f,0f );//green color
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Top Right Of The Quad
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Top Left Of The Quad
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Bottom Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Bottom Right Of The Quad
gl.glColor3f( 0f,0f,1f );//blue color
gl.glVertex3f( 1.0f, 1.0f, 1.0f );//Top Right Of The Quad (Front)
gl.glVertex3f( -1.0f, 1.0f, 1.0f );//Top Left Of The Quad (Front)
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Bottom Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Bottom Right Of The Quad
gl.glColor3f( 1f,1f,0f );//yellow (red + green)
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Bottom Left Of The Quad
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Bottom Right Of The Quad
gl.glVertex3f( -1.0f, 1.0f, -1.0f );//Top Right Of The Quad (Back)
gl.glVertex3f( 1.0f, 1.0f, -1.0f );//Top Left Of The Quad (Back)
gl.glColor3f( 1f,0f,1f );//purple (red + green)
gl.glVertex3f( -1.0f, 1.0f, 1.0f );//Top Right Of The Quad (Left)
gl.glVertex3f( -1.0f, 1.0f, -1.0f );//Top Left Of The Quad (Left)
gl.glVertex3f( -1.0f, -1.0f, -1.0f );//Bottom Left Of The Quad
gl.glVertex3f( -1.0f, -1.0f, 1.0f );//Bottom Right Of The Quad
gl.glColor3f( 0f,1f, 1f );//sky blue (blue +green)
gl.glVertex3f( 1.0f, 1.0f, -1.0f );//Top Right Of The Quad (Right)
gl.glVertex3f( 1.0f, 1.0f, 1.0f );//Top Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, 1.0f );//Bottom Left Of The Quad
gl.glVertex3f( 1.0f, -1.0f, -1.0f );//Bottom Right Of The Quad
gl.glEnd();//Done Drawing The Quad
gl.glFlush();
rquad -= 0.15f;
}
@Override
public void dispose( GLAutoDrawable drawable ) {
//TODO Auto-generated method stub
}
@Override
public void init( GLAutoDrawable drawable ) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel( GL2.GL_SMOOTH );
gl.glClearColor( 0f, 0f, 0f, 0f );
gl.glClearDepth( 1.0f );
gl.glEnable( GL2.GL_DEPTH_TEST );
gl.glDepthFunc( GL2.GL_LEQUAL );
gl.glHint( GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST );
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if( height lt;= 0 )
height = 1;
final float h = ( float ) width/( float ) height;
gl.glViewport( 0, 0, width, height );
gl.glMatrixMode( GL2.GL_PROJECTION );
gl.glLoadIdentity();
glu.gluPerspective( 45.0f, h, 1.0, 20.0 );
gl.glMatrixMode( GL2.GL_MODELVIEW );
gl.glLoadIdentity();
}
public static void main( String[] args ) {
final GLProfile profile = GLProfile.get( GLProfile.GL2 );
GLCapabilities capabilities = new GLCapabilities( profile );
//The canvas
final GLCanvas glcanvas = new GLCanvas( capabilities );
Cube cube = new Cube();
glcanvas.addGLEventListener( cube );
glcanvas.setSize( 400, 400 );
final JFrame frame = new JFrame ( " Multicolored cube" );
frame.getContentPane().add( glcanvas );
frame.setSize( frame.getContentPane().getPreferredSize() );
frame.setVisible( true );
final FPSAnimator animator = new FPSAnimator(glcanvas, 300,true);
animator.start();
}
}上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 色付きの3Dキューブが表示されます。
テクスチャをキューブに適用する
次の手順は、キューブにテクスチャを適用するために与えられています-
- を使用して、必要なテクスチャをキューブにバインドできます Drawableインターフェイスの* gl.glBindTexture（GL2.GL_TEXTURE_2D.texture）*メソッド。
- このメソッドには、* GL2.GL_TEXTURE_2D（int）*とともにテクスチャ（int）引数が必要です。
- * Display（）*を実行する前に、テクスチャ変数を作成する必要があります
- * init（）メソッドまたは glDisplay（）*メソッドの開始行で、gl.glEnable（GL2.GL_TEXTURE_2D）*メソッドを使用してテクスチャを有効にします。
- テクスチャとしてオブジェクトを作成します。パラメータとしてファイルオブジェクトが必要です。 次に、オブジェクトへのテクスチャとして使用される画像のパスが必要です。
File file = new File(“c:\\pictures\\boy.jpg”);
Texture t = textureIO.newTexture(file, true);
texture = t.getTextureObject(gl);- 「ファイルが見つかりません」という例外を処理する
以下は、キューブに画像を添付するプログラムです。
import java.awt.DisplayMode;
import java.io.File;
import java.io.IOException;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.opengl.util.texture.Texture;
import com.jogamp.opengl.util.texture.TextureIO;
public class CubeTexture implements GLEventListener {
public static DisplayMode dm, dm_old;
private GLU glu = new GLU();
private float xrot,yrot,zrot;
private int texture;
@Override
public void display(GLAutoDrawable drawable) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();//Reset The View
gl.glTranslatef(0f, 0f, -5.0f);
gl.glRotatef(xrot, 1.0f, 1.0f, 1.0f);
gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);
gl.glRotatef(zrot, 0.0f, 0.0f, 1.0f);
gl.glBindTexture(GL2.GL_TEXTURE_2D, texture);
gl.glBegin(GL2.GL_QUADS);
//Front Face
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, 1.0f);
//Back Face
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
//Top Face
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, -1.0f);
//Bottom Face
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 1.0f);
//Right face
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, -1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f( 1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f( 1.0f, -1.0f, 1.0f);
//Left Face
gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, 1.0f);
gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, -1.0f);
gl.glEnd();
gl.glFlush();
//change the speeds here
xrot += .1f;
yrot += .1f;
zrot += .1f;
}
@Override
public void dispose(GLAutoDrawable drawable) {
//method body
}
@Override
public void init(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glShadeModel(GL2.GL_SMOOTH);
gl.glClearColor(0f, 0f, 0f, 0f);
gl.glClearDepth(1.0f);
gl.glEnable(GL2.GL_DEPTH_TEST);
gl.glDepthFunc(GL2.GL_LEQUAL);
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST);
//
gl.glEnable(GL2.GL_TEXTURE_2D);
try{
File im = new File("E:\\office\\boy.jpg ");
Texture t = TextureIO.newTexture(im, true);
texture= t.getTextureObject(gl);
}catch(IOException e){
e.printStackTrace();
}
}
@Override
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
//TODO Auto-generated method stub
final GL2 gl = drawable.getGL().getGL2();
if(height lt;= 0)
height = 1;
final float h = (float) width/(float) height;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(45.0f, h, 1.0, 20.0);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
}
public static void main(String[] args) {
//TODO Auto-generated method stub
final GLProfile profile = GLProfile.get(GLProfile.GL2);
GLCapabilities capabilities = new GLCapabilities(profile);
//The canvas
final GLCanvas glcanvas = new GLCanvas(capabilities);
CubeTexture r = new CubeTexture();
glcanvas.addGLEventListener(r);
glcanvas.setSize(400, 400);
final JFrame frame = new JFrame (" Textured Cube");
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
final FPSAnimator animator = new FPSAnimator(glcanvas, 300, true);
animator.start();
}
}上記のプログラムをコンパイルして実行すると、次の出力が生成されます。 目的のテクスチャが適用された3Dキューブを見ることができます。
JOGL-付録
*GPU* -グラフィカル処理ユニット。画像のレンダリングを高速化する特別な電子デバイスです。*JNI* -Javaネイティブインターフェイス。 これを使用して、Javaはネイティブメソッドにアクセスします。モデル-これらは、ポイント、ライン、ポリゴンなどの基本的なグラフィックプリミティブから構築されたオブジェクトです。
ピクセル-画面に表示されるディスプレイの最小単位。
投影-オブジェクトの座標を2次元平面にマッピングする方法は、投影と呼ばれます。
投影行列-2Dサーフェス上のオブジェクトの線形変換です。
レンダリング-コンピューターがモデルから画像を作成するプロセス。
ビューポート-ビューポートは、コンピュータグラフィックスの画面上の表示領域です。
