目录

JOGL - 快速指南

JOGL - Overview

本章介绍OpenGL,它的功能,java中的OpenGL绑定(GL4java,LWJGL,JOGL),以及JOGL优于其他OpenGL绑定的优点。

O pen GL (JOGL)的J ava绑定是Java中最近对OpenGL图形API的绑定。 它是一个包装库,可以访问OpenGL API,它旨在创建用Java编码的2D和3D图形应用程序。 JOGL是一个开源库,最初由前麻省理工学院的研究生Ken Russell和Chris Kline开发。 后来,它被Sun Microsystems的游戏小组采用,现在由Java在图形音频和处理(JOGAMP)上维护。 JOGL可在各种操作系统上运行,如Windows,Solaris,Mac OS X和Linux(在x86上)。

什么是OpenGL?

OpenGL代表Open Graphics Library,它是创建2D和3D图形的命令集合。 使用OpenGL,您可以使用非常基本的基元(如点,线,多边形,位图和图像)创建复杂的3D形状。

以下是OpenGL的一些功能 -

  • 它可以在多个平台上运行。

  • 它具有多种语言的绑定,如C ++,Python等

  • 它可以渲染2D和3D矢量图形。

  • 它与图形处理单元(GPU)交互,以实现快速和高质量的渲染。 渲染是从2D或3D模型创建图像的过程。

  • 它是用于编写3D图形应用程序的行业标准API。 例如,游戏,屏保等。

  • 它包含大约150个命令,程序员可以使用这些命令指定开发应用程序的对象和操作。

  • 它包含OpenGL实用程序库(GLU),它提供各种建模功能,例如二次曲面和NURBS曲线。 GLU是OpenGL的标准组件。

  • OpenGL的设计侧重于使用多种语言在多个平台上的效率,有效性及其实现。 为了保持OpenGL API的简单性,不包括窗口化任务。

因此,OpenGL依赖于其他编程语言来进行窗口化任务。

用于OpenGL API的Java绑定

它是Java规范请求(JSR)API规范,允许在Java平台上使用OpenGL。

产品规格 细节
JSR 231 此Java绑定包支持Java SE平台。
JSR 239 此Java绑定包支持Java ME平台。

Java中有各种OpenGL绑定。 它们将在下面讨论

GL4java

它被称为OpenGL for Java技术。 它包含指向OpenGL 1.3和几乎所有供应商扩展的链接。 此外,它可以与Abstract Window Toolkit(AWT)和Swings一起使用。 这是一个以游戏为中心的OpenGL绑定,它是一个显示全屏应用程序的单一窗口。

