TutorialsPoint JOGL 教程

来源：易百教程

JOGL教程

本章介绍了OpenGL，Java OpenGL绑定（GL4java，LWJGL，JOGL）和JOGL比其他的OpenGL的优点。

Java支持OpenGL（JOGL）是近期在Java OpenGL图形API结合。它是一个包装库，它可以访问OpenGL API，并且它被设计来创建Java编码的2D和3D图形应用程序。 JOGL是前麻省理工学院的研究生肯·拉塞尔和克里斯·克莱恩最初开发的一个开源库。后来发布到Sun Microsystems，现在它是Java图形和音频处理（JOGAMP）。用于各种操作系统，如Windows，Solaris和Mac OS X和Linux（基于x86）JOGL功能。

OpenGL是什么?

OpenGL代表开放图形库，用来创建2D和3D图形的集合。在OpenGL中，可以创建一个使用非常基本的图元，如点，线，多边形，位图和图像复杂的三维形状。

下面是OpenGL的几个特点：

• 它可以在多个平台上工作。
• 它有几种语言，如C ++，Python绑定等。
• 它可以呈现2D和3D矢量图形。
• 它与图形处理单元（GPU）实现快速，高品质的渲染。 （渲染是指创建从一个二维或三维模型的图像的过程。）
• 它是用于编写3D图形应用程序的行业标准API。例如，屏幕保护程序等。
• 它包含约150个命令，程序员可以使用指定的对象和操作来开发应用程序。
• 它包含了OpenGL实用库（GLU），提供各种建模功能，如二次曲面和NURBS曲线。 GLU是OpenGL的一个标准组件。
• OpenGL的设计重点是效率，效益和实现使用多语言在多个平台。保持一个OpenGL API的简单框架，不包括窗口的任务。因此，OpenGL依赖于其他编程语言对加窗的任务。

Java绑定OpenGL API

它是一个Java规范请求（JSR）的API规范，它允许使用OpenGL在Java平台上。

在Java中有各种OpenGL的绑定。他们是：

GL4java

这是被称为OpenGL的Java技术。它链接OpenGL1.3和几乎所有的供应商扩展。此外，它可以用于抽象窗口工具包（AWT）和摆动。它是一个聚焦OpenGL结合，这是一个显示全屏幕应用程序的单个窗口。

LWJGL

• 轻量级的Java库（LWJGL），使用OpenGL1.5，并结合Java最新版本。
• 它可以使用JSE1.4的全屏功能。但它对于AWT/Swings的支持有限。
• 它适用于重量轻的设备，如移动电话，嵌入式设备等。

JOGL

• JOGL只专注于2D和3D渲染。处理声音和输入输出的接口不包括在JOGL。
• 它包括图形工具库（GLU），GL实用工具包（GLUT），和自身API-native窗口工具包（NEWT）。

为什么要用JOGL?

• 它提供了完全访问的OpenGL API（版本1.0，4.3，ES1，ES2 ES3），以及几乎所有的供应商扩展。因此，在OpenGL中的所有功能都包含在JOGL。
• JOGL集成了AWT，Swing和标准窗口小部件工具箱（SWT）。它也包括它自己的本机窗口工具包（NEWT）。因此，它提供窗口的完整支持。

JOGL历史

• 1992 - Silicon Graphics公司发布了第一个OpenGL的规范。
• 2003 - Java.net网站推出的新功能和JOGL发表首次在同一网站上。
• 2010 – 自2010年以来，它一直在BSD许可证下独立的开源项目，它是计算机软件一个自由的许可证。

JOGL安装 - JOGL教程

本章介绍了设置环境以使用JOGL使用不同的集成开发环境(IDE)，在您的系统上。

安装JOGL

对于JOGL安装，需要有以下系统要求：

系统要求

第一个要求是要在机器上安装Java Development Kit（JDK）。

需要按照设置给定的步骤，从配置环境入手JOGL应用程序开发：

