Quartz 2D Graphics for MacOS X开发者指南

需积分: 10 163 浏览量更新于2024-07-24 收藏 5.69MB PDF 举报

"Quartz.2D.Graphics 是一本专注于iOS平台上的Quartz 2D图形开发的书籍，适合苹果游戏开发人员阅读。作者R. Scott Thompson是Mindjet Corporation的软件工程师，具有丰富的Macintosh开发经验。该书由Addison Wesley Professional出版，于2006年3月发行，共352页，详细介绍了Quartz 2D在Mac OS X系统中的应用。" Quartz 2D是苹果操作系统中的核心2D绘图框架，它提供了低级别的图形绘制功能，使得开发者能够创建出高质量的图形和图像。在iOS和Mac OS X平台上，Quartz 2D是构建图形用户界面和进行定制图形渲染的重要工具。这本书《Quartz 2D Graphics for MacOS X Developers》深入探讨了如何利用Quartz 2D API来实现高效的图形处理。本书的主要内容可能包括： 1. **Getting Started** - 这一章可能会介绍Quartz 2D的基本概念，以及如何在项目中接入Quartz 2D库。书中可能会讲解到必要的编程环境设置，以及如何在代码中初始化和使用Quartz 2D。 2. **From QuickDraw to Quartz 2D** - QuickDraw是Mac OS早期的图形引擎，这一章可能会讲述QuickDraw的历史，以及为什么Quartz 2D取代了QuickDraw，重点讨论两者之间的差异和改进。它可能还会涉及PDF（Portable Document Format）在现代图形编程中的作用，因为Quartz 2D基于PDF的渲染模型。 3. **MacOS X Graphics Architecture** - 这一部分将详细阐述Mac OS X的图形架构，包括Core Graphics、Core Image等框架的集成，以及如何利用这些框架进行复杂的图形操作。Core Image API可能是书中一个重要的章节，因为它提供了图像处理和滤镜效果的接口。 4. **Graphics Programming in the Modern Age** - 书中可能会讨论在现代开发环境中，如何利用Quartz 2D进行图形编程，包括动画、触摸事件处理、性能优化等方面。此外，可能还会涉及与其他苹果技术如OpenGL和Metal的协同工作。 5. **Advanced Topics** - 除了基础内容外，书中的高级章节可能会涵盖更复杂的技术，如自定义绘图路径、渐变、阴影效果、文本渲染、图像合成等，帮助开发者创造出更加丰富多彩的图形界面。这本书对于那些想要深入理解iOS和Mac OS X图形编程的开发者来说是一份宝贵的资源，通过它，读者可以学习到如何充分利用Quartz 2D来提高应用程序的视觉质量和用户体验。同时，了解Quartz 2D也可以为开发者在其他图形框架如cocos2D的使用上提供基础，增强游戏开发能力。

The Legacy of QuickDraw and the Rise of PDF

The QuickDraw graphics library stands to this day as testament to the original Macintosh computer and

its creators. The library was the fundamental technology that made the original Macintosh graphical user

interface possible. QuickDraw was brought to life by the ingenuity and skill of software designers such

as Bill Atkinson and Andy Herzfeld. Apple created QuickDraw in the late 1970's and early 1980s, an era

in which "real" computer graphics were the province of large, powerful mainframe computers, and

personal computers were just making the transition from novelty to necessity.

QuickDraw had very modest beginnings. In various forms, the original code ran on computers like the

Apple Lisa and the original Macintosh. The high resolution bitmapped displays of these computers was

considered a revolution when compared to the character terminals of the previous computer generation.

In spite of their sophistication, however, the computers could only display graphics in black and white.

QuickDraw was flexible enough to produce impressive graphics on both the screen and on printer. The

library incorporated a number of revolutionary advances, features that were not found on personal

computers prior to the Macintosh. Among these were the support for pixel regions, drawing operations

that could be recorded into a meta-file (the infamous PICT file format), the ability to scale the drawings

in a meta-file on playback, and drawing primitives for ovals, curves, and rounded rectangles.

Although QuickDraw and its immediate ancestors ran on computers

that could only display black and white, the API actually supported

several colors. Even though the computers could not display those

colors on screen, QuickDraw could print in color to some printers.

The 9-inch black and white display of the original Macintosh quickly became a thing of the past.

Computers evolved, as did the sophistication and requirements of applications and users. Apple evolved

QuickDraw along with its computers. As displays became capable of reproducing millions of colors and

two tone dot-matrix printers evolved into high-resolution, photo quality ink jet printers, QuickDraw both

