Jogl-quick-guide

提供：Dev Guides
移動先:案内、検索

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）]をクリックします。

Jogampホームページ

これにより、Webサイトで管理されているすべてのAPIの.jarファイルのリストが表示されます。

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

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_フォルダーにコピーします。

Eclipse1

  • ステップ5 *-これらのファイルを選択し、マウスボタンを右クリックします。 *ビルドパス>ビルドパスに追加*を含むショートカットメニューが表示されます。

Eclipse2

  • ステップ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 *-メインメニューで、*ツール>ライブラリ*を選択します。

NetBeans1

ステップ2 *- *Ant Library Manager に移動します。

NetBeans2

  • ステップ3 *-*クラスパス*タブで、左下隅にある*新規ライブラリ*ボタンをクリックします。 小さなダイアログボックスが開きます。

ステップ4 *-ライブラリ名を JoGl2.0。*として入力します

  • ステップ5 *-[OK]ボタンをクリックします。

NetBeans3

  • ステップ6 *-「JAR/フォルダを追加…」ボタンをクリックします。

ステップ7 *-.jarファイル *jogl.all.jar および gluegen-rt.jar が配置されているパスを選択します。

JOGLライブラリを各プロジェクトに含めるには、以下の手順に従ってください-

  • ステップ1 *-*プロジェクト名*を右クリックします。 ショートカットメニューが表示されます。

NetBeans4

ステップ2 *-*プロパティを選択します。 *プロジェクトプロパティ*という名前のウィンドウが開きます。

NetBeans7

  • ステップ3 *-左側の[カテゴリ]から[ライブラリ]を選択します。
  • ステップ4 *-*コンパイルタブ*を選択し、「ライブラリを追加…​」ボタンをクリックします。 [ライブラリの追加]ダイアログボックスが表示されます。
  • ステップ5 *-さきほど作成したJOGL2.0ライブラリを追加します。

各プロジェクトにネイティブライブラリを含める

指定された手順に従って、各プロジェクトにネイティブライブラリを含めます-

  • ステップ1 *-プロジェクトを右クリックします。

ステップ2 *-[設定の設定]> [カスタマイズ…]を選択します

NetBeans8

[プロジェクトプロパティ]ウィンドウに移動します。

NetBeans9

ステップ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クラスのクラス階層を表す図です。

GJPanel

以下は、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関数にアクセスします。

JNI 

*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;

上記のコードをコンパイルして実行すると、次の出力が生成されます-

LineStrip

ラインループを描画する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（）*メソッドを上記のコードで置き換え、コンパイルして実行すると、次の出力が生成されます-

Quads

ポリゴンを描画する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

上記のプログラムをコンパイルして実行すると、次の出力が生成されます-

3Dライン

上記のビューを生成する* 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

上記のプログラムをコンパイルして実行すると、次の出力が生成されます-

3D Edge

同様に、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ラインを使用して描画された菱形を示しています。

菱形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三角形のスナップショットがあります。 このプログラムには深度テストが含まれていないため、三角形は中空に生成されます。

トライアングル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サーフェス上のオブジェクトの線形変換です。

レンダリング-コンピューターがモデルから画像を作成するプロセス。

ビューポート-ビューポートは、コンピュータグラフィックスの画面上の表示領域です。

「https://www.finddevguides.com/index.php?title=Jogl-quick-guide&oldid=79050」から取得
Powered by MediaWiki