第1步 - 在机器上验证Java安装

系统的开放式控制台，并执行下面的Java命令：

验证在各操作系统的输出。

第2步 - 安装Java开发工具包（JDK）

如果Java未在你的机器上安装，则需要从Oracle网站上下载安装Java SDK： www.oracle.com/technetwork/java/javase/downloads/. 您可以从下载的文件安装JDK说明。需要按照安装和配置设置的指示。最后，设置PATH和JAVA_HOME环境变量指向包含的java.exe和javac.exe文件的目录，它们分别为：java_install_dir/bin和java_install_dir。

设置Java-home环境变量指向的基本目录的位置相同的路径，安装在机器上的Java程序。

附加的Java编译器位置，系统路径如下：

第3步 - 下载JOGL

• 可以从网站上下载JOGL的最新版本 www.jogamp.org
• 前往主页 www.jogamp.org
• 点击 Builds/Downloads > Current (zip).

可以看到网站所维护的所有.jar文件的API列表。

• 下载库.jar文件jogamp-all-platforms.7z，JAVA文档OpenGL库glugen-javadoc.7z和JOGL JOGL-javadocs.7z。
• 提取使用任何压缩解压软件下载的.jar文件。
• 当打开解压文件夹，会发现jar 文件夹，源代码和其他文件。

• 获取源代码gluegen-java-src.zip和jogl-java-src.zip支持IDE。这是可选的。
• 文件夹中的jar，有多个.jar文件。文件的集合属于Glugen和JOGL。
• JOAMP提供支持多种操作系统，如Windows，Solraris，Linux和Android原生库。因此，需要采取适当的jar文件，这些文件可以在需要的平台上执行。例如，如果使用的是Windows64位操作系统，那么可以通过jarfolder以下.jar文件：
• gluegenrt.jar
• jogl-all.jar
• gluegen-rt-natives-windows-amd64.jar
• jogl-all-natives-windowsamd64.jar

Eclipse4.4设置JOGL

按照给定的程序设置JOGL：

添加以下类库

1. 打开eclipse.
2. 创建一个新工程
3. 创建一个名为lib目录在项目文件夹中的新文件夹。
4. 复制文件 gluegen-rt-natives-windows-amd64.jar, gluegen-rt.jar, jogl-all-natives-windowsamd64.jar 和 jogl-all.jar 到 lib 目录。
5. 现在选择这些文件，然后右键单击鼠标按钮。将显示一个快捷菜单，其中包含 Build Path > Add to Build Path.
6. 为了可以在其他项目中可以使用所有的.jar文件，进入主菜单。选择 Window > Preferences. 出现在首选项窗口。
7. 在首选项窗口，在下拉菜单上的左侧菜单中，按照 hierarchy- Java-> Build Path -> User 库.
8. 点击 “New…” 按钮.
9. 这将打开一个对话框。输入库名称 jogl2.1.
10. 添加 jar 文件 glugen-rt.jar 和 jogl-all.jar 使用按钮 “Add External JARs...”.
11. 这将创建一个名为新的用户库 jogl2.1.

以同样的方式，我们可以为添加.jar文件添加的java文件和源代码。

添加本地库

1. 展开jogl-all.jar 的节点上，选择Javadoc位置（无）。
2. 点击 “New…” 钮，输入JOGL Java文件的名称。
3. 请点击 “Add External JARs…” 按钮。
4. 这将打开你需要选择JOGL Java文档，我们已经先前下载的位置的对话框。

添加源代码

1. 选择节点本地库的位置：(None).
2. 点击 “New…” 按钮.
3. 本地库和点击输入姓名 “OK” 按钮.
4. 点击 “Add External JARs…” 按钮.
5. 现在选择的路径，其中原生库文件 ('gluegen-rt-natives-windows-amd64.jar and joglall-natives-windows-amd64.jar') 位置.
6. 重复同样的程序源代码。
7. 上文两个本地库文件，我们可以设置为Javadoc，源代码和jar文件的位置以相同的方式在 glegen-rt.jar 和 glugen-natives-windows-amd64.jar.

