3D计算机图形学基础：从OpenGL到矩阵变换

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

《三维计算机图形学基础》是一本由Steven J. Gortler编著的深入讲解图形学原理的书籍，出版于2012年，由麻省理工学院出版社发行。本书旨在为读者提供一个全面而系统的框架，理解3D计算机图形的基础概念和技术，包括但不限于OpenGL编程接口、几何数据类型、线性代数、变换和矩阵、坐标系与框架、以及图形渲染的基本流程。章节一"Getting Started"引导读者进入图形世界，介绍OpenGL作为常用图形编程工具，帮助理解图形应用程序的构建基础。OpenGL主要涉及3D图形的绘制和渲染，包括点、线和多边形的表示。在第二章"Linear"部分，作者详细讨论了几何数据类型，如点、向量、坐标向量和基底，这些都是构建3D空间结构的基础。接着，通过介绍向量运算、线性变换和3x3矩阵，读者可以学习如何处理形状和空间中的位置和方向。此外，还探讨了额外的结构，如旋转和尺度，这些都是3D变换的重要组成部分。第三章转向"Affine"变换，讲解了帧的概念，即坐标系，以及如何通过四元数矩阵来实现平移、旋转和缩放等复合变换。这一章还涵盖了如何将线性变换应用于点，以及单独处理翻译操作，并展示了这些变换如何结合起来构建复杂场景。第四章"Respect"着重强调帧在图形学中的重要性，讨论了如何处理多个变换以及它们之间的关系。这有助于理解在实际应用中，如动画和游戏开发中，如何管理对象的运动和空间定位。第五章深入到图形系统中的帧概念，区分世界、对象和视图框架，以及如何通过这些框架进行物体的位置调整、尺度控制和层次组织。此外，通过"HelloWorld3D"示例，读者能实践如何在实际代码中运用所学的知识，从设置坐标和矩阵到绘制基本形状，再到利用顶点着色器进行更高级的图形处理。《Foundations of 3D Computer Graphics》提供了一条清晰的路径，让读者逐步掌握3D图形设计的基础知识和核心技术，无论是对于初次接触图形学的学生，还是希望提升技能的专业人士，都是不可或缺的参考资料。通过深入理解这些基础知识，读者将能够构建出更加复杂和真实感的3D图形应用。

CHAPTER 1. INTRODUCTION

Figure 1.1: A cat head is described by a soup of triangles. Someoftheverticesare

highlighted with black dots. From [64],

!Eurographics and Blackwell Publishing

Ltd.

computation can be done using single instruction multiple data (SIMD) parallelism.

Data stored with each geometric vertex can be processed independently from the other

vertices. Likewise, computation to determine the color of one screen pixel can be

computed completely independently from the other pixels.

In a current OpenGL program, much (but not all) of the actual 3Dgraphicsisdone

by the shaders that you write, and are no longer really part of the OpenGL API itself.

In this sense, OpenGL is more about organizing your data and your shaders, and less

about 3D computer graphics. In the rest of this section, we will give an overview of

the main processing steps done by OpenGL. But we will also givesomehighlevel

descriptions of how the various shaders are typically used inthesestepstoimplement

3D computer graphics.

In OpenGL we represent our geometry as a collection of triangles. On the one

hand, triangles are simple enough to be processed very efﬁciently by OpenGL, while

on the other hand, using collections of many triangles, we canapproximatesurfaces

with complicated shapes (see Figure 1.1). If our computer graphics program uses a

more abstract geometric representation, it must ﬁrst be turned into a triangle collection

before OpenGL can draw the geometry.

Brieﬂy stated, the computation in OpenGL determines the screen position for each

vertex of each of the triangles, ﬁgures out which screen dots,calledpixels,liewithin

each triangle, and then performs some computation to determine the desired color of

that pixel. We now walk through these steps in a bit more detail.

Each triangle is made up of 3 vertices. We associate some numerical data with

each vertex. Each such data item is called an attribute.Attheveryleast,weneed

to specify the location of the vertex (using 2 numbers for 2D geometry or 3 numbers

for 3D geometry). We can use other attributes to associate other kinds of data with our

Foundations of 3D Computer Graphics

S.J. Gortler

MIT Press, 2012

CHAPTER 1. INTRODUCTION

Vertex buffer

Uniform Variables

Attributes gl_Position

Varying variables

Vertex Shader

Assembler

Figure 1.2: Vertices are stored in a vertex buffer. When a drawcallisissuedeach

of the vertices passes through the vertex shader. On input to the vertex shader, each

vertex (black) has associated attributes. On output, each vertex (cyan) has a value for

Position and for its varying variables.

vertices that we will use to determine their ultimate appearances. For example, we may