kept up the pace and pushed the envelope of graphics evolution. The era of QuickDraw ended, however,

when Apple deprecated the technology in Mac OS X 10.4 Tiger. The QuickDraw library came of age as an

important building block for vital graphics technologies like QuickTime and ColorSync. Along the way it

not only served the graphics industry, but also took a hand in shaping it.

PostScript and Desktop Publishing

QuickDraw was not the only technology born in 1984 to have a profound impact both the graphics

industry and the Mac OS X platform. In the same year, Chuck Geschke and John Warnock incorporated a

new company, Adobe Systems Inc. Adobe released the first version of their PostScript graphics system

that same year.

The PostScript graphics system grew out of research Adobe's founders performed while working at Xerox.

That research centered around innovative ways to write control software for laser printers. The

PostScript system combines a rich graphics model, a simple programming language, and a run-time

environment. At the time of its introduction, the system's ability to repurpose graphics on a broad

number of printers with very different capabilities was a clarion call for the graphics industry.

PostScript was unusual because of the device independence inherit in the system. A PostScript program

could send the same drawing commands to two printers with very different capabilities, and both would

reproduce the same graphic to the best of their abilities. One printer might draw the graphic with a low

resolution and in black and white, while the same program on another printer might generate a high-

resolution color image. This was in stark contrast to the fixed resolution, device dependent nature of

QuickDraw and other graphics libraries.

The paths of QuickDraw and PostScript were destined to converge. Apple and Adobe brought these two

technologies together when they developed the LaserWriter printer. In spite of the fact that QuickDraw

had one drawing model, and PostScript a completely different one, application developers combined the

on-screen drawing with QuickDraw and the printing might of PostScript. This synthesis led to the

creation of creative applications such as Aldus Page-Maker and Adobe Illustrator. Applications like these

freed document editors from the proprietary typesetting systems that had dominated the industry. The

Desktop Publishing revolution had arrived.

PostScript on the Screen

The rift between the graphics model of the screen and the graphics model of the printer continued for

some time. In fact, this was not limited to the Macintosh platform. Microsoft Windows, for example,

used the GDI graphics library when drawing on screen. On many UNIX systems, applications used the

XLib library of the X11 windowing system to create graphics on the screen. Both GDI and XLib are

graphics libraries very similar to QuickDraw. Each of these environments also supported PostScript as a

tool for creating high-quality graphics on the printer.

In this environment, application developers applied their creativity and ingenuity to bridge the gap

between libraries and create WYSIWYG applications. It wasn't long before enterprising developers

realized the potential benefit of using PostScript for graphics on the screen as well. In fact, one of the

earliest implementations of this idea came when Sun Microsystems created an entire windowing system

based on PostScript! That windowing system was called NeWS, the Network extensible Windowing

System.

NeWS was unusual because it used PostScript as more than just a graphics library. The windowing

system itself was implemented on top of a customized PostScript interpreter. Developers could extend

the system or write NeWS applications in PostScript. In spite of the novelty and innovation in NeWS,

however, it never gained much of a foothold in the industry. Eventually it faded from view.

The lead engineer of NeWS was Jim Gosling. After working on NeWS,

he turned his attention to Java where he designed the original

language, compiler, and virtual machine.

The engineers at Sun were not the only group to bring PostScript to the screen. One of the most

successful environments to integrate PostScript into its graphics architecture was the NeXT Computer

operating system. Steve Jobs started NeXT Inc. shortly after leaving Apple. The computers that company

created were revolutionary in a number of ways. The NeXT operating system included an optimized

PostScript interpreter. Applications created their graphics in windows by calling routines invoked the

PostScript interpreter.

NeXT sold a PostScript laser printer that didn't include a PostScript

interpreter! The system relied on the computer to process the

PostScript and then sent the resulting graphics to the printer over a

high-speed communication line.

The success of the NeXT graphics library caused other industry leaders to take notice. Adobe

collaborated with NeXT to create a standard called Display PostScript for PostScript graphics on the

screen. Display PostScript incorporated a small set of extensions to the basic PostScript language. In

time, Adobe licensed Display PostScript for use in other computing environments. The X11 applications

on some UNIX computers could create windows that contained Display PostScript graphics. Display

PostScript, like the NeWS window system, never gained a broad acceptance in the industry. When Apple

purchased NeXT Computer, in 1996, it acquired all of its technologies, including its implementation of

Display PostScript.

PDF to Quartz 2D

Even though Display PostScript enjoyed limited popularity, the appeal of PostScript continues to this day.