Netbeans4.4设置JOGL

让我们通过以下步骤来设置JOGL针对NetBeans4.4：

添加库

1. 在主菜单中，选择Tools > Libraries.
2. 这使得 Ant Library Manager.
3. 在Classpath选项卡，单击位于左下角新建库按钮。它会打开一个小对话框。
4. 输入库名称 JoGl2.0.
5. 点击 “OK” 按钮.
6. 点击 “Add JAR/Folder…” 按钮.
7. 选择在.jar文件jogl.all.jar和gluegen-rt.jar所在的路径。

包括JOGL库到每一个项目，请执行以下步骤：

1. 在项目名称上单击右键。它显示一个快捷菜单。
2. 选择属性。它打开了一个名为Project Properties窗口。
3. 从左侧的类别中选择库
4. 选择编译选项卡，并单击“添加库...”按钮。添加库对话框出现。
5. 现在添加JOGL2.0库，先前创建的。

包括每个项目的本地库

按照给定的步骤，包括在每个项目中机库：

这使得项目属性窗口。

1. 用鼠标右键单击该项目。
2. 选择 Set Configuration > Customize…
3. 在右手边，在VM选项，点击“Customize”按钮。
4. 浏览包含JOGL本地库的路径 gluegen-rt-natives-windows-amd64.jar'' 和 'jogl-all-natives-windows-amd64.jar.

添加本地库Java文档

需要再次打开Ant库管理，使源代码和Javadoc可用于每个项目。按照给定的步骤：

添加本地库的源代码

1. 打开main menu.
2. 选择 Tools > Libraries. 这使 Library manager.
3. 在JavaDoc 下面选项卡中，单击 “New Library…” 按钮.
4. 输入 JOGLJavadoc 名称. (可以输入任何所需的名称)
5. 点击 “Add jars/libraries…” 按钮.
6. 其中，选择解压后的文件JOGL代码所在的路径。
7. 在Sources 下面的选项卡中，单击 “New Library…” 按钮。进入JOGLsources 名称.
8. 点击 “Add jars/libraries…” 按钮，选择解压缩源代码所在的路径。

自定义JDK编辑

1. 设置类路径的文件jogl.all.jar和gluegen-rt.jar。
2. 设置路径，本地库gluegen-rt-natives-windows-amd64.jar 和 jogl-all-natives-windowsamd64.jar复制并将其粘贴到JSE lib下载文件夹中的所有jar文件。

JOGL基本模板 - JOGL教程

本章介绍了编写JOGL基本模板的概念。

重要的接口和类

为了使程序能够使用JOGL图形API，需要实现GLEventListener接口。

GLEventListener接口

可以在javax.media.opengl包找到GLEventListener接口。

Interface: GLEventListener

Package: javax.media.opengl

下表给出了各种方法和GLEventListener接口的详细描述：

GLEventListener所有的方法都需要GLAutoDrawable接口作为参数的对象。

GLAutoDrawable 接口

这个接口提供一个基于事件机制（GLEventListener），用于执行OpenGL渲染。 GLAutoDrawable自动创建一个与GLAutoDrawable为对象的生命周期相关联的一个主要呈现上下文。

Interface: GLAutoDrawble

Package: javax.media.opengl

注：有在这个包的其他方法。只有很少的关于模板的重要方法是在此界面中进行讨论。

GLCanvas 类

GLCanvas 和 GLJpanel 是JOGL GUI两大类实现 GLAutoDrawable 接口，这让他们可以用作拉丝表面的OpenGL命令。

GLCanvas是一个重量级AWT组件，它提供了OpenGL的渲染支持。这是一AWTAutoGLDrawable接口的主执行。它还是java.awt.Canvas继承类。因为它是一个重量级的组成部分，在某些情况下，GLJCanvas可能无法与Swing组件正确地结合起来。因此，必须谨慎使用，同时它与Swing共用。每当面临GLJCanvas问题，那么必须使用GLJPanel类。