associate a color (using 3 numbers representing amounts of red, green and blue) with

each vertex. Other attributes might be used to represent relevant material properties

describing, say, how shiny the surface at the vertex is.

Transmitting the vertex data from the CPU to the graphics hardware (the GPU)

is an expensive process, so it is typically done as infrequently as possible. There are

speciﬁc API calls to transfer vertex data over to OpenGL whichstoresthisdataina

vertex buffer

Once the vertex data has been given to OpenGL, at any subsequent time we can

send a draw call to OpenGL. This commands OpenGL to walk down the appropriate

vertex buffers and draw each vertex triplet as a triangle.

Once the OpenGL draw call has been issued, each vertex (i.e., all of its attributes)

gets processed independently by your vertex shader (See Figure 1.2). Besides the

attribute data, the shader also has access to things called uniform variables.Theseare

variables that are set by your program, but you can only set them in between OpenGL

draw calls, and not per vertex.

The vertex shader is your own program, and you can put whateveryouwantin

it. The most typical use of the vertex shader is to determine the ﬁnal position of the

vertices on the screen. For example, a vertex can have its own abstract 3D position

stored as an attribute. Meanwhile, a uniform variable can be used to describe a virtual

camera that maps abstract 3D coordinates to the actual 2D screen. We will cover the

details of this kind of computation in Chapters 2- 6 and Chapter 10.

Once the vertex shader has computed the ﬁnal position of the vertex on the screen, it

assigns this value to the the reserved output variable called gl

Position.Thex and

y coordinates of this variable are interpreted as positions within the drawing window.

The lower left corner of the window has coordinates (−1, −1),andtheupperright

corner has coordinates (1, 1).Coordinatesoutsideofthissquarerepresentlocations

Foundations of 3D Computer Graphics

S.J. Gortler

MIT Press, 2012

CHAPTER 1. INTRODUCTION

Rasterizer

gl_Position

Varying variables

Assembler

Figure 1.3: The data in gl Position is used to place the three vertices of the triangle

on a virtual screen. The rasterizer ﬁgures out which pixels (orange) are inside the

triangle and interpolates the varying variables from the vertices to each of these pixels.

outside of the drawing area.

The vertex shader can also output other variables that will beusedbythefragment

shader to determine the ﬁnal color of each pixel covered by thetriangle.Theseoutputs

are called varying variables since as we will soon explain, their values can vary as we

look at the different pixels within a triangle.

Once processed, these vertices along with their varying variables are collected by

the triangle assembler,andgroupedtogetherintriplets.

OpenGL’s next job is to draw each triangle on the screen (see Figure 1.3). This step

is called rasterization.Foreachtriangle,itusesthethreevertexpositionstoplace the

triangle on the screen. It then computes which of the pixels onthescreenareinside

of this triangle. For each such pixel, the rasterizer computes an interpolated value for

each of the varying variables. This means that the value for each varying variable is set

by blending the three values associated with the triangle’s vertices. The blending ratios

used are related to the pixel’s distance to each of the three vertices. We will cover the

exact method of blending in Chapter 13. Because rasterization is such a specialized

and highly optimized operation, this step has not been made programmable.

Finally, for each pixel, this interpolated data is passed through a fragment shader

(see Figure 1.3). A fragment shader is another program that you write in the GLSL

language and hand off to OpenGL. The job of the fragment shaderistodeterminethe

drawn color of the pixel based on the information passed to it as varying and uniform

variables. This ﬁnal color computed by the fragment shader isplacedinapartofGPU

memory called a framebuffer.Thedataintheframebufferisthensenttothedisplay,

where it is drawn on the screen.

In 3D graphics, we typically determine a pixel’s color by computing a few equa-

tions that simulate the way that light reﬂects off of some material’s surface. This calcu-

lation may use data stored in varying variables that represent the material and geometric

properties of the material at that pixel. It may also use data stored in uniform variables

Foundations of 3D Computer Graphics

S.J. Gortler

MIT Press, 2012

剩余283页未读，继续阅读

qq_30757311

粉丝: 0
资源: 2

3D计算机图形学基础：从OpenGL到矩阵变换

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

3d computer vision a geometric viewpoint

Fundation of Computer Graphics

Quaternions for Computer Graphics.pdf

Geometric Tools for Computer Graphics.pdf

Mathematics.for.3D.Game.Programming.and.Computer.Graphics.3rd.Edition.pdf

Course - Mathematics for 3D Game Programming and Computer Graphics.3rd.2012.pdf

Mathematics.for.3D.Game.Programming.and.Computer.Graphics.(2004),.2Ed.LRN.LotB.pdf

curves.and.surfaces.for.computer.graphics.pdf

Foundations of 3D Computer Graphics 无水印pdf

最新资源