There is, however, one evolution that is particularly relevant to the Macintosh and Quartz 2D.

The PostScript system includes both an imaging model and a programming language. While the flexibility

of the imaging model continues to this day, the programming language aspects of PostScript have

proven to be problematic.

PostScript interpreters run PostScript programs. Like most programs, PostScript code must execute

sequentially. This can lead to difficulty when printing documents. For example, if a press operator wants

to print page 99 of a 100-page document, the PostScript interpreter must execute the code that draws

the first 98 pages. The results of that drawing take time, and the resulting graphics are merely

discarded. This is obviously a waste of time and resources.

Furthermore, because PostScript drawings are actually programs, they are susceptible to programming

bugs. To continue the example just discussed, a logic error on page 97 might cause the printer to

abandon the entire print job. As these problems came to light, Adobe added some features to

PostScript. The new features helped to alleviate problems but did not eliminate them. In the end Adobe

recognized the limitations of PostScript and took another tack on the problem.

The Portable Document Format (PDF) works around many of the limitations of PostScript. At its heart,

PDF is a file format that includes the graphics features of PostScript (with a few minor changes). At the

same time, the standard removes most of the programming language aspects of PostScript. A PDF

document is not an executable program so much as it is a structured container for drawing commands

and related metadata. The file format continues PostScript's advantages of device and resolution

independence. In short, PDF retains the graphical power of PostScript but eliminates some of its less

reliable aspects.

Apple evaluated the technologies they purchased for NeXT with a eye toward creating Mac OS X. They

looked at the evolution of PostScript and the PDF strategy. Combining these elements with their own

unique flair, Apple developed a new graphics library for Mac OS X that combined the richness of the

Adobe Imaging Model with alpha channel support in the high-performance graphics library we know

today as Quartz 2D.

Understanding this legacy can be an important part of understanding why the Quartz 2D imaging model

behaves as it does. For example, Quartz 2D does not provide an easy mechanism for erasing graphics

you have already drawn. The reason is that when you are drawing to a printer, the graphics may not be

going to a frame buffer, and there is no way to erase graphics. Instead of erasing graphics, in Quartz

2D you create a mask, or clipping area, and draw the graphics you want the user to see relying on the

mask to remove parts of the image you don't want to display. This is a simple example but very

illustrative of how the drawing model of the library can affect how it is used.

Graphics Programming in the Modern Age

One advance in technology that contributed to the demise of QuickDraw was the trend in modern

personal computers to move more of the graphics capabilities of the system to video cards. Indeed the

advent of video cards with dedicated graphics processing units has ushered in a new age of computer

graphics. Quartz 2D and Core Image take advantage of these recent developments to improve their

functionality and performance. Core Image in particular is a direct benefactor of the power of modern

graphics hardware. The evolution of the graphics system in personal computers is extending the reach of

those machines to new and exciting fields of endeavor. The Mac OS X graphics system is at the fore-

front of this technologies wave. By using modern graphics APIs like Quartz 2D, your application can take

advantage of the work Apple has done, and you can enjoy the benefits of the hardware while

concentrating on a simple interface.

By way of an example, consider the impact that modern personal computers have had on video

production. We live in an age where studios use computer graphics to create full-length, animated

feature films. In the past, digital video production houses used expensive, dedicated workstations to

produce their films.

Just as PostScript shifted print publishing from proprietary systems to the desktop, the development of

software such as Final Cut Pro has professional quality video editing onto consumer computers. This

transition works because of a combination of hardware improvements and the advancement of the

graphics systems on personal computers.

In recent past, images that used 32 bits per pixel and alpha channels could only be manipulated by

high-end applications. Today, however, these images are commonplace. The CCT chips in modern digital

cameras can capture images using 12 bits per color channel or more. Storing these images in an 8 bit

per channel image drops valuable color information. The high-end applications of today may choose to

use a full 32-bit floating point value to represent just one color channel. Each pixel, therefore, requires

128 bits. An image with the same dimensions may require four times the storage just to hold the

additional color information! Processing such an image requires the computer to sift through four times

the data.

Shuffling around large volumes of pixel data is one difficulty. The color channels in these images are

stored in floating point representations. Correspondingly, performing calculations on those pixels requires

floating point math. Computing at this level requires significant processing horsepower and efficient use

of graphics resources. Computer scientists have answered the demand for greater graphics processing

power by adding dedicated computer graphics hardware to personal computers.

General Purpose Vector Processors for Graphics

A good example of the evolution of hardware with a corresponding impact on graphics is the addition of