GLCanvas类的分层图可以如下所示：

• GLEventistener接口工作以及GLCanvas类，它响应变化GLCanvas类并由它们制成要求的图纸。
• 每当GLCanvas的类被实例化，调用GLEventListener的init()方法。可以覆盖此方法来初始化OpenGL的状态。
• 每当GLCanvas的初始绘制（实例化），或调整大小，则执行GLEventListener的reshape()方法。它用来初始化OpenGL的视口和投影矩阵。它也被调用被改变来组件的位置。
• GLEventListener()方法显示包含渲染3D场景的代码。它被调用时调用GLCanvas的display()方法。

class: GLCanvas

package: javax.media.opengl.awt

Contructor

**GLCanvas()**

它与OpenGL功能的默认设置创建一个新的GLCanvas组成部分，使用默认的OpenGL功能选择机制，在默认的屏幕设备上。

**GLCanvas(GLCapabilitiesImmutable)**

它创建了一个新的GLCanvas成分与所请求的一套OpenGL的功能，使用默认的OpenGL功能选择机制，在默认的屏幕设备上。

要实例化GLCanvas类，需要GLCapabilitiesImmutable接口，它指定一个不可变的集合的OpenGL性能的目的。

来获得 CapabilitiesImmutable 接口的对象的一个方式是实例 GLCapabilities 类，它实现接口。 GLCapabilities 类的实例可以用来服务。

GLCapabilities 类

此类指定一组的OpenGL性能。它需要GLCapabilities对象作为参数。该GLCapabilities类描述渲染上下文必须支持所期望的功能，例如OpenGL的轮廓。

class: GLCapabilities

package: javax.media.opengl

Constructor

**GLCapabilities(GLProfile glprofile)**

创建一个GLCapabilities对象。

要实例化GLCanvas类，需要GLCapabilitiesImmutable接口，它指定一个不可变的集合的OpenGL性能的目的。

获得CapabilitiesImmutable接口的对象的一种方式是实例化GLCapabilities类并实现接口。 GLCapabilities类的实例，可以用来以服务为目的。

GLCapabilities 类

此类指定一组OpenGL性能。它需要GLCapabilities对象作为参数。GLCapabilities类描述渲染上下文必须支持所期望的功能，例如OpenGL的轮廓。

class: GLCapabilities

package: javax.media.opengl

Constructor

**GLCapabilities(GLProfile glprofile)**

GLCapabilities类又需要GLProfile对象。

GLProfile 类

由于几个版本的OpenGL API发布，需要指定OpenGL的API确切版本被用在你的程序到Java虚拟机（JVM）。这是通过使用GLProfile类。这个类的get()方法接受不同的预定义的String对象作为参数。每一个String对象是一个接口的名称，每个接口支持OpenGL的某些版本。如果初始化这个类的静态和单例，这个类提供了每个可用JOGL单例GLProfile对象。

class: GLProfile

package: javax.media.opengl

因为这是一个静态方法，需要使用类名来调用它，它需要一个预定义的静态字符串变量作为参数。有在这12级这样的变量，分别代表GL接口的独立实现。

GLProfile.get(GLProfile.GL2);

下表显示GLProfile类的get()方法的字符串参数：

现在一切都被设置在使用JOGL的第一个程序中。

使用画布与AWT的基本模板

使用JOGL的编程，可以绘制各种图形形状，例如直线，三角形，三维形状，包括特殊效果，如旋转，照明，色彩等。

JOGL编程的基本模板如下：

步骤1：创建一个类

最初创建一个实现 GlEventListener 接口的类，并导入包 javax.media.opengl。实现所有四种方法 display(), dispose(), reshape(), init()。由于这是基本框架，基本任务，如创建Canvas类，将其添加到框架进行了讨论。所有GLEVentListener接口的方法留下未实现。