LWJGL

  • 轻量级Java游戏库(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网站推出了新功能,JOGL首次在同一网站上发布。

  • 2010年 - 自2010年以来,它一直是BSD许可下的独立开源项目,这是一个自由的计算机软件许可证。

JOGL - Installation

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

安装JOGL

对于JOGL安装,您需要具备以下系统要求 -

系统需求 (System Requirements)

第一个要求是在您的计算机上安装Java Development Kit(JDK)。

需求 描述
JDK版本 1.4或以上
Memory 没有最低要求
磁盘空间 没有最低要求
操作系统 没有最低要求

您需要按照给定的步骤设置环境以开始JOGL应用程序开发 -

步骤1 - 验证计算机上的Java安装

打开系统控制台并执行以下java命令 -

平台 任务 命令
Windows 打开命令控制台 C:\>java-version
Linux 打开命令终端 $ java -version
MAC 开放式终端 机器:~joseph $ java -version

验证相应操作系统上的输出。

平台 Output
Windows

Java “1.6.0.21”

java(TM)SE运行时环境(版本1..6.0_21-b07)Java HotSpot(TM)客户端VM(版本17.0-b7,混合模式,共享)

Linux

Java “1.6.0.21”

java(TM)SE运行时环境(版本1..6.0_21-b07)Java HotSpot(TM)客户端VM(版本17.0-b7,混合模式,共享)

MAC

Java “1.6.0.21”

java(TM)SE运行时环境(版本1..6.0_21-b07)Java HotSpot(TM)客户端VM(版本17.0-b7,混合模式,共享)

第2步 - 设置Java Development Kit(JDK)

如果您的计算机上未安装Java,则需要从Oracle网站安装Java SDK: Oracle 。 您可以从下载的文件中找到有关安装JDK的说明。 您需要按照给定的说明安装和配置设置。 最后,设置PATH和JAVA_HOME环境变量以引用包含java.exe和javac.exe文件的目录,通常分别是java_install_dir/bin和java_install_dir。

Java-home环境变量设置为指向同一路径上的基本目录位置,其中Java安装在您的计算机上。

平台 命令
Windows 将环境变量JAVA_HOME设置为C:\ProgramFiles\Java\Jdk1.6.0_21
Linux 导出JAVA_HOME =/usr/local/java-current
MAC 导出JAVA_HOME =/Library/Java/Home

将Java编译器位置附加到系统路径,如下所示 -

平台 命令
Windows 在系统变量和路径的末尾追加字符串;%JAVA_HOME%bin
Linux 导出PATH = $ PATH:$ JAVA_HOME/bin/
MAC 不需要

第3步 - 下载JOGL

Jogamp主页

这会将您带到网站维护的所有API的.jar文件列表。

JAR文件列表
  • 下载库.jar文件jogamp-all-platforms.7z ,用于OpenGL本机库glugen-javadoc.7z和JOGL jogl-javadocs.7z. java文档jogl-javadocs.7z.

  • 使用任何zip解压缩软件提取下载的.jar文件。

当您打开解压缩的文件夹时,您将找到jar文件夹,源代码和其他文件。

源代码文件夹

获取源代码gluegen-java-src.zipjogl-java-src.zip以支持IDE。 这是可选的。

  • 在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 -

添加库

Step 1 - 打开Eclipse。

Step 2 - 创建一个新项目。

Step 3 - 在项目文件夹中创建一个名为lib的新文件夹。

Step 4 - 将文件gluegen-rt-natives-windows-amd64.jar, gluegenrt.jar, jogl-all-natives-windowsamd64.jarjogl-all.jar复制到lib文件夹中。

Eclipse1

Step 5 - 现在选择这些文件并右键单击鼠标按钮。 将显示一个快捷菜单,其中包含“ Build Path 》 Add to Build Path.

Eclipse2

Step 6 - 要使所有.jar文件可用于其他项目,请转到主菜单。 选择窗口“首选项。 出现“首选项”窗口。

Eclipse3Eclipse4
  • 在首选项窗口中,在左侧的下拉菜单中,按照层次结构 - Java→构建路径→用户库。

  • 单击“新建...”按钮。

  • 它会打开一个对话框。 输入库名称为jogl2.1。

  • 使用按钮“添加外部JAR ...”添加jar文件glugen-rt.jarjogl-all.jar

  • 它创建了一个名为jogl2.1.的新用户库jogl2.1.

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

添加本机库

Step 1 - 展开jogl-all.jar节点,选择Javadoc location(none)。

Step 2 - 单击“新建...”按钮。 输入JOGL Java Document的名称。

Step 3 - 单击“添加外部JAR ...”按钮。

Step 4 - 它打开一个对话框,您需要在其中选择我们之前已经下载的JOGL Java文档的位置。

添加源代码

Step 1 - 选择节点本机库位置:(无)。

Step 2 - 单击“新建...”按钮。

Step 3 - 输入本机库的名称,然后单击“确定”按钮。

Step 4 - 单击“添加外部JAR ...”按钮。

Step 5 - 现在选择本机库文件('gluegen-rt-natives-windows-amd64.jar and joglall-natives-windows-amd64.jar')所在('gluegen-rt-natives-windows-amd64.jar and joglall-natives-windows-amd64.jar')

Step 6 - 对源代码重复相同的过程。

Step 7 - 我们可以像上面给出的本地库文件glegen-rt.jarglugen-natives-windows-amd64.jar.一样设置Javadoc,源代码和jar文件glugen-natives-windows-amd64.jar.

为NetBeans 4.4设置JOGL

让我们完成为NetBeans 4.4设置JOGL的步骤 -

添加库

Step 1 - 在主菜单中,选择“ Tools 》 Libraries

NetBeans1

Step 2 - 它将引导您进入Ant Library Manager

NetBeans2

Step 3 - 在Classpath选项卡下,单击左下角的New Library按钮。 它会打开一个小对话框。

Step 4 - 输入库名称为JoGl2.0.

Step 5 - 单击“确定”按钮。

NetBeans3

Step 6 - 单击“添加JAR /文件夹...”按钮。

Step 7 - 选择.jar文件jogl.all.jargluegen-rt.jar所在的路径。

要将JOGL库包含到每个项目中,请按照以下步骤操作 -

Step 1 - 右键单击project name 。 它显示了一个快捷菜单。

NetBeans4

Step 2 - 选择Properties. 它会打开一个名为Project properties的窗口。

NetBeans7

Step 3 - 从左侧的“类别”中选择“ Libraries

Step 4 - 选择Compile tab ,然后单击“Add Library ...”按钮。 出现添加库对话框。

Step 5 - 现在添加您之前创建的JOGL2.0库。

在每个项目中包含本机库

按照给定的步骤在每个项目中包含本机库 -

Step 1 - 右键单击​​该项目。

Step 2 - 选择Set Configuration 》 Customize…

NetBeans8

它会引导您进入“ Project Properties窗口。

NetBeans9

Step 3 - 在右侧,在VM options,单击“自定义”按钮。

Step 4 - 浏览包含JOGL本机库gluegen-rtnatives-windows-amd64.jar'''jogl-all-natives-windowsamd64.jar.

添加本机库的Java文档

您需要再次打开Ant库管理器以使源和Javadoc可用于每个项目。 按照给定的程序 -

Step 1 - 打开main menu

Step 2 - 选择Tools 》 Libraries 。 这将引导您进入Library manager

Step 3 - 在JavaDoc选项卡下,单击“New Library ...”按钮。

Step 4 - 输入JOGLJavadoc名称。 (您可以输入任何所需的名称。)

Step 5 - 单击“添加罐子/库...”按钮。

Step 6 - 选择解压缩的JOGL documentation代码所在的路径。

添加本机库的源代码

Step 1 - 在“ Sources选项卡下,单击“新建库...”按钮。 输入JOGLsources名称。

Step 2 - 点击“添加罐子/库......”按钮。 选择解压缩源代码所在的路径。

自定义JDK编辑器

Step 1 - 为文件jogl.all.jargluegen-rt.jar.设置Classpath gluegen-rt.jar.

Step 2 - 设置本机库gluegen-rt-natives-windows-amd64.jarjoglall-natives-windowsamd64.jar路径,或者从下载它们的文件夹中复制所有jar文件并将它们粘贴到jse lib文件夹中。

JOGL - API for Basic Template

使用JOGL编程,可以绘制各种图形形状,如直线,三角形,3D形状,包括旋转,光照,颜色等特殊效果。首先,要在JOGL中绘制对象,我们必须构建一个基本的JOGL框架。 下面给出了构造基本框架所需的类。

GLEventListener接口

要使程序能够使用JOGL图形API,您需要实现GLEventListener接口。 您可以在javax.media.opengl包中找到GLEventListener接口。

下表提供了GLEventListener接口的各种方法和描述的详细信息 -

Sr.No. 方法和描述
1

Void display(GLAutoDrawable drawable)

它由GLAutoDrawable接口的对象调用,以启动客户端的OpenGL呈现。 即,此方法包含用于使用OpenGL API绘制图形元素的逻辑。

2

Void dispose(GLAutoDrawable drawable)

此方法通知侦听器每个GLContext执行所有OpenGL资源的释放,例如内存缓冲区和GLSL程序。

3

Void init(GLAutoDrawble drawable)

初始化OpenGL上下文后,立即由GLAutoDrawable接口的对象调用它。

4

Void reshape(GLAutoDrawble drawble, int x, int y, int width, int height)

在调整组件大小后的第一次重绘期间,由GLAutoDrawable接口的对象调用它。 每当窗口上组件的位置发生变化时,也会调用它。

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

GLAutoDrawable接口

此接口提供基于事件的机制(GLEventListener)用于执行OpenGL呈现。 GLAutoDrawable自动创建一个主渲染上下文,该上下文在对象的生命周期内与GLAutoDrawable相关联。

下表提供了GLAutoDrawable接口的各种方法和说明的详细信息 -

Sr.No 方法和描述
1

GL getGL()

返回GLAutoDrawable接口的当前对象使用的GL管道对象。

2

void addGLEventListener(GLEventListener Listener)

将给定的侦听器添加到当前可绘制队列的末尾。

3

void addGLEventListener(int index, GLEventListener listener)

在此drawable队列的给定索引处添加给定侦听器。

4

void destroy()

Destroys与GLAutoDrawable接口的此对象关联的所有资源,包括GLContext。

Note - 此包中还有其他方法。 在该界面中仅讨论了与模板有关的一些重要方法。

GLCanvas类

GLCanvasGLJpanel是实现GLAutoDrawable接口的两个主要类JOGL GUI, GLAutoDrawable OpenGL命令的绘图表面。

GLCanvas是一个重量级的AWT组件,提供OpenGL渲染支持。 这是AWTAutoGLDrawable接口的主要实现。 它还继承了java.awt.Canvas类。 由于它是一个重量级组件,在某些情况下, GLJCanvas可能无法正确地与swing组件集成。 因此,在使用Swing时必须小心。 每当您遇到GLJCanvas问题时,您必须使用GLJPanel类。

GLCanvas类的层次结构图如下所示 -

帆布
  • GLEventistener接口与GLCanvas类一起使用。 它响应GLCanvas类中的更改以及它们所做的绘图请求。

  • 每当实例化GLCanvas类时,都会调用GLEventListenerinit()方法。 您可以覆盖此方法以初始化OpenGL状态。

  • 无论何时绘制GLCanvas (实例化)或调整大小,都会执行GLEventListenerreshape()方法。 它用于初始化OpenGL视口和投影矩阵。 每当组件的位置发生变化时,也会调用它。

  • GLEventListener的display()方法包含渲染3D场景的代码。 只要调用GLCanvas display()方法,就会调用它。

下面给出了实例化GLCanvas类所需的构造函数。

Sr.No 构造函数和描述
1

GLCanvas()

它使用默认的OpenGL功能选择机制在默认屏幕设备上创建一个具有默认OpenGL功能的新GLCanvas组件。

2

GLCanvas(GLCapabilitiesImmutable)

它使用默认屏幕设备上的默认OpenGL功能选择机制,创建一个具有所请求的OpenGL功能集的新GLCanvas组件。

下面给出了用于GLCanvas类的事件处理的方法。

Sr. No. 方法和描述
1

void addGLEventListener(GLEventListener listener)

将给定的侦听器添加到此可绘制队列的末尾。

2

void addGLEventListener(int indexGLEventListener listener)

在此drawable队列的给定索引处添加给定侦听器。

要实例化GLCanvas类,需要GLCapabilitiesImmutable接口的对象, GLCapabilitiesImmutable接口指定一组不可变的OpenGL功能。

获取CapabilitiesImmutable接口的对象的方法之一是实例化GLCapabilities类,该类实现接口。 GLCapabilities类的实例可用于实现此目的。

GLCapabilities类

此类指定一组OpenGL功能。 它将GLCapabilities对象作为参数。 GLCapabilities类描述了渲染上下文必须支持的所需功能,例如OpenGL配置文件。

下面给出了一个实例化GLCapabilities类的构造函数

Sr. No. 方法和描述
1

GLCapabilities(GLProfile glprofile)

它创建了一个GLCapabilities对象。

要实例化GLCanvas类,您需要一个GLCapabilitiesImmutable接口的对象,该对象指定一组不可变的OpenGL功能。

获取CapabilitiesImmutable接口的对象的方法之一是实例化GLCapabilities类,该类实现接口。 GLCapabilities类的实例可用于实现此目的。

GLCapabilities类又需要一个GLProfile对象。

GLProfile类

由于发布了几个版本的OpenGL API; 您需要在Java虚拟机(JVM)中指定程序中使用的OpenGL API的确切版本。 这是使用GLProfile类完成的。

此类的get()方法接受不同的预定义String对象作为参数。 每个String对象都是一个接口的名称,每个接口都支持某些版本的OpenGL。 如果将此类初始化为static和singleton,它会为每个可用的JOGL概要文件提供单独的GLProfile对象。

下面给出的是GLProfile类的get方法的原型。

Sr.No. 方法和描述
1

Static GLProfile get(String profile)

使用默认设备。

由于这是一个静态方法,您需要使用类名调用它,并且它需要一个预定义的静态字符串变量作为参数。 这个类中有12个这样的变量,每个变量代表GL接口的单独实现。

GLProfile.get(GLProfile.GL2);

Parameters of get() method

Sr.No 预定义字符串值(接口名称)和描述
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] compatibility profilewell as most of its extensions defined at the time of this specification.

13

GL4ES3

包含核心GL4(OpenGL 4.0+)和GLES3(OpenGL ES 3.0)的公共子集的接口。

GLJPanel类

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

GLJPanel类层次结构

下面给出的图表代表了GLJPanel类的类层次结构。

GJPanel

下面给出了各种构造函数GLJPanel类。

Sr. No. 构造函数和描述
1

GJPanel()

它使用一组默认的OpenGL功能创建一个新的GLJPanel组件。

2

(GLCapabilitiesImmutable)

它使用所请求的OpenGL功能集创建一个新的GLJPanel组件。

3

GLJPanel(GLCapabilitiesImmutable userCapsRequest, GLCapabilitiesChooser chooser)

它创建了一个新的GLJPanel组件。

下面给出了GLJPanel类的方法。

Sr.No. 方法和描述
1

void addGLEventListener(GLEventListener listener)

此方法将给定侦听器添加到此可绘制队列的末尾。

2

void addGLEventListener(int indexGLEventListener listener)

此方法在给定的可绘制队列的索引处添加给定的侦听器。

JOGL - Canvas with AWT

本章介绍如何使用带有AWT帧的Canvas绘制JOGL基本帧。 在这里,我们将构造一个AWT框架,并使用框架类的add()方法将画布对象添加到AWT框架。

下面给出了编写程序的步骤,该程序使用JOGL的Canvas类和AWT的Frame类组合创建JOGL基本框架。

第1步:创建类

最初创建一个实现GlEventListener接口的类并导入包javax.media.opengl。 实现所有四个方法display(), dispose(), reshape(), init(). 由于这是基本框架,因此讨论了原始任务,例如创建canvas类,将其添加到框架中。 所有GLEVentListener接口方法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)使用GLCanvas从javax.media.opengl.awt.AWTGLAutoDrawable继承的setSize()方法设置框架的大小。

glcanvas.setSize( 400, 400 );

现在您已准备好使用GLCanvas

第3步:创建框架

通过实例化JSE AWT框架组件的Frame类Object来创建框架。

添加画布并使框架可见。

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

如果编译并执行上述程序,则会生成以下输出。 它显示了当我们使用带有AWT的GLCanvas类时形成的基本框架 -

基本框架

JOGL - Canvas with Swing

本章将介绍如何使用Canvas和javax.swing包的JFrame类绘制JOGL基本框架。 在这里,我们将实例化一个JFrame,并使用add()方法将canvas对象添加到JFrame的实例中。

使用Canvas和AWT为您提供具有重量级功能的图形框架。 要拥有轻量级图形框架,您需要将GLCanvas与Swing一起使用。 将GLCanvas与Swing一起使用时,可以直接将GLCanvas放在JFrame窗口中,也可以将其添加到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 Class

本章介绍如何使用GLJpanel类绘制JOGL基本框架。 它是一个轻量级的Swing组件,提供OpenGL渲染支持。 它提供与Swing的兼容性。 在这里,我们将实例化一个JFrame,并使用add()方法将GLJpanel对象添加到JFrame的实例中。

以下程序使用带有Swing窗口的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 - Drawing Basics

OpenGL API提供了绘制基本图形元素(如点,顶点,直线等)的基本方法。使用这些方法,您可以开发三角形,多边形和圆形等形状。 在2D和3D维度中。 本章将教您如何在Java程序中使用JOGL绘制基本行。

绘图对象

要访问特定于硬件和操作系统平台的程序以及使用其他语言(如C和C ++(本机应用程序)编写库),Java使用称为Java Native Interface (JNI)的编程框架。 JOGL在内部使用此接口来访问OpenGL函数,如下图所示。

JNI

GLEventListener接口的所有四个方法都有代码(java JOGL方法)在内部调用OpenGL函数。 这些JOGL方法的命名也类似于OpenGL的命名约定。 如果OpenGL中的函数名是glBegin() ,则将其用作gl.glBegin()

每当调用java JOGL的gl.glBegin()方法时,它就会在内部调用OpenGL的glBegin()方法。 这是在安装JOGL时在用户系统上安装本机库文件的原因。

The Display() Method

这是一个保存开发图形代码的重要方法。 它需要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接口的对象,可以访问该接口的成员,从而提供对OpenGL [1.0 ... 3.0]功能的访问。

划线

GL2接口包含大量方法,但这里讨论了三个主要的重要方法,即glBegin()glVertex()glEnd()

Sr.No. 方法和描述
1

glBegin()

此方法开始绘制线条的过程。 它将预定义的字符串整数“GL_LINES”作为参数,它继承自GL接口。

2

glVertex3f()/glVertex2f()

此方法创建顶点,我们必须将坐标作为参数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 - Drawing with GL Lines

在上一章中,我们学习了如何使用JOGL绘制基本线。 我们通过将预定义字段Gl_linesglBegin()方法来绘制线条。

本章提供了使用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 glBegin()的三角形。

三角形

让我们通过一个使用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 - Pre Defined Shapes

在前面的章节中,我们学习了如何使用JOGL绘制线条,三角形,菱形等形状。 我们通过将预定义字段Gl_linesglBegin()方法来绘制线条。

除了GL_LINESglBegin()方法还接受另外八个参数。 您可以使用它们绘制不同的形状。 它们的使用方法与GL_LINES相同。

下表显示了glBegin()方法参数及其描述 -

Sr.No 参数和说明
1

GL_LINES

将每对顶点创建为独立的线段。

2

GL_LINE_STRIP

从第一个顶点到最后一个顶点绘制一组连接的线段。

3

GL_LINE_LOOP

从第一个顶点到最后一个顶点绘制一组连接的线段,再次返回第一个顶点。

4

GL_TRIANGLES

将每个顶点三元组视为一个独立的三角形。

5

GL_TRIANGLE_STRIP

绘制一组连接的三角形。 为前两个顶点之后呈现的每个顶点定义一个三角形。

6

GL_TRIANGLE_FAN

绘制一组连接的三角形。 为前两个顶点之后呈现的每个顶点定义一个三角形。

7

GL_QUADS

将每组四个顶点视为独立的四边形。

8

GL_QUAD_STRIP

绘制一组连接的四边形。 对于在第一对之后呈现的每对顶点定义一个四边形。

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()方法,编译并执行它,将生成以下输出 -

线环

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()方法,编译并执行它,将生成以下输出 -

三角形

用于绘制三角形条带的display()方法的代码片段

public void display(GLAutoDrawable drawable) {
   final GL2 gl = drawable.getGL().getGL2();
   gl.glBegin (GL2.GL_TRIANGLE_STRIP);
   gl.glVertex3f(0f,0.5f,0);
   gl.glVertex3f(-0.50f,-0.75f,0);
   gl.glVertex3f(0.28f,0.06f,0);
   gl.glVertex3f(0.7f,0.5f,0);
   gl.glVertex3f(0.7f,-0.7f,0);
   gl.glEnd();
}

如果用上面的代码替换任何基本模板程序的display()方法,编译并执行它,将生成以下输出 -

三角带

用于绘制四边形的display()方法的代码片段

public void display(GLAutoDrawable drawable) {
   final GL2 gl = drawable.getGL().getGL2();
   gl.glBegin(GL2.GL_QUADS);
   gl.glVertex3f( 0.0f,0.75f,0);
   gl.glVertex3f(-0.75f,0f,0);
   gl.glVertex3f(0f,-0.75f,0);
   gl.glVertex3f(0.75f,0f,0);
   gl.glEnd();
}

如果用上面的代码替换任何基本模板程序的display()方法,编译并执行它,将生成以下输出 -

四边形

用于绘制多边形的display()方法的代码片段

public void display(GLAutoDrawable drawable) {
   final GL2 gl = drawable.getGL().getGL2();
   gl.glBegin(GL2.GL_POLYGON);
   gl.glVertex3f(0f,0.5f,0f);
   gl.glVertex3f(-0.5f,0.2f,0f);
   gl.glVertex3f(-0.5f,-0.2f,0f);
   gl.glVertex3f(0f,-0.5f,0f);
   gl.glVertex3f(0f,0.5f,0f);
   gl.glVertex3f(0.5f,0.2f,0f);
   gl.glVertex3f(0.5f,-0.2f,0f);
   gl.glVertex3f(0f,-0.5f,0f);
   gl.glEnd();
}

如果用上面的代码替换任何基本模板程序的display()方法,编译并执行它,则会生成以下输出 -

多边形

JOGL - Transformation

OpenGL提供了更多功能,例如为对象应用颜色,缩放,照明,旋转对象等。本章介绍了使用JOGL对对象进行的一些转换。

在窗口上移动对象

在前面的章节中,我们讨论了使用简单的线条绘制线条和绘制各种形状的程序。 以这种方式创建的形状可以显示在窗口内的任何位置。 它是使用方法glTranslatef (float x, float y, float z)

此方法属于GLMatrixFunc接口,该接口位于javax.media.opengl.fixedfunc包中。

GLMatrixFunc接口

interface - GLMatrixFunc

package - javax.media.opengl.fixedfunc

下表列出了此接口的一些重要方法 -

Sr.No. 方法和描述
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 - Coloring

本章将教您如何使用JOGL将颜色应用于对象。 要将颜色应用于对象,请使用GL2 glColor()方法。 下面给出了使用glColor方法的语法。

语法 (Syntax)

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

Where,

  • X表示使用的颜色数,3(红色,绿色,蓝色)或4(红色,绿色,蓝色,alpha)。 要获得各种颜色组合,这些颜色的值将作为参数传递。 必须按该顺序维护颜色参数的顺序。

    Example

    如果将颜色值传递为(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 - Scaling

本章将教您如何缩放对象,即使用JOGL增大或减小对象的大小。

通过使用GLMatrixFunc接口的glScalef(float x, float y, float z)方法来GLMatrixFunc 。 此方法接受三个浮点参数,使用它们分别指定沿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生成的原始三角形相比,您可以观察到减小的三角形 -

缩放

JOGL - Rotation

在本章中,我们向您解释了如何使用JOGL旋转对象。 使用GLMatrixFunc接口的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()方法重置投影矩阵。

实例化animator类并使用start()方法启动动画师。

FPSAnimator类

下面给出了FPSAnimator类的各种构造函数。

Sr.No. 方法和描述
1

FPSAnimator(GLAutoDrawable drawable, int fps)

它创建了一个FPSAnimator,它具有给定的每秒帧数值和一个初始可绘制的动画。

2

FPSAnimator(GLAutoDrawable drawable, int fps, boolean cheduleAtFixedRate)

它创建一个FPSAnimator,它具有给定的目标帧每秒值,一个初始可绘制的动画,以及一个指示是否使用固定速率调度的标志。

3

FPSAnimator(int fps)

它创建一个具有给定目标帧每秒值的FPSAnimator。

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

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

start()stop()是这个类中的两个重要方法。 以下程序显示如何使用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 - Lighting

本章介绍如何使用JOGL将光照效果应用于对象。

要设置光照,最初使用glEnable()方法启用光照。 然后使用GLLightingFunc接口的GLLightingFunc glLightfv(int light, int pname, float[] params, int params_offset)方法为GLLightingFunc 。 该方法有四个参数。

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

Sr.No. 参数名称和描述
1

Light

指定灯光。 灯的数量取决于实现,但至少支持八个灯。 它接受10个值,这些参数在下面给出的名为Light Source Parameters的单独表中讨论。

2

Pname

指定单值光源参数。 对于光源,有十个参数,如下所述。

3

Params

指定指向一个或多个值的指针,该值设置为光源light的参数pname

4

Light source parameter

您可以使用下面给出的任何光源参数。

光源参数

Sr.No. 参数和描述
1

GL_AMBIENT

它包含指定灯光环境强度的参数。

2

GL_DIFFUSE

它包含指定光的漫反射强度的参数。

3

GL_SPECULAR

它包含指定灯光反射强度的参数。

4

GL_POSITION

它包含四个整数或浮点值,用于指定均匀对象坐标中光的位置。

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 Basics

在前面的章节中,我们已经了解了如何创建2D对象,对其应用效果以及转换对象。 本章将教您如何绘制具有第三维和某些形状的线。

让我们用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形状,从而生成上述视图。 现在加入剩余的线将导致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) {
      // 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边缘

以同样的方式,通过将3D边缘开发到任何2D四边形的相应边并连接相邻顶点,您可以获得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 Triangle

在前一章我们已经看到了如何绘制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 Cube

在前面的章节中,我们已经看到了如何绘制三角形并旋转它。 现在,在本章中,您可以了解如何使用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)方法将所需纹理绑定到多维数据集。

  • 此方法需要texture(int)参数以及GL2.GL_TEXTURE_2D(int)

  • 在执行Display()之前,需要创建纹理变量

  • init()方法或glDisplay()方法的起始行中, using 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 - Appendix

GPU - 图形处理单元,它是一种加速图像渲染的特殊电子设备。

JNI - Java Native Interface。 使用哪个,java访问本机方法。

Model - 它们是由基本图形基元(如点,线和多边形)构造的对象。

Pixel - 屏幕上显示的最小显示单位。

Projection - 将对象的坐标映射到二维平面的方法称为投影。

Projection matrix - 它是2D表面上的对象的线性变换。

Rendering - 计算机从模型创建图像的过程。

Viewport - 视口是计算机图形中屏幕上的查看区域。

↑回到顶部↑
WIKI教程 @2018