vector processing units to general purpose microprocessors. On the Macintosh platform, for example, the

G4 and G5 PowerPC processors have a vector processor known as the Velocity Engine. Developers will

recognize it by its geeky name, AltiVec. Intel-based processors include SIMD technologies like MMX or

SSE.

AltiVec will serve as a good example of a general purpose vector processor. The registers of the AltiVec

unit store quantities that are 128 bit wide. The processors instructions treat those bits as vectors.

Depending on the instruction, the processor will interpret the 128 bits as a vector whose components

have different lengths. Figure 2.1 shows the different ways that AltiVec processors can interpret 128

bits.

Figure 2.1. AltiVec Register Configurations

When interpreting a vector of four 32-bit values, the processor can treat those bits as either a 32-bit

integer or a 32-bit floating point value. A graphics application might feed the AltiVec unit with 16 pixels

of an 8-bit grayscale image all at once. The program could then lighten all 16 pixels at once using a

single AltiVec command.

Using different instructions, a program could also load an AltiVec register with the four 32-bit floating

point numbers that make up a single floating point ARGB pixel. The AltiVec processor could combine two

floating point ARGB pixels in a single operation. From these two examples, it's easy to see how the

processing muscle of a vector unit like AltiVec can improve graphics performance.

One shadow that complicates the use of vector processing units for graphics is the fact that the AltiVec

unit is not dedicated to graphics alone. Computer games are popular clients of the graphics system.

Many games contain computing engines that handle physics calculations. Physics involves working with

vector-valued quantities like velocities and accelerations. These calculations are also a good fit for

implementation with the vector processor. Scientific visualization applications also rely heavily on the

graphics system and include algorithms that benefit from the vector processor. In many applications, the

vector processor is shared between the graphics systems and other computation engines.

Computers with two or more microprocessors often have the added luxury of a second vector processing

unit, and applications can employ that to alleviate some of the congestion. Unfortunately, there is a

practical limit that prevents computers from scaling performance through the addition of processing

units.

The complexity of a general-purpose vector processor means that they also take up quite a lot of space

on silicon chips. Correspondingly, the amount of power they require and the amount of heat they

generate increases with each additional unit. Issues like these make it very hard to scale the

performance of a general vector processor by simply adding additional cores. As will be shown, however,

if we reduce the complexity of the core, limit the operations it can perform, and focus it on a specific

task, the idea of scaling vector processing power this way actually works quite well.

The Emergence of the GPU

Another common technique to boost the graphics performance of a computer is to augment the CPU

with an additional processor that is dedicated graphics. On the personal computer systems of today, that

additional processor is usually found on the computer's video card.

Many of the earliest models of graphics coprocessors, particularly in the personal computer space, were

simply tools to speed up some very specific parts of the 3D graphics pipeline. The cards had algorithms

for applying lighting and shading models to simple geometric primitives like triangles. The algorithms

were hard-wired into the video card and could not be changed. Communication with these cards flowed

in one direction only, from the main computer to the video card. The cards were useful for rendering 3D

graphics efficiently but could not be used in more general graphics applications.

As time progressed, the services provided by the video card's processor expanded to include more

general purpose routines. The data path between the main CPU and the graphics card widened and

became bidirectional. With those innovations, programs gained the ability to use the graphics processor

to perform calculations and retrieve the results to main memory. This allowed the video card to behave

as a graphics computation engine, not just a display mechanism.

Collectively, these more powerful processors have come to be known as Graphics Processing Units or

GPUs. They play a significant role in boosting the graphics capabilities of modern computers. Along with

the GPU, a typical video card will also contain a block of dedicated memory (called Video RAM or VRAM)

and some kind of hardware that converts bits in the cards display buffer into video signals for a

computer display. In many respects, the video card resembles a self-contained graphics computer. Like

剩余248页未读，继续阅读

LAOKAI119

粉丝: 6
资源: 4

Quartz 2D Graphics for MacOS X开发者指南

iOS Quartz 2D绘图引擎详解

Quartz 2D：iOS/Mac OS X 2D绘图引擎详解与应用

探索MacOS的Quartz 2D与PDF图形编程

Mac.OS.X开发系列电子书].Quartz.2D.Graphics.For.Mac.OS.X.Developers.pdf

ios-Quartz2D.zip

Quartz 2D Graphics for Mac OS X Developers

Programming with Quartz 2D and PDF Graphics in Mac OS X .pdf

Quartz_2D_Programming_Guide.tar

Quartz_2D编程指南

Programming with Quartz 2D and PDF Graphics in MacOS

最新资源