第二步：准备画布

(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

生成GLProfile对象

因为这是静态方法，它是使用类名调用。由于本教程是关于JOGL2，产生GL2接口对象。

final GLProfile profile = GLProfile.get( GLProfile.GL2 );
// both, variable and method are static hence both are called using class name.

让我们看到了代码片段画布

//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);

现在，使用方法addGLEventListener()添加GLEventListener到画布。此方法需要GLEventListener接口参数的对象。因此，通过实现GLEventListener类的对象。

BasicFrame basicframe=newBasic Frame( );// class which implements
GLEventListener interface
glcanvas.addGLEventListener( basicframe );

使用setSize()方法继承自javax.media.opengl.awt.AWTGLAutoDrawable GLCanvas框架设置大小。

glcanvas.setSize( 400, 400 );

现在，还可以用GLCanvas。

第三步：创建框架

通过实例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 JFrame frame = new JFrame (" Basic Frame");
//adding canvas to frame
frame.getContentPane().add(glcanvas);
frame.setSize(frame.getContentPane().getPreferredSize());
frame.setVisible(true);
}
}

如果编译并执行上述程序，将生成以下输出。它显示了当我们用GLCanvas类与AWT形成一个基本的框架：

使用画布与Swing

使用Canvas与AWT提供了一个图形化的框架与重量级的功能。对于具有轻量级的图形框架，同时采用GLCanvas与Swing，可以将GLCanvas会在窗口JFrame直接使用，也可以将其添加到JPanel中。

下面的程序将生成使用GLCanvas与Swing窗口的基本框架：

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

如果编译并执行上述程序，将生成以下输出。它显示了当我们用GLCanvas与Swing窗口形成一个基本的框架。

GLJPanel 类

它是一个轻量级的Swing组件，它提供了OpenGL的渲染支持。它提供了与Swing的兼容性。

GLJPanel类层次结构

class: GLJPanel

package: javax.media.opengl.awt

Contructors

GJPanel()

创建一个用 OpenGL 功能的默认设置一个新的GLJPanel组成部分。

(GLCapabilitiesImmutable)

创建一个具有指定一组OpenGL性能的新 GLJPanel 组件。

GLJPanel(GLCapabilitiesImmutable userCapsRequest,
GLCapabilitiesChooser chooser)

创建一个新的GLJPanel组件。

使用GLJPanel与Swing窗口

让我们来看看生成使用GLJPanel与Swing窗口基本框架方案：

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

如果编译并执行上述程序，将生成以下输出。这表明，当我们使用GLJPanel swing窗口形成一个基本框架：

JOGL图形形状 - JOGL教程

本教程介绍了绘制直线，用直线的各种形状。 OpenGL的API提供了原始的方法，用这些方法，可以开发形状，如三角形，多边形和圆形绘制基本图形元素如点，顶点，线等。或者二维和三维。

图形对象

要访问程序特定于硬件和操作系统平台，以及其他语言编写，比如C和C++(原生应用)库，Java使用一种称为Java本地接口(JNI)编程框架的工作。 JOGL内部使用此接口，如图中下面的图表来访问OpenGL函数。

GLEventListener接口的所有四种方法让代码(Java JOGL方法)，它内部调用OpenGL函数，这些JOGL方法的命名也类似于 OpenGL 命名约定。如果在OpenGL中的函数名是在glBegin()，它被用作gl.glBegin()。

只要gl.glBegin()的Java JOGL的方法被调用时，它在内部调用OpenGL的glBegin()方法。这是在安装JOGL的时间对用户的系统上安装本地库文件的原因。

Display() 方法

这是其中包含用于开发图形的代码的一个重要方法。这就要求GLAutoDrawable接口对象作为参数。

