3D图形编程基础全解析

需积分: 9 18 浏览量更新于2024-07-24 1 收藏 18.11MB PDF 举报

"《Foundations of 3D Graphics Programming》由Jim X. Chen和Edward J. Wegman合著，是一本深入探讨3D图形编程的书籍，主要使用JOGL（Java OpenGL绑定）和Java 3D技术进行讲解，并配有139幅插图。该书适合对3D图形编程感兴趣的计算机科学学生和专业人士，通过学习可以掌握3D图形的基本概念、技术和应用。" 在3D图形编程领域，理解基础概念和技术是至关重要的。本书详细介绍了以下关键知识点： 1. **3D坐标系统**：学习如何理解和操作3D空间中的坐标系，包括笛卡尔坐标系、视口坐标系和屏幕坐标系的转换。 2. **向量和矩阵**：作为3D图形中的基本数学工具，向量和矩阵的运算对于表示和变换3D对象至关重要。书中会涵盖向量的加减、标量乘法、点积、叉积以及矩阵的乘法、逆矩阵、旋转和平移变换等。 3. **图形管线**：OpenGL的图形渲染管线是3D图形处理的核心，书中会解释从顶点数据到屏幕像素的整个过程，包括顶点处理、几何变换、投影、裁剪、视口转换和光栅化等阶段。 4. **JOGL介绍**：JOGL是Java平台上的OpenGL绑定，它允许开发者使用Java语言进行高性能的3D图形编程。书中会介绍如何设置JOGL环境，创建基本的窗口，以及如何使用JOGL接口来绘制3D图形。 5. **Java 3D API**：Java 3D是一种高级的3D图形API，提供了面向对象的方式来构建复杂的3D场景。书中会讨论Java 3D的核心类，如`SceneGraph`、`TransformGroup`和`Appearance`，以及如何创建和管理3D模型。 6. **光照和材质**：理解光照和材质对于创建逼真的3D场景至关重要。书中会讲解各种光照模型，如环境光、漫反射和镜面反射，以及材质属性如颜色、透明度和反光度。 7. **纹理映射**：纹理映射是将2D图像应用到3D表面的技术，用于增加细节和真实感。书中会涵盖纹理坐标、纹理坐标生成、纹理过滤和MIP映射等内容。 8. **深度缓冲与隐藏面消除**：这两个技术解决了多边形重叠时的显示问题，确保正确地渲染深度关系并隐藏不可见的表面。 9. **动画与交互**：书中还会涉及如何创建动态3D场景，包括时间驱动的动画和用户交互，例如旋转、平移和缩放3D对象。 10. **实例和项目**：通过一系列示例和实践项目，读者可以逐步学习如何将所学知识应用于实际的3D应用程序开发。《Foundations of 3D Graphics Programming》全面覆盖了3D图形编程的基础和实践，旨在帮助读者建立起坚实的技术基础，为进一步探索复杂的3D图形算法和高级视觉效果打下坚实基础。

4 1 Introduction

That is, you need to place the “jogl.jar” file in the CLASSPATH of your build

environment in order to be able to compile an application with JOGL and run, and

place “jogl.dll” and “jogl_cg.dll” in the directory listed in the “java.library.path”

environment variable during execution. Java loads the native libraries (such as the

dll file for Windows) from the directories listed in the “java.library.path”

environment variable. For Windows, placing the dll files under

“C:\WINDOWS\system32\” directory works. This approach gets you up running

quickly without worrying about the “java.library.path” setting.

3. Installing a Java IDE (Eclipse, jGRASP, or JBuilder)

Installing a Java IDE (Integrated Development Environment) is optional. Without

an IDE, you can edit Java program files using any text editor, compile and run Java

programs using the commands we introduced above after downloading JOGL.

Java IDEs such as Eclipse, JBuilder, or jGRASP are development environments

that make Java programming much faster and easier. If you use Eclipse, you can

put “jogl.jar” in “C:\j2re1.5.0\lib\ext\” directory in the Java runtime environment.

You can download from http://eclipse.org

the latest version of Eclipse that matches

the platform you use. Expand it into the folder where you would like Eclipse to run

from, (e.g., “C:\eclipse\”). There is no installation to run. To remove Eclipse you

simply delete the directory, because Eclipse does not alter the system registry.

If you use jGRASP, in the project under “compiler->setting for

workspace->PATH”, you can add the directory of the *.dll files to the system PATH

window, and add “jogl.jar” file with full path to the CLASSPATH window.

As an alternative, you can download a free version of JBuilder from

http://www.borland.com/jbuilder/

. JBuilder comes with its own JDK. If you use

JBuilder as the IDE and want to use your downloaded JDK, you need to start

JBuilder, go to "Tools->Configue JDKs", and click "Change" to change the "JDK

home path:" to where you install your JDK. For example, “C:\j2sdk1.5.0\”. Also,

under "Tools->Configue JDKs", you can click “Add” to add “jogl.jar” from

wherever you save it to the JBuilder environment.