Display()方法中，首先得到使用GL接口的对象的OpenGL上下文（GL继承GLBase接口，该接口包含的方法来生成所有的OpenGL上下文对象）。由于本教程是关于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接口的对象，就可以访问GL2接口的成员，而这又提供了访问 OpenGL[1.0 ...3.0]功能。

绘制一条线

GL2接口包含的方法和列表，但这里的三个主要方法的重要论述，即函数是glBegin()glVertex()和glEnd()。

让我们通过程序来绘制一条直线：

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
}
@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);
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;

使用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 );
}//end of main
}//end of class

如果编译并执行以上程序，会得到下面的输出。它示出了使用在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()方法生成一所房子的图。

使用glBegin()更多的参数绘画出更多的形状

除了GL_LINES预定义的字符串参数，glBegin()方法接受八个参数。可以用它来绘制不同的形状。这些用于相同GL_LINES。

下表显示了glBegin()方法的参数和描述：

让我们来看看使用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()方法，编译并执行它，下面的输出生成：

代码片段display()方法使用GL_TRIANGLES画三角形

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()方法来绘制三角形：

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()方法来绘制四边形：

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()方法来绘制多边形：

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转化对象 - JOGL教程

OpenGL提供了更多的功能，比如色彩应用到一个对象，比例，灯光，旋转的物体等。本章介绍了一些变换使用JOGL的对象。

移动对象的窗口

在前面的章节中，我们讨论的方案画线，用简单的线条绘制各种形状。以这种方式创建的形状可被显示在该窗口内的任何位置。它是通过使用glTranslatef (float x, float y, float z) 方法完成。

这种方法属于GLMatrixFunc接口，它在javax.media.opengl.fixedfunc包。

GLMatrixFunc 接口

interface: GLMatrixFunc

package: javax.media.opengl.fixedfunc

让我们来看看这个接口的一些重要方法：

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){
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();
}

运用颜色的对象

要应用颜色的物体，使用GL2类的glColor()方法。

语法

gl.glColorXY(1f,0f,0f);

例子

如果通过颜色值（1，0，0），那么得到的红色和（1，1，0）的值给定为黄色。

• x表示使用的颜色数， 3 (red, blue, green) or 4(red, blue, green, alpha)。为了得到不同的颜色组合，这些颜色值作为参数传递。颜色参数的序列必须是维护的顺序。
• 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 blue
gl.glColor3f(0f,0f,1f); //gives us green

如果三角形，可以为每个顶点应用不同的颜色。

让我们通过程序的颜色应用到一个三角形：

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 ); //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 );
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

当编译并执行上述程序，将生成以下输出：

缩放

缩放对象是通过使用GLMatrixFunc接口的void glScalef(float x, float y, float z) 方法进行。该方法接受三个浮点参数，使用我们指定轴沿x，y和z比例因子。

例如，在下面的程序中，一个三角形是减弱至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生产的原三角形：

旋转

对象旋转可以沿任意3轴来完成，使用GLMatrixFunc接口的void glRotatef(float angle, float x, float y, float z) 方法。需要传递的旋转以及x，y，z轴的角度作为参数传递给该方法。

下面的步骤指导成功地旋转对象：

• 清除颜色缓存和深度缓存最初使用gl.glClear（GL2.GL_COLOR_BUFFER_BIT| GL2.GL_DEPTH_BUFFER_BIT）方法。此方法擦除对象的先前状态，使视图清晰。
• 复位用glLoadIdentity()方法的投影矩阵。

实例化的动画类和使用start()方法启动动画。

FPSAnimator 类

Class:

FPSAnimator

Package: javax.media.opengl.util

构造方法

FPSAnimator(GLAutoDrawable drawable, int fps)

创建给定的目标帧每秒的值和初始绘制的动画一个FPSAnimator。

FPSAnimator(GLAutoDrawable drawable, int fps, boolean cheduleAtFixedRate)

创建一个具有给定的目标帧每秒的值，初始绘制动画，和一个标志，指示是否使用固定利率调度FPSAnimator。

FPSAnimator(int fps)

创建由给定的目标帧每秒值的FPSAnimator。

FPSAnimator(int fps, boolean scheduleAtFixedRate)

创建由给定的目标帧每秒的值和一个标志，指示是否使用固定速率的调度FPSAnimator。

start() 和stop()在这个类中的两个重要的方法。

让我们通过程序来旋转一个三角形：

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
gl.glRotatef( rtri, 0.0f, 1.0f, 0.0f );//triangle rotation
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();
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 ) {
// 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 );
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轴旋转彩色三角形的各个快照。

灯光

要设置灯光，使用过glEnable()方法初步启用的照明。然后应用照明的对象，使用GLLightingFunc接口的 glLightfv(int light, int pname, float[] params, int params_offset) 方法。这个方法有四个参数。

下表描述了gllightfv()方法的参数。

光源参数：

照明被启用并使用过glEnable()方法和glDisable()函数以及参数GL_LIGHTING禁用。

下面的模板，给出了灯光：

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 }; //multi-color 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 );
float[] ambientLight = 0.1f, 0.f, 0.f,0f }; // weak RED ambient
gl.glLightfv( GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient-Light, 0 );
float[] diffuseLight = { 1f,2f,1f,0f }; //multi color diffuse
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图形 - JOGL教程

在本章中，让我们来学习如何处理3D图形。

绘制3D线

让我们绘制与z轴成简单的线，看到2D和3D线之间的差值。先画一条简单的直线，再画第二条线3个单元到窗口中。

让我们通过程序来绘制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优势：

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) {
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边缘到对应的任何二维四边形的侧面和连接相邻顶点，就可以得到一个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 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 <=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形状。

让我们通过程序绘制一个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 ) {
final GL2 gl = drawable.getGL().getGL2();
if(height <=;)
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 );
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_DEPTH_BUFFER_BIT GL_COLOR_BUFFERBIT）的颜色被清除。要启用深度测试中的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 dimentions
//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 ) {
//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 );
}
@Override
public void reshape( GLAutoDrawable drawable, int x, int y, int width, int height ) {
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三角形的快照。由于该计划包括用于深度测试代码，三角形生成固体。

绘制一个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 );
gl.glRotatef( rquad, 1.0f, 1.0f, 1.0f ); // Rotate The Cube On X, Y & Z
//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 ) {
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 ) {
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立方体。

应用质感的立方体

给出下面的步骤来应用质感的立方体：

File file=new File(“c:\\pictures\\boy.jpg”);
Texture t=textureIO.newTexture(file, true);
texture=t.getTextureObject(gl);

• 可以要求纹理结合使用gl.glBindTexture（GL2.GL_TEXTURE_2D。纹理）绘制对象的接口方法的立方体。
• 这种方法需要的纹理（INT）参数以及GL2.GL_TEXTURE_2D（INT）
• 执行display()创建需要纹理变量。
• 在init()方法或在glDisplay()方法中的起始行，使用gl.glEnable（GL2.GL_TEXTURE_2D）方法的纹理。
• 创建纹理对象，它需要一个文件对象作为参数，而这又需要用作纹理的对象的图像的路径。
• 处理未发现异常文件。

让我们通过程序应用纹理到多维数据集：

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) {
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) {
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) {
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立方体与应用上所需的纹理。

附录

GPU - 图形处理单元，它是促进图像的呈现一个特殊的电子设备。

JNI - Java本地接口。使用它，Java可以访问本地方法。

模型 - 它们是从基本的图形元素，如点，线和多边形构造的对象。

像素 - 显示在屏幕上看到的最小单位。

投影 - 映射对象的坐标的二维平面的方法，被称为凸起。

投影矩阵 - 它是二维表面上的物体的线性变换。

渲染 - 由计算机从模型生成的图像的过程。

视口 - 视区是计算机图形学的屏幕上观看区域。