4. Creating a Sample Program in Eclipse

As an example, here we introduce using Eclipse. After downloading it, you can run

it to start programming. Now in Eclipse you click on “File->New->Project” to

create a new Java Project at a name you prefer. Then, you click on

1.2 OpenGL Programming in Java: JOGL 7

1.2.2 Drawing a Point

The above J1_0_Point.java is a Java application that draws a red point using JOGL. If

you are a C/C++ programmer, you should read all the comments in the sample

program carefully, because they include explanations about Java-specific

terminologies and coding. Our future examples are built on top of this one. Here we

explain in detail. The program is complex to us at this point of time. We only need to

understand the following:

1. Class GLCanvas is an Abstract Window Toolkit (AWT) component that provides

OpenGL rendering support. Therefore, the GLCanvas object, canvas

, corresponds

to the drawing area that will appear in the Frame object frame

, which corresponds

to the display window. Here object means an instance of a class in object-oriented

programming, not a 3D object. In the future, we omit using a class name and

underline its object name in our discussion. In many cases, object names are

lowercases of the corresponding class names to facilitate understanding.

2. An event is a user input or a system state change, which is queued with other events

to be handled. Event handling is to register an object to act as a listener for a

particular type of event on a particular component. Here frame

is a listener for the

GL events on canvas

. When a specific event happens, it sends canvas to the

corresponding event handling method and invokes the method. GLEventListener

has four event-handling methods:

• init() is called immediately after the OpenGL context is initialized for the first

time, which is a system event. It can be used to perform one-time OpenGL

initialization;

• reshape() is called if canvas

has been resized, which happens when the user

changes the size of the window. The listener also passes the drawable canvas

and

the display area’s lower-left corner (x, y) and size (width, height) to the method. At

this time, (x, y) is always (0, 0), and the canvas

’ size is the same as the display

window’s frame

. The client can update the coordinates of the display

corresponding to the resized window appropriately. reshape() is called at least

once when program starts. Whenever reshape() is called, display() is called as

well;

• display() is called to initiate OpenGL rendering when program starts. It is called

afterwards when reshape event happens;

8 1 Introduction

• displayChanged() is called when the display mode or the display device has been

changed. Currently we do not use this event handler.

3. canvas is added to frame to cover the whole display area. canvas will reshape with

frame

4. gl is an interface handle to OpenGL methods. All OpenGL commands are prefixed

with “gl” as well, so you will see OpenGL method like gl.glColor(). When we

explain the OpenGL command, we often omit the interface handle.

5. Here we set the physical size of frame and make its contents visible. Here the

physical size corresponds to the number of pixels in x and y direction. The actual

physical size also depends on the resolution of the display, which is measured in

number of pixels per inch. At this point, the window frame appears. Depending on

the JOGL version, the physical size may include the boarders, which is a little

larger than the visible area that is returned as w and h in reshape().

6. The foreground drawing color is specified as a vector (red, green, blue). Here (1, 0,

0) represents a red color.

7. These methods specify the logical coordinates. For example, if we use the

command glOrtho(0, width, 0, height,

−

1.0, 1.0), then the coordinates in frame (or

canvas

) will be 0 ≤ x ≤ width from the left side to the right side of the window, 0 ≤

y ≤ height from the bottom side to the top side of the window, and −1 ≤ z ≤ 1 in the

direction perpendicular to the window. The z direction is ignored in 2D

applications. It is a coincidence that the logical coordinates correspond to the

physical (pixel) coordinates, because width and height are initially from frame

’s

WIDTH and HEIGHT. We can specify glOrtho(0, 100*WIDTH, 0, 100*HEIGHT,

−

1.0, 1.0) as well, then point (WIDTH/2, HEIGHT/2) will appear at the lower-left

corner of the frame

instead of the center of the frame.

8. These methods draw a point at (WIDTH/2, HEIGHT/2). The coordinates are logical

coordinates not directly related to the canvas’ size. The width and height in

glOrtho() are actual window size. It is the same as WIDTH and HEIGHT at the

beginning, but if you reshape the window, they will be different, respectively.

Therefore, if we reshape the window, the red point moves.

In summary, when Frame is instantiated, constructor J1_0_Point() will create a

drawable canvas, add event listener to it, attach the display to it, and get a handle to gl

methods from it. reshape() will set up the display’s logical coordinates in the window

frame. display() will draw a point in the logical coordinates. When program starts,

剩余304页未读，继续阅读

weifeng0715

粉丝: 2
资源: 17

3D图形编程基础全解析

Foundations of 3D Graphics Programming - Using JOGL and Java3D (Springer, 2006)

Foundations Of 3D Computer Graphics (高清PDF扫描版)

foundations of programming languages pdf

foundations of data science csdn

foundations of machine learning答案

foundations of optimization 苏文藻

foundations of mimo communication pdf

foundations of game engine development pdf

foundations of statistical natural language processing

我想学习计算机图形学，你能帮我推荐几本书籍吗？

最新资源