Vector Art, Images, and Graphics Download

Logo Doll HQ Logo Templates

Logo doll is a 500 HQ logos and a done for you website kit to help you build your email list and earn affiliate commissions in 3 easy steps. In the program, you'll get three steps to good results. This includes Download the logos, Upload the website, and Earn commissions. The website is built in 3 different website platforms, including Convertri templates, HTML mini-site, and Optimize press template. The website is built in convertri and optimize press templates that can be imported into those platforms in seconds and a full HTM mini-site. This will let you choose the best alternative for you. Also, if you join Logo doll today, you'll qualify for a VIP training workshop, profit Rolodex, video training, free graphic software, and developers license as free bonuses. The total value of these bonuses is more than $297, but you can get them free if you join the logo doll today. There is no negative comment regarding the logo doll program. However, you can join, taste the effectiveness and give your own experience. Continue reading...

Logo Doll HQ Logo Templates Summary

Rating: 4.6 stars out of 11 votes

Contents: Website
Creator: Noel Cunningham
Price: $1.00

Access Now

My Logo Doll HQ Logo Templates Review

Highly Recommended

Some users might complain that the default interface is more complicated than it needs to be. If you just panicked grab a quick drink and relax because this baby has a full customizable interface.

However, Logo Doll HQ Logo Templates is a fairly good program considering the standard and depth of the material it provides. In addition to being effective and its great ease of use, this software makes worth every penny of its price.

Installing Graphics Drivers

Ubuntu is extremely good at detecting and configuring graphics cards. By default it ships with a number of proprietary drivers to allow graphics cards to work and will alert you to this by using the Hardware Drivers Manager. You can then choose to enable or disable the drivers as appropriate, depending on your personal preference. (See the Open-Source Versus Proprietary note earlier in this chapter.) For the most part, Ubuntu will detect and configure the majority of graphics cards from the start, and even if it has problems, it will attempt to give you a display of some sort. This feature is known as BulletProof X, and it allows you access to tools that may help you fix your problem by trying different combinations of graphics cards and monitors.

Graphics Fundamentals

2D raster graphics consist of plotted pixels on a display. The pixels are arranged in a rectangular grid, typically accessible in memory as a linear sequence of bytes. Though we specify pixels by their addresses in memory at the lowest level, it is better to specify pixels in terms of a 2D coordinate system, with horizontal x and vertical y axes. In this book, we define the origin of the 2D pixel coordinate system to be the upper-left corner of the screen, with the x axis increasing to the right and the y axis increasing downward. Under Linux, we display our graphics under the X Window System. Specifically, the approach chosen for this book is to use Xlmages in ZPixmap format to display 2D graphics. This allows us direct access to the bytes (and thus the pixels) forming the image. Each pixel can have a particular color. Exactly how this color is specified depends on the bit depth and color model of the X server. The bit depth determines the total number of available colors and is...

Working with Graphics

Tools for creating and manipulating graphics are becoming both more plentiful and more powerful in Linux systems as a whole. Leading the list is the GNU Image Manipulation Program (GIMP). GIMP enables you to compose and author images as well as retouch photographs. To work with vector graphics (where geometric shapes represent images, instead of just dots), Inkscape is a popular open source application. Other tools for creating graphics include ksnap-shot (a program for taking screen captures) and kpaint (for working with bitmap images).

Video Graphics Card Driver Support Ati Nvidia and Livna

Though a generic Xorg NVIDIA and ATI driver is included with Fedora, to make full use of your graphics driver, you will have to use the vendor-supplied NVIDIA or ATI drivers. Both NVIDIA and ATI provide Linux-compatible versions of their drivers, released almost monthly. The drivers contain updated bug fixes and enhancements. You can download and install these drivers either directly from the vendor Web site or with Yum using the Livna-prepared versions. It is always preferable to use the Livna versions of the vendor graphics drivers. The Livna versions have been tested and configured specifically for use on Fedora, whereas the direct vendor packages are generic, designed for all Linux systems. Most likely you will have difficulties trying to use the vendor graphics packages directly, whereas the Livna versions usually have no problems. Livna remains perhaps the best repository for specialized kernel drivers and modules, even though some of its other multimedia packages may conflict...

Configure the Graphics Card

If you select the headline Graphics Cards, YaST starts the SaX2 configuration tool to configure the graphics card settings. The following appears * Graphics card Display. Configure your monitor, graphics card, color depth, resolution, and the position and size of the screen. Input Devices. Configure the keyboard, mouse, touchscreen monitor, and graphics tablet.

Working with Graphics Formats

If you want to view or manipulate an image, you need to identify the file format to choose the proper tool for working with the image. The file's extension is your first indicator of the file's format. The graphics image formats supported by the applications included with Ubuntu include Bitmapped graphics, commonly used in Microsoft Windows CompuServe Graphics Interchange Format Joint Photographic Experts Group . .png Portable Network Graphics . .svg Scalable Vector Graphics

Accessing framebuffer graphics after installation

Because SUSE's installer automatically starts the X Window system in graphical mode, you may believe that you've correctly specified your graphics hardware during installation. Unfortunately, you may then find that X (and sax2) will not start or execute correctly on your system. This is especially common when installing SUSE on laptops, which frequently use custom, low-power versions of well-known graphics chips. To start sax2 using framebuffer graphics, use the following command If this doesn't work, you can use the following command to tell sax2 to experiment with various graphics modes until it finds one that works correctly

Graphics Applications

In this chapter, we'll concentrate on the applications that are installed by default with Red Hat Linux 9 The GIMP, PDF Viewer, GQView, and OpenDraw. Most of these are contained within the Graphics package group (which you'll find under the Applications category of the RPM), and can be found in the Main Menu Graphics menu.

Graphics Tools and Multimedia

Fedora includes a wide range of both graphic and multimedia applications and tools. such as simple image viewers like KView, sophisticated image manipulation programs like GIMP, music and CD players like Rhythmbox, and TV viewers like Totem. Graphics tools available for use under Linux are listed later in Table 12-2. Additionally, there is strong support for multimedia tasks from video and DVD to sound and music editing (see Table 12-3). Thousands of multimedia and graphic projects, as well as standard projects, are under development or currently available from www.sourceforge.net,rpm.livna.org, and freshrpms .net. Be sure to check the SourceForge site for any kind of application you may need.

Two Kinds of Graphics

The two basic kinds of graphics are bitmaps and pixmaps There seems to be no end to graphics file formats. Thanks to a universal conversion utility, almost any graphics file format can be used inside a KDE application. The convert utility (described in more detail later in this chapter) can convert a graphics file from some external format into a format that can be displayed. For example, the following command shows how to convert a JPEG file into a pixmap a form that can be compiled directly into your program The convert utility looks at the contents of the input file to determine what kind of file it is (it doesn't trust the file suffix on input), and looks at the suffix of the output filename to determine what kind of graphics file to produce.

Customizing Graphics for Menus and Toolbars

The following example program allows you to browse through a selection of graphics files and display the six different forms of the one you select, as shown in Figure 9-7. A QFileDialog, described in Chapter 5, is used to select and load a QPixmap from a graphic file. A QlconSet object is then used to create the six versions of the pixmap displayed in the figure.

Open Office Draw for Graphics

OpenOffice features a graphics program called Draw. While it is technically a vector program, it provides some of the bitmap functionality of programs such as The GIMP and could be classified as a beginner- to intermediate-level graphics program. It is well suited for combining text, shapes, lines, and images into a single document, and has a limited ability to do a wide variety of tasks that usually require a specialized program. While some of its features are not as refined as they are in programs such as The GIMP, the advantage is that they are combined in one program. So if you want to create a business card with a graphic, you can do it without moving back and forth between programs.

Graphics Manipulation

The previous chapter demonstrated some of the fundamentals of drawing and painting graphics to windows, and this chapter demonstrates some of the special capabilities in KDE and Qt for manipulating graphics. Because everything displayed in a widget is graphic, many of the techniques described in this chapter can be used to modify any graphic content. Probably the most useful information pertains to the processes for rotating and positioning images, but there is quite a bit more. For one thing, depending on the capabilities of your printer, it is a very simple process to print a graphic image in color or in black and white. It is possible to reshape graphics scaling and shearing, or even to modify images by making changes to bit values of each pixel. And animation can be performed by drawing one frame after another and displaying the frames in a controlled, timed sequence.

Using a QPicture to Store Graphics

Anything that can be drawn to the window of a widget can also be drawn to a QPicture object. The QPicture object can then save the drawing instructions to a disk file, and another QPicture object can read the file and execute the drawing instructions. There are a number of uses for this, including the capability to store complicated drawings and transmit graphics from one system to another. The following program creates a simple drawing and saves it to a disk file Printing windows and other graphics Scaling, clipping, shearing, rotating, and translating graphics

Vector Graphics Tools for Linux

Standard document and graphics formats were less important before personal computers became the latest household appliance and the Internet provided a common platform for exchanging and presenting text and illustrations. Previous chapters stressed the importance and value of open standards for the written word such as HTML and the Open Document format. Similar standards are emerging in the area of graphics and illustration, where older formats such as GIF and JPEG are being complemented by the emergence of open raster graphics standards such as Portable Network Graphics (PNG) and an equally powerful, open standard for vector graphics such as the W3C standard Scalable Vector graphics (SVG) format. (For more information about the SVG standard, see www.w3.org Graphics SVG .) Aside from being designed from the ground up as an open format, one of the primary advantages of SVG files is that they are, as the name suggests, scalable. Because SVG files consist of drawing and color information...

Other Graphics Applications

Graphics programs seem to rank second to text editors and word processors in terms of the sheer number of available choices. Each has its own niche, fans, and detractors. Since I've already acknowledged that I'm not particularly good at graphics, I've covered only the graphics programs that I have actually used at one time or another and which I feel are the best applications for creating and editing various types of graphics on Linux systems. Some other good graphics applications are as follows (all of which are available in the Ubuntu repositories unless otherwise noted) Blender An impressive 3D graphics modeling, rendering, and animation package that has been used to make various animated films, video and desktop computer games, and so on. Blender is also a great tool for architectural or similar wire-frame drawings. (www.blender.org) GNUPaint A simple, GNOME-based application for creating and editing graphics, GNUPaint has all of the attributes of xpaint (its ancestor), Microsoft...

Creating and inserting graphics

Writer also comes with a gallery of predefined graphics. To view the Gallery (shown in Figure 12-8), choose ToolsOGallery or click the Gallery icon (the rightmost icon on the Function bar). Select from the themes along the left side of the gallery. If you see a graphic you'd like to use, drag and drop it from the gallery to the location on the document where you want to insert it. Click the Gallery icon again to hide the graphics gallery. Drag and drop graphics from the gallery onto your document. Drag and drop graphics from the gallery onto your document.

Adding graphics and special effects

To jazz up your presentation, you might want to add graphics, charts, and other special effects to the slides. With Impress, you can do nearly everything you can think of all you have to decide is how many bells and whistles your presentation needs. It's your call, but I recommend using these features judiciously lest they detract from your presentation's main message.

Using Graphics Utilities in KDE

In this hour, you learn how to use the graphics utilities that come with KDE to view and create or edit bitmapped graphics. Several other graphics utilities for KDE are also mentioned in this hour. Some of these other utilities, however, are not included with a standard KDE distribution. You will need to download and install these utilities if you want to use them. Hour 21, Finding and Installing Additional KDE Applications, provides some additional direction on doing this.

Figure 92 Graphics layers across operating systems

Abstraction or glue layer it might be possible to write an application that directly interacts with the hardware via the driver interface. Also some applications such as a video player require an accelerated interface to bypass the graphics layer and interface with the driver directly. For such cases the graphics system provides special interfacing such as the famous Direct-X in Windows. Figure 9.2 compares layers across various operating systems.

Java AWTs Inefficient Graphics

Before the Java 2 Platform, Java relied heavily on the native capabilities of the host graphics platform. This engendered no shortage of problems (as discussed in Chapter 3, A Look at the Java Core Classes, in the section Package javax.swing ), but it at least had the effect of delegating the heavy lifting to reasonably well-tuned, optimized, native-code graphics and GUI libraries and window systems. With the advent of Java2D and Swing, Java has assumed a substantial portion of the graphics and GUI burden. Some of the results follow Much of the rendering formerly performed by the underlying window system is now performed on memory buffers by slower algorithms running in the JVM and then blitted (bit-for-bit copied) over the network to the display. This leads to higher computation, memory, and (for X environments) higher network costs for graphics. For some operations, like rendering of text, the slowdown is dramatic.

Creating and Modifying Graphics

The GIMP is a graphics program that's considered in many ways equivalent to Adobe Photoshop. Many don't consider The GIMP the friendliest program on the planet, but at the very least, it has enough features to keep you busy experimenting for weeks To open The GIMP I Knoppix From the main menu, choose GraphicsOGIMP Image Editor. I SuSE From the main menu, choose GraphicsOImage Editing. I Xandros Choose LaunchOApplicationsOGraphicsOGIMP Image Editor. When you start The GIMP for the first time, you have to walk through its user setup routine. Fortunately, you can just click Continue each time, unless you're a graphics guru who has a particular reason to want to do things in a different way. After you've clicked past all these dialog boxes, a collection of one or more dialog boxes pops up containing the GIMP main dialog box (see Figure 18-6) plus additional tool dialog boxes. I recommend closing all but the main one for now, just to keep your screen and brain uncluttered.

The Installer Tested My Graphics Fine but My GUI Wont Start

Each distribution has its own set of graphics configuration tools. If you boot your machine for the first time and see error messages when you're trying to enter the GUI automatically or when you type startx to start the GUI manually, use the following tools to fix the problem

Graphicsrelated commands

Convert the proprietary giff graphics into a raw. portable pnm file. Then convert the pnm into a png file. which is a newer and better standard for Internet pictures (better technically plus there is no danger of being sued by the owner of giff patents). (in X terminal) Capture the contents of X-windows screen into a graphics X-windows dump file (*.xwd). You can later convert the xwd file into your favourite format using the convert utility. Unde KDE. you can also use the keyboard shortcuts or to copy the current window or the entire desktop into the clipboard. Convert the X-windows screen dump file (*.xwd) into the *.jpg file format. The convert utility can convert graphics from to many different file formats.

Graphics Programming

Computer Graphics, Principles and Practice by James Foley, Andries van Dam, Steven Feiner, and John Hughes. Regarded by many as a classic in the field, this book covers an extremely broad range of topics relevant to 2D and 3D graphics programmers. Practically every important topic is covered, even if briefly. This book has a somewhat mathematical slant to it. Real-Time Rendering, by Tomas M ller and Eric Haines. This book contains numerous algorithms and concepts required for rendering high-quality graphics in real time. It is currently (March, 2001) one of the more up-to-date books in the field, and is a good collection of the most useful contemporary techniques. http www.graphicspapers.com. This site contains a very large searchable database of academic papers dealing with 3D graphics. http www.flipcode.com. This site offers many tutorials and columns relevant to programming real-time 3D graphics and games.

Overview of Digital Graphics Terminology

Even if you're not a graphics artist (and I certainly am not one), everyone with a Web site or a digital camera has some familiarity with digital graphics. Terminology-wise, digital graphics is basically nothing more than storing images in files on your computer, regardless of whether these files contain pictures from your summer vacation, fancy buttons or other images that you're using on your Web site, artwork and drawings that you've created using graphics software, pictures that you've used a scanner to capture, images captured directly from your computer screen, or just about anything else that you can store in a file and display in a graphics application. The following provides a quick glossary of graphics terms that you may encounter as you start to work with online, digital graphics Bitmap A graphical image that is composed of multiple picture elements, each representing one bit of that image. Each bit in a bitmap has its own color value, generally expressed as a combination...

Exploring Other KDE Graphics Utilities

Many graphics utilities are available for Linux and UNIX systems, including the venerable xv and the popular GIMP drawing program. These tools are generally included with any Linux product that you purchase. Hints for integrating these tools into your KDE environment are provided in Hour 22, Integrating Non-KDE Applications into KDE. Although the KDE-aware tools described in the first part of this hour are not as powerful as many other Linux graphics tools, many other useful tools are also available for KDE. Some of these tools are described in this section. Table 17.1 presents a list of some interesting and useful graphics-related programs available for KDE. These applications can be downloaded via a link on the Applications page of the KDE Web site (www.kde.org). Table 17.1 Additional Graphics-related Applications for KDE An icon editing program used to prepare standard KDE icons (in the default KDE format and size). Included with KDE choose Graphics, Icon Editor. A screen capture...

Converting Graphics to Text OCR

Scanners are fundamentally graphics devices their product is a bitmap graphics stream, which is easily displayed in an X window or saved in a graphics file. Sometimes, though, the purpose of scanning a document is to convert it to text in order to edit it in a word processor, load data into a spreadsheet, or otherwise manipulate it in a nongraphical way. To accomplish this goal, optical character recognition (OCR) programs exist. These programs accept a graphics file as input and generate a text file that corresponds to the characters in the input file. Essentially, the OCR package reads the characters out of the input file. This is an extremely challenging task for a computer program, though the software must overcome many obstacles, including streaks and blotches in the input file the varying sizes and appearance of characters in different fonts and the presence of nontextual information, such as embedded graphics. Therefore, OCR software tends to be imperfect, but it's often good...

Create Graphics with the GIMP

The GNU Image Manipulation Package, affectionately known as the GIMP to its friends, is a powerful graphics package. The GIMP provides a comprehensive range of functionality for creating different types of graphics. It includes tools for selections, drawing, creating paths, masks, filters, effects, and more. It also includes a range of templates for different types of media such as Web banners, different paper sizes, video frames, CD covers, floppy disk labels, and even toilet paper. Yes, toilet paper. You can load the GIMP by clicking Applications Graphics GIMP Image Editor. Start the GIMP by clicking Applications Graphics GIMP Image Editor.

Embedded Linux Graphics Driver

The first frame buffer driver was introduced in kernel version 2.1. The original frame buffer driver was devised to just provide a console to systems that lack video adapters with native text modes (such as the m68k). The driver provided means to emulate a character mode console on top of ordinary pixel-based display systems. Because of its simplistic design and easy-to-use interface, the frame buffer driver was finding inroads in graphics applications on all types of video cards. Many toolkits that were essentially written for traditional X window systems were ported to work on a frame buffer interface. Soon new windowing environments were written from scratch targeting this new graphics interface on Linux. Today, the kernel frame buffer driver is more of a video hardware abstraction layer that provides a generic device interface for graphics applications. Today almost all graphical applications on embedded Linux systems make use of the kernel frame buffer support for graphics...

Screen and Graphics Preferences

To open the Screen and Graphics Preferences tool, click System Administration Screens and Graphics, or in a GUI command line, enter the sudo displayconfig-gtk command. In the Screen And Graphics Preferences window shown in Figure 11-13, you can configure multiple monitors, if the hardware supports it. I see two screens in my version of this tool on my laptop, as it also includes an external video port. There are two tabs associated with this tool. The Screen tab configures monitors, and the Graphics Card tab configures the driver and video memory associated with the graphics card, which should be configured first. The Driver option under the Graphics Card tab opens a menu of available drivers, as shown in Figure 11-14. If you click the Choose Driver By Name drop-down box, it allows you to select from a list of available drivers. If in doubt, the VESA and VGA driver options are most likely to work. However, as they are generic drivers, they probably won't enable the features which make...

General Graphics Interface

The General Graphics Interface (GGI) provides an alternative to the older versions of the graphical interface X and SVGALIB. It can actually run under the other interfaces and still provide the higher graphic performance. You can find out more about GGI at www.ggi-project.org. One specific area where graphics has a large following is in the gamming arena.

Graphics Card Support

Debian's support for graphical interfaces is determined by the underlying support found in X.Org's X11 system. Most AGP, PCI and PCIe video cards work under X.Org. Details on supported graphics buses, cards, monitors, and pointing devices can be found at http xorg.freedesktop.org . Debian 5.0 ships with X.Org version 7.3.

Cataloging the Image and Graphics Applications

When I talk about images and graphics, I mean applications that are meant to work with photographs or other images and those that enable you to prepare vector drawings drawings consisting of lines and shapes for use in various types of documents. SUSE Linux includes a number of such image and graphics applications. You can find these applications in the Main MenuO Graphics menu. Table 4-4 summarizes the image and graphics applications in GNOME and KDE desktops. I describe these applications in detail in Chapter 15. Table 4-4 summarizes the image and graphics applications in GNOME and KDE desktops. I describe these applications in detail in Chapter 15. Typical Image and Graphics Applications Here's what the image and graphics applications enable you to do

Using the Screens and Graphics Utility

As we mentioned, if X.org fails to start based on the current graphical settings, the low-graphics mode of X.org will run with minimal display settings, as shown in Figure 6-1. In low-graphics mode, you have an option to launch the manual graphical configuration tool, the Screens and Graphics utility. Technically, this utility is made possible through the displayconfig-gtk package. The program can also be run while Ubuntu is up and running by opening a terminal window (Applications Accessories Terminal) and typing gksu displayconfig-gtk. This can be useful if your graphical subsystem works okay but not optimally and you wish to tweak the settings. Ubuntu is running in low-graphics mode bur screen and graphics card could not be detected correctly. To use higher resolutions, visual effects or multiple screens, you have to configure the display yourself. Always run in low-graphics mode Figure 6-1. X.org runs in low-graphics mode when the current graphical settings are not compatible with...

Copying Graphics Files

The theme instructions usually give explicit instructions for where to copy the graphics files that the theme includes. The Arctic theme instructions tell you exactly what to do The .xpm files that are placed in the kwm pics directory are graphics that define new buttons and borders. Some of the names from the listing should be recognizable to you These graphics replace the default KDE graphics for the user in whose home directory they are placed.

An Overview of the Screen and Graphics Card Settings

The Screens and Graphics utility allows you to configure the screen and graphics card settings. The Screen tab, shown in Figure 6-2, contains the following settings Screen arrangement You have options to set the primary monitor, mirror the displays, extend the area of the monitor to another monitor, or disable using the monitor altogether. These options are useful if you have multiple monitors and your graphics card can support them. Screen Graphics Card Screen Graphics Card The Graphics Card tab allows you to set the technical characteristics of your graphics card, such as the graphics card driver and its video memory, as shown in Figure 6-3. Though it's safe to leave the video memory for autodetection, if you encounter problems, you can set this information manually. You can determine the video memory size from the manual or from the graphics card information that pops up on your monitor when your computer starts up. Graphics Card Detected Screen Graphics Card j Graphics card (S3...

Using KView to View Graphics Files

You can start KView by choosing Graphics, Image Viewer, from the main menu, or by clicking on a graphics file in a kfm window. In addition, you can start KView from a command line. This is most useful if you want to review a set of graphics files. Use a command such as this one The supported graphics formats in KView include the following (additional formats are These formats should fill most of your graphics needs, as they include UNIX resource formats for icons, PC standards, Web standards, and even eps for viewing vector-based drawings saved in many popular design packages.

OpenGL is a Software Interface to Graphics Hardware

There are OpenGL software interface implementations for most 3D graphics cards, so OpenGL and Mesa will probably run efficiently on your computer unless you have a very old graphics card. Microsoft supports OpenGL on Windows 95, 98, and NT, so the programs that you develop under Linux using Mesa will probably run with few modifications under Windows. I worked at a computer animation company, Angel Studios (www.angel.com), where we used proprietary software for rendering real-time 3D graphics on a wide variety of hardware, including Nintendo Ultra-64, Windows, and SGI workstations. This proprietary software, as an option, used OpenGL to talk with graphics hardware.

Installing 3D Graphics Card Drivers

Virtually all graphics cards are automatically supported and configured within SUSE Linux. In most cases, you can stick with the default drivers installed by SUSE Linux. However, there are some instances where you might want to install the proprietary graphics drivers supplied by the manufacturers You want to use your graphics card's advanced 3D functionality, usually to play 3D games or run 3D modeling software. You want to use more than one monitor at the same time (a multiple monitor setup) using recent Nvidia or ATI graphics cards that feature dual-head outputs. The built-in graphics drivers don't function correctly. Sometimes the built-in graphics drivers don't use the full resolution of the monitor. For example, this is sometimes true of computers with widescreen displays. Installing proprietary graphics drivers requires that you download the driver software from the manufacturer's web site and then compile the driver module. This is largely automated but is nonetheless a...

Reconfigure your graphics card from the groundup

If Ubuntu just hasn't got it right when it comes to your graphics card and or monitor, you can configure things manually. To do so, open a terminal window and type gksu displayconfig-gtk. Settings relating to your monitor are located on the Screen tab, while you can change the graphics driver in use by selecting the Graphics Card tab. If you can't seem to get any driver to work, try clicking the Driver dropdown list, and then selecting VESA from the Choose Driver by Name dropdown list. VESA is a kind of failsafe driver that only uses the most primitive parts of a graphics card, and should allow you to get at least some kind of desktop visible, although performance will not be very good (video playback might stutter, for example).

Configuring Advanced Graphics Support

This set of options configures support for advanced video cards that can perform hardware-accelerated, 3D graphics. You can enable the first option to build the AGP (Accelerated Graphics Port) driver and can answer Yes to the option for your specific chipset. Next, you have to configure a set of options for the Direct Rendering Manager (DRM), a device-independent driver that supports the XFree86 Direct Rendering Infrastructure (DRI). DRI is meant for direct access to 3D graphics hardware in advanced graphics cards, such as 3Dfx Banshee and Voodoo3. To learn more about DRI, use your Web browser to visit http dri.freedesktop.org wiki . If you have a 3D graphics card, you can answer Yes to DRM and build the module for the graphics card in your system. If you do not have one of the listed graphics cards, you should answer No to these options.

Setting a Screen Background Image

In X, you can display a bitmap image, a solid color, or a graphics file as your screen background, depending on the program you use to accomplish this task. With complicated color images, you can soon fill up your colormap from the screen background image. This may lead to color flashing as X programs run out of colors in the default colormap and therefore create their own colormaps.

Graphics

Graphics programs POV-ray for Linux (a ray-tracing program). multimedia Multimedia and graphics programs ImageMagick (an image-processing package), gimp (an image-editing package), mpeg_play (plays MPEG animations under X or on the Linux console), pixmap (a pixmap xpm editor), xpcd (a PhotoCD viewer), and xpdf (a viewer for PDF files, also known as

Graphics Card

Dealing with a graphics card has been one of the most problematic areas of Linux or rather, of XFree86, which serves as the X Window System graphical interface to Linux. XFree86 deals directly with the graphics card and must know everything about the card in a configuration file (such as the amount of RAM it has, the chipset it features, and what modes it supports), putting more stress on you than the average software. Chapter 3 details how to configure XFree86, and in almost every respect this will be the most daunting task you will face as a budding Linux user.

Framebuffer Graphics

Any VESA2-compliant graphics adapter is capable of providing framebuffer graphics. Framebuffer graphics provide an abstraction layer for the graphics hardware in your computer system and provide an easy way for X to interact with and control your graphics hardware. If nothing else works, this is your best chance of getting graphics configured, but may not take advantage of any specialized features of your hardware. If you need to use framebuffer graphics, you can specify a graphical resolution at boot time through a boot parameter, such as vga 7 9l, which sets the resolution to 1,024 x 768 at 16-bit color depth (a common and reasonably safe option). Having booted with this boot parameter, you can then run sax2 and force the graphics mode to be framebuffer by using the command line When you are sure that the configuration works, you can set the vga parameter in the file boot grub menu.lst so that it will take effect at the next boot. You should make this change in the default...

Graphics and Images

The applications in this category enable you to work with images, graphics (line drawings and shapes), and sound. Chapter 5 describes the CD players you can use to play audio CDs on your Linux system. The following applications, summarized in this chapter, enable you to prepare, view, modify, and print graphics and images

GNOME Graphics Tools

Inkscape is a Gnome based vector graphics application for SVG (scalable vector graphics) images with features and capabilities similar to professional level vector graphics applications like Adobe Illustrator. The SVG format allows easy generation of images for Web use, as well as complex art. Though its native format is SVG, it can also export to PNG format. It features layers and easy object creation, including stars and spirals. A color bar lets you quickly change color fills.

Graphics Tools

GNOME, KDE, and the X Window System support an impressive number of graphics tools, including image viewers, window grabbers, image editors, and paint tools. On the KDE and GNOME desktops, these tools can be found under a Graphics submenu on the Utilities menu. Phoronix site for the latest news and reviews of hardware compatibility, including graphics cards

Inserting Graphics

Graphics can be inserted with the same vertical pop-up toolbar as tables, only you need to select its second button. Alternatively, select 'Insert' - 'Graphics' - 'From File. . . '. This opens a dialog window in which to select the desired file. If you check 'Preview', the selected image is displayed in the right part of the dialog. Such a preview may take some time in the case age has little square handles on its edges. Then select 'Graphics. . . ' from the context menu to open a dialog in which to change various image settings, such as the wrap type and border style. q

Graphics Features

Generating realistic 3D graphics particularly in real-time, as needed for 3D games requires enormous computational effort. Characteristics that must be computed include a 2D image based on the 3D object, shadows, lighting effects, texture effects, reflections, transparency effects, and haze or fog effects. Most video cards sold today support at least minimal 3D operations. If you have an older card that doesn't support 3D features, and if you want these features, you can either replace the video card with a new one or add an expansion card. Most video cards manufactured in the past decade include an expansion connector (shown in Figure 12.1). You can attach a dedicated 3D graphics card to this connector. The dedicated card then handles 3D functionality, leaving normal 2D operations to the original card.

Graphics Formats

There are two main formats for graphics pixel and vector. The GIMP works only with pixel graphics, which is the normal format for photographs and scanned images. Pixel graphics consist of small blocks of color that together create the entire image. The files can easily become quite large because of this. It is also not possible to increase the size of a pixel image without losing quality. Unlike pixel graphics, vector graphics do not store information for all individual pixels. Instead, they store information about how image points, lines, or areas are grouped together. Vector images can also be scaled very easily. The drawing application of OpenOffice.org, for example, uses this format.

Graphics and Imaging

You can use graphics and imaging applications to work with images and graphics (line drawings and shapes). I discuss two applications The GIMP (GNU Image Manipulation Program) is an image-manipulation program written by Peter Mattis and Spencer Kimball and released under the GNU General Public License (GPL). It is installed if you select the Graphics Manipulation package when you install Fedora Core from this book's companion DVD-ROM. The GIMP is comparable to other image-manipulation programs, such as Adobe Photoshop and Corel Photopaint.

Graphics Programs

The ability to use graphics is increasing in importance in business. All the office suites have a varying ability to manipulate graphics, but sometimes you need to do more. Stand-alone graphics programs come it two types photo editors and drawing programs. Photo editors allow you to manipulate photographs and images. These programs imitate many of the tools familiar to artists, including a paintbrush, pen, and airbrush. The most popular of these programs is Adobe Photoshop. The open source program Gnu Image Manipulation Program (GIMP) provides the same functions for Linux. GIMP is every bit as powerful as Photoshop, although its interface is not quite as intuitive. GIMP is included in most Linux distributions and both Linux and Windows versions can also be downloaded from http www.gimp.org. 6.12.1 Graphics Conversion GIMP, Corel Draw, Photoshop, and most other graphics programs can open and convert many different file formats. Sometimes, though, you run into a graphics file that your...

Embedded Graphics

One might have various questions regarding graphics support on embedded Linux. What comprises a graphics system How does it work Can I use Linux desktop graphics on embedded systems as is What are the choices available for graphics on embedded Linux systems Is there a generic solution that can address the entire range of embedded devices requiring graphics (i.e., mobile phone to DVD player)

Rendering graphics

The preferred form of rendering graphics from an XView application is to use Xlib graphics calls. Volume One, Xlib Programming Manual, has a complete discussion of Xlib graphics programming. Throughout this book, you will find examples of drawing into canvases using Xlib graphics routines. Appendix F, Example Programs, has several longer programs that demonstrate Xlib graphics. The XView graphics model, which is available, is almost identical to the SunView model for graphics and is provided for backwards compatibility with SunView. Because XView graphics calls are wrappers to the underlying Xlib calls, these functions are not recommended for graphics-intensive applications or for use by programmers who are not already familiar with SunView.

Creating Graphics

I created the Penguin Warrior spaceship model in the shareware AC3D modeller (http www.ac3d.org)3 and rendered it at various angles in the free POV-Ray 3.1 raytracer (http www.povray.org). I drew the starry background in The GIMP. Though these aren't professional-quality graphics, they serve their intended purpose, and I had fun creating them. After creating the ship model in AC3D, I exported it to POV-Ray, manually tweaked the camera position in the .pov file, and added a clock variable to allow it to be automatically rotated. I wrote a script to automatically render 96x96 images of the model in 4-degree rotation increments (thereby saving the tedious work of rotating the model by hand). The entire rendering process took only a few minutes on a fast laptop. Finally, I used the free ImageMagick package to assemble the individual ship images into one long strip, saved as a bitmap file. I developed this particular procedure throughout several of my own projects, but there are other ways...

Organization of the Book and the Code

Seen pedagogically, a bottom-up approach means first covering fundamental concepts before proceeding to more complex subjects. This is a fully natural progression which deals with computer graphics at ever-increasing levels of abstraction. Seen practically, a bottom-up approach means that simple C++ classes are developed first, with later, more complicated examples literally building upon the foundation developed earlier through the object-oriented mechanism of inheritance. This ensures compilable, executable code at each level of abstraction which is incrementally understandable and extensible. Every chapter has complete, executable sample programs illustrating the concepts presented. The bottom-up organization has a rather far-reaching impact on the structure of the code in general. The principal goal I had in mind when structuring the code for the book was that all parts of a class presented in a chapter should be explained within that same chapter. I tried very diligently to...

Reader and System Requirements

This book requires you to have a working Linux installation up and running with the XFree86 server for the X Window System on an IBM PC or compatible system with a Pentium or better processor. If you don't yet have Linux installed, you can download Linux for free from the Internet, or obtain a CD-ROM containing a ready-to-install Linux distribution. Installing Linux is no more difficult than installing other common PC operating systems, such as Microsoft Windows. A 3D graphics card with Mesa drivers is recommended for optimum performance, but the code will run acceptably fast without hardware acceleration through a custom software renderer. If your graphics card is supported by the new XFree86 4.0 Direct Rendering Infrastructure or by the Utah GLX project, you can also link the code with the appropriate OpenGL library (from the DRI or from Utah GLX) to achieve hardware-accelerated rendering in a window.

Step 2 Declare a Pipeline Subclass

The second step in writing an l3d application is to declare a pipeline subclass. A pipeline is simply a sequence of operations on data. The main loop in a game or graphics program is typically called the pipeline. Therefore, the pipeline contains, directly or indirectly, your application's main data and functionality. The first responsibility of an l3d_pipeline subclass is easy to understand. The pipeline represents the application. The application should display interactive graphics on the screen. We therefore create and store a screen object, representing the output device, and a rasterizer implementation, representing a strategy for drawing graphics to the screen. The rasterizer itself presents a high-level interface to rasterization functionality, implemented by the low-level tools offered by a rasterizer implementation. Again, remember that a rasterizer implementation can be either a software rasterizer implementation, directly manipulating bytes in an off-screen frame buffer, or...

Summary of Fundamental l3d Concepts

The five-step process presented above is typical of l3d programs. First, you choose the proper factories to configure the program to its environment. Then, you declare a pipeline representing your application and its data. You create an instance of the pipeline, which in turn creates screen, rasterizer implementation, and rasterizer objects. You plug this pipeline into an event dispatcher. Your application pipeline responds to events from the dispatcher by filling in the blanks left by the virtual functions key_event, update_event, and draw_event. The application pipeline draws to the screen by using the screen, rasterizer implementation, and rasterizer objects it created within its constructor. This forms a complete, interactive, event-driven, hardware-independent graphics program.

Mathematical Models for Computing Light

The lighting models presented in the next few sections attempt to approximate the effects of light by computing the amount of light we see from a surface. Note that these lighting models do not necessarily represent a realistic modeling of the physical phenomena underlying the emission and reflection of light, but nevertheless provide adequate results in practice and are widely used in interactive 3D graphics.

The World Database Revisited

The l3d_world class, as presented thus far (see Chapter 1 and the introductory companion book Linux 3D Graphics Programming), uses a very simple world database merely a list of l3d_ object objects, traversed sequentially. As the number of objects grows, sequentially traversing the world database takes more and more time. TIP Notice that both the original simple world database (a list of objects) and the BSP's database (a binary tree of polygons) are both fundamental data structures from the field of computer science. There are many other data structures queues, hash tables, directed acyclic graphs, and so forth. All of these can be used within the context of interactive 3D graphics applications to create more efficient data structures for managing larger world databases. While most data structures books deal (and necessarily so) with operations on simple objects such as words, letters, numbers, or database records, the same principles can be applied with great success to storing and...

BSP Trees and Dimension Independence

One last comment on BSP trees is that the concept can be applied to any dimensional space. The examples we looked at were 3D examples, where we used 2D splitting planes to divide 3D space. In general, for an n dimensional space, we use objects of dimension n-1 to divide the space into two pieces. The n-1 dimensional objects are referred to as hyperplanes. In 2D, for instance, we deal with 2D line segments and polygons, and split 2D space by 1D lines. (The game Doom used a 2D BSP tree.) In 1D, we deal with intervals, and split 1D space by 0D points. BSP trees can also be extended to dimensions greater than 3D, but 3D graphics, not 4D graphics, is the topic of this book.

Porting the Code to Microsoft Windows

The l3d code has been designed so that it can be easily ported to other operating systems, such as Microsoft Windows. With a few exceptions, the sample programs in this book compile and run under Windows. However, support for Windows has not been a primary concern for l3d, since it was written to illustrate graphics programming under Linux, and since I have neither installed nor need any Microsoft products whatsoever on my main computer. Under the (not necessarily true) assumption that Microsoft and Windows continue to maintain some short-term market relevance, it might be interesting for you to make your programs available under Microsoft Windows as well. By default, the Windows code is compiled with both a software renderer and an OpenGL-based renderer. This means that you should have OpenGL and the GLUT libraries installed on your system. OpenGL libraries should come standard with the operating system, and are also distributed as specialized drivers with any modern 3D graphics...

Class l3drasterizer2dswlighterimp

Let's briefly discuss why we need to artificially increase the size of the polygon for light map rasterization purposes. The reason for this goes all the way back to a discussion in the introductory companion book Linux 3D Graphics Programming, when we first developed the rationale for our rasterization strategy. There, we said that it was of primary importance to plot every pixel once and only once, so that the polygons all lined up on the edges. We used the rule that only pixels whose upper left corner was in the polygon were drawn. The problem is that using this same strategy here often leads to unsightly dark holes or dark strips in the light map, because certain lumels exactly on the edge of the polygon do not get rasterized and thus remain dark. When computing a light map, we should ideally compute a light intensity for every lumel of which any part not just the upper-left corner touches the polygon. Then, depending on how much of the lumel lies within the polygon, we would...

The l3d Library Classes

This book relies on the use of a series of C++ library classes implementing all of the 2D and 3D graphics concepts described in the previous sections. This library is called the l3d library. It is developed incrementally in the introductory companion book, Linux 3D Graphics Programming. In this book, we use the classes presented in the first book, and continue to build on these classes to illustrate newer and more advanced concepts. The l3d classes are on the CD-ROM and are also available for download from the Internet at

Portals and the Near Z Plane

Clipping polygons against the near z plane is a necessity, as discussed in the introductory companion book Linux 3D Graphics Programming. However, it causes problems with portals. In particular, as we are approaching a portal, right as soon as we are about to cross it to move into the adjoining cell, the portal gets briefly but completely clipped away by the near z plane. This causes

Mesa OpenGL 3D Rasterizer Implementation l3drasterizer3dmesaimp

Mesa can also draw texture mapped polygons for us. For a computer without hardware acceleration, there is no speed benefit to be gained by using Mesa instead of a custom software texture mapper, because Mesa must do exactly the same math. The picture looks quite different, though, with a 3D graphics card. In this case, Mesa simply forwards the request to draw a texture mapped polygon on to the hardware, which then draws the polygon at speeds impossible to achieve via software alone. Therefore, let's now take a look at a Mesa OpenGL 3D rasterizer implementation. As usual, the rasterizer implementation is chosen via a factory at the program start, and is plugged into the rasterizer interface. Application code need not be modified to use either software or hardware rasterizers. Listing 2-12 ras3_mes.h Like the software 3D rasterizer, the Mesa 3D rasterizer also overrides the routines set_text_color and draw_text to draw text into the rasterizer buffer, although here we must use OpenGL...

The Five Step Process of l3d Programs

Let's examine each step in detail to understand the general l3d structure within the context of the sample drawdot program. This serves two goals first, to understand the general l3d structure, and second, to understand the specific functions called by drawdot in order to draw to the screen. Then, we will take a look at the l3d classes themselves, which we build upon throughout the book to incorporate increasingly advanced and reusable 3D graphics concepts.

Classes for Loading Textures from Disk

The l3d classes for loading textures support the portable pixmap (PPM) file format developed by Jef Poskanzer. Converters exist (under Linux and other operating systems) which convert most graphics formats to and from PPM format, and the better bitmap graphics programs also directly support loading and saving PPM files.

Hardware Acceleration

There are two ways for you to use hardware acceleration. The first way requires a 3DFX graphics card, the Glide library, and a Mesa distribution compiled with Glide support. This means that you need to manually install Glide and compile Mesa see the Mesa documentation for more information. There are many versions of the Glide library, for different generations of 3DFX hardware. I have included two versions of Glide on the CD-ROM, which should work with Voodoo and Voodoo3 cards. If you have a different 3DFX card, check out the web site http linux.3dfx.com to download the proper version of Glide for yourself. After installing Glide and compiling Mesa to use Glide, you must edit the file L3D Makefile.vars to point to the correct directories. Variable GLIDEDIR should point to the directory containing the Glide library MESAINCLUDEDIR should point to the directory containing the include files used to compile Mesa and MESALIBDIR should point to the directory containing the new, 3DFX-enabled...

Rendering and LOD Techniques for Landscapes

Finally, it is also worth mentioning that for small landscapes with relatively few polygons, and fast enough graphics acceleration hardware, it is sometimes possible to completely ignore LOD issues and simply render all triangles within the landscape for every frame. This could conceivably be used in a mixed indoor outdoor engine, where the outdoor parts of the world are isolated small landscapes. The isolated small landscapes could then be rendered in their entirety. If we combine this with a portal scheme and place the landscape areas in their own sectors, the landscape regions do not degrade rendering performance when they are completely blocked by intervening walls of an indoor region.

Sample Program particle

With the preceding explanation, understanding the source code listing for the sample program particle should be easy. The structure of this program is based on that of the dots program presented in the introductory companion book Linux 3D Graphics Programming (and included on the CD-ROM). We have mercilessly slashed out the code for the runway lights, stars, and snow examples, and focused the program on the particle system simulation. The abstract class mydot has been extended to include a member variable lifetime, indicating how much longer this dot has to live, in seconds, and a method is_alive, returning if the dot is still alive or not. Chapter 7 Additional Graphics Techniques 491

Fixed and Floating Point Math

In 3D graphics, we generally need to be able to store and manipulate fractional values. For this, we introduce the type l3d_real. The purpose of the l3d_real type is to allow all computations using real values to be performed using either floating-point or fixed-point arithmetic. Floating-point arithmetic is done by using the C type float, and for good real-time performance requires a hardware floating-point unit. Fixed-point arithmetic requires no floating-point unit in hardware, and simulates fractional values with integers by multiplying the fractional value so that the fractional part moves into the integer part. 30 Chapter 1 Basic Linux 3D Graphics Concepts D, NOTE The reasons for not making l3d_real a class are discussed in the Appendix of the introductory companion book, Linux 3D Graphics Programming.

Summary of l3d Classes

Figure 1-11 illustrates the major l3d classes covered up to this point. Study the previously presented drawdot program to keep a practical perspective on the use of the l3d classes, and remember the five-step process for creating l3d applications. Also, remember that the CD-ROM contains complete source code listings for all of these classes, and the introductory companion book Linux 3D Graphics Programming develops the classes in detail, with several example programs. TIP See the source code for the sample program fltsim on the CD-ROM (taken from the introductory companion book Linux 3D Graphics Programming) for a typical example of creating an animated world populated with polygonal objects and a user-controllable camera.

Vertex Animation and 3D Morphing

The program morph2d from the companion book Linux 3D Graphics Programming already explained and illustrated the concept of morphing in 2D. As we used the term earlier, morphing referred to the change in shape of a polygon by interpolating the vertices in its vertex list between certain key frames or morph targets.

Radiosity and Ray Tracing

As realistic as radiosity is, it is slow to compute. Therefore, its role in interactive 3D graphics is more of a preprocessing step. Radiosity can be used in an offline manner to compute light levels, which are then saved along with the 3D geometry. Then, at run time, we simply draw the light using the precomputed light levels.

Overview of l3d Classes

We are now ready to look at the specific l3d classes. A much more detailed development of the following l3d classes appears in the introductory companion book Linux 3D Graphics Programming. The descriptions below are more of a reference, but suffice for a high-level understanding of the structure of the library classes.

Summary

This chapter flew through the basics of Linux 3D graphics programming, as covered in depth in the introductory companion book Linux 3D Graphics Programming. We looked at 2D graphics, theory, and practice under Linux and X Definition of 3D graphics l3d library classes in C++ for implementing event-driven, object-oriented 3D graphics With the basics of polygonal 3D graphics now firmly in mind, we can proceed to the next chapter, which discusses rendering and animation techniques for 3D polygons.

Light Maps

The most difficult part of light mapping is the determination, during the rasterization of a particular polygon, of which lumel in the light map corresponds to the current pixel on-screen which we are drawing. When rasterizing a polygon, we know that all pixels we draw do correspond to (i.e., result from the perspective projection of) some point on the polygon and thus to some point in the light map, but we do not immediately know which point exactly. If you have a super-human memory, you may recall that we briefly mentioned this problem in passing in the introductory companion book Linux 3D Graphics Programming. To summarize, it is not exactly easy or intuitive to calculate which lumel on the polygon corresponds to the current pixel of the polygon being drawn, but it is possible, as we will see in grueling detail in the next section. This calculation is actually one particular application of the technique called texture mapping, which allows us to associate arbitrary images with a...

Advanced Techniques

In this section, we take a look at some graphical techniques which use interesting algorithms to create complicated or visually interesting graphics. The advanced techniques of this section differ from the special effects of the previous section in that the special effect techniques generally relied upon a fairly simple idea, with the goal of generating a visually interesting result. On the other hand, the advanced techniques in this section generally have somewhat more complex algorithms, and often have a goal other than just a visual glamour. They can represent an entirely different or new way of handling some fundamental aspect of 3D graphics.

Nvironment

We've almost reached the end of this book. Until now, the content of this book has, not surprisingly, focused on the graphics techniques necessary for creating visually appealing and realistic 3D applications. But in such 3D applications, often visual quality is not the only important factor. 3D applications are often simulations of reality, such as games, virtual reality, and so forth. In such programs, the overall effect of the application is a combination of visual and other cues provided by the program. This chapter is devoted to these other cues. By devoting some attention to these other issues, we can produce 3D programs that not only look but also sound and act realistically.

Physics

By providing us with mathematical models of the way the real world behaves, the field of physics allows 3D graphics programs to simulate not only the visual appearance, but also the static and dynamic properties of the real world. This can create very engaging and interesting 3D programs, because they look and act natural in subtle ways.

The Future

Chaos theory tells us that, in the long run, we can never predict anything about the future with any accuracy. Nevertheless, that never stopped anyone from trying, myself included. What follows are some speculations about possible future trends in the field of interactive 3D graphics, under Linux and in general. large worlds in the first place. Some pseudorandom techniques can be used to deterministically generate huge amounts of data automatically, such as landscapes. Data for real-world locations can also be generated automatically from satellite and photographic information. As the demand for larger worlds grows, so will the need for such automated algorithms. Networking large virtual worlds is also an interesting issue. There is still no universally accepted standard for transmitting 3D content over the WWW, nor for networking various participants into collective virtual worlds. We can expect to see much work done in the network sector, since networking has the potential to make...

Perspective

It is only appropriate that a book on 3D graphics ends with a section entitled Perspective. Indeed, perspective is the one common thread running through all areas of 3D graphics. It is the compelling visual cue which creates the illusion of depth it is the single most important formula in 3D graphics it is the visual and geometric phenomenon which causes the non-linearity of z in screen space. Now, let's try to put the contents of this book into perspective, in the broader field of 3D graphics as a whole. We can broadly classify 3D graphics into a spectrum with three categories high-end graphics, real-time graphics, and network graphics. This book focused on real-time 3D graphics under Linux we looked at the techniques and tools needed to produce interactive 3D programs with acceptable visual quality and interactive frame rates. This is the middle of the spectrum. High-end graphics is at the high end of the spectrum. It typically involves algorithms which produce extremely...

Modeling

This practice-oriented book explains basic principles of 3D imagery and illustrates which 3D graphics techniques to use in order to create effective presentations. Drawing on the Right Side of the Brain by Betty Edwards. This book deals with developing the visual skills to become a good 2D artist. While it doesn't directly deal with computer graphics, the visual skills you can learn from this book are very effective for all types of visual expression, including 3D modeling. Keys to Drawing by Bert Dodson. This book, too, does not deal directly with computer graphics, but offers a number of useful tips or keys to creating effective 2D art.

Goals of This Text

Analyze and use other 3D graphics texts and programs. In the open source world of Linux, understanding fundamental concepts is indeed important so that you can understand and possibly contribute to the common pool of knowledge and code. Furthermore, learning fundamental 3D graphics concepts also enables you to understand and effectively use sophisticated 3D applications and libraries such as 3D modelers and OpenGL. A second goal of this text is to give you plenty of hands-on experience programming 3D graphics applications under Linux. It is one thing to understand the theoretical mechanics of an algorithm it is another to actually implement, debug, and optimize that same algorithm using a particular set of programming tools. Small standalone programs are scattered throughout this text to demonstrate key 3D graphics concepts. It is often easy to lose sight of the forest for the trees, particularly in the complicated world of 3D graphics. Standalone sample programs address this problem...

Eneral Technique

We have seen many facets of Linux 3D graphics programming operating system issues, the X Window System, 2D graphics, 3D geometry and mathematics, classes for orga-T y nizing 3D world data, 3D modeling and texturing, import and export of polygonal models, and animation. Starting with this chapter, we begin to put all of this information together, to create larger, interactive 3D environments. In this and the coming chapters we'll look at techniques for handling larger datasets, tools for creating these datasets, and some miscellaneous topics which make for a more realistic and enjoyable 3D experience (collision detection, sound, and basic networking).

Collision Detection

The topic of collision detection is a non-graphical technique which nonetheless is very important for 3D graphics applications. Collision detection refers to the determination of whether two objects in the 3D virtual world overlap, or not. Collision detection generally also requires some sort of collision response if we detect a collision, such as moving the objects apart again. Collision detection algorithms are important for 3D graphics applications for two reasons They illustrate useful geometric intersection techniques which are often also needed for visual 3D graphics algorithms, such as ray tracing or shadow computation.

Back Face Culling

One of the simplest VSD algorithms is the back-face culling algorithm. This algorithm mainly addresses the efficiency issue of VSD. In 3D graphics, to cull an object means to remove it from further consideration. Thus, back-face culling refers to the removal from further consideration of faces (polygons) which are back-facing. Let's explore this idea more closely.

Curved Surfaces

The focus of this book has been on polygonal 3D graphics. We stored our models as polygons, and rendered these polygons to the screen. To render a patch as polygons, we can evaluate successive rows on the patch. For instance, we would keep v constant, say 0.0, then evaluatefu,v) for u from 0.0 to 1.0 in any chosen interval, say ten steps. Then we increase v slightly, for instance to 0.1, and evaluatefu,v) again for u from 0.0 to 1.0. This gives us two rows of vertices. By connecting the vertices in a zig-zag fashion, we create a series of triangles, which can then be rendered as polygons. A series of triangles connected in this way is called a triangle strip. Some graphics acceleration hardware can draw triangle strips faster than drawing individual polygons, because in the interior of the strip, a single new vertex defines a new triangle the other two vertices are reused from the previous triangle in the strip. Blender supports modeling using NURBS surfaces and subdivision surfaces,...

Multipass Techniques

The recent increase in availability of graphics acceleration hardware has made it feasible to implement multi-pass rendering algorithms. Multi-pass algorithms render the same scene multiple times, combining the results of each rendering into the final 2D image which gets displayed on-screen. This, of course, implies increased rendering work. There are two main reasons for multi-pass rendering either it is the most natural solution to a problem, or the presence of hardware acceleration makes it the fastest solution to a problem. OpenGL 1.3 supports multi-texturing, where the graphics API itself (and possibly also the hardware) allows for the simultaneous specification of multiple texture coordinates for one set of geometry. Then, in the presence of appropriate multi-texturing hardware, the scene is rendered with multiple textures, but in the time it takes to render just one pass.

Linux 3D Modeling

The introductory companion book Linux 3D Graphics Programming covered basic usage ofthe Blender 3D modeling package for creating 3D models. We continue the coverage in this book. Blender is zero-cost software a fully functional version of Blender, with no artificially imposed restrictions, is included on the CD-ROM.

Texture Mapping

As recently as the mid-1990s, an interactive 3D graphics application with texture mapping was quite a sensation for personal computers. Today, end users expect texture mapping even in simple 3D graphics applications. Therefore, it is important to understand this technique.

Camera Tracking

Another advanced technique useful for interactive 3D graphics applications is camera tracking. By camera tracking, we mean that the camera should always follow a particular subject. This is particularly useful for third-person games, where the player controls the movement of a character throughout the virtual world. The world is seen not through the character's eyes, but instead from the viewpoint of an external camera following the movement of the character. In such an application, it is important that the camera always keep the target in sight.

What Is So Good About Linux

Another aspect of Linux that appeals to users is the amazing range of peripherals that is supported and the speed with which support for new peripherals emerges. Linux often supports a peripheral or interface card before any company does. Unfortunately some types of peripheralsparticularly proprietary graphics cardslag in their support because the manufacturers do not release specifications or source code for drivers in a timely manner, if at all.

Ubuntu and Kubuntu for System Administrators

Anyone who sets up their computer to connect to the network, enable users to log in, and so on is an official junior system administrator as far as I'm concerned. This part explains how to do all of the system administration tasks that any home user will want to do, but also explores all of the system administration tasks that you or any other administrator will need to do when using Ubuntu or Kubuntu in a business setting. Chapter 22 begins by explaining what happens when your Ubuntu or Kubuntu boots or is shut down, and how you can monitor and expedite the boot process. Chapter 23 tells you how to keep your system up-to-date and how to locate and install new software, while Chapter 24 explains how to add new hardware to your Ubuntu system if you run out of space, need faster graphics, or need anything that causes you to upgrade your machine. Chapter 25 discusses network security and how to protect yourself from crackers and other local or Internet vandals. Chapter 26 explains how to...

About the Course and Objectives

Ubuntu is a community developed Linux-based operating system freely available and suitable for laptops, desktops and servers. This course is based on Ubuntu 7.10 and aims to train new users of Ubuntu how to use key applications including mainstream office applications, Internet connectivity and browsing, graphics arts tools, multi-media and music. After completing this course, you will

Why Teach Yourself KDE

If you're an experienced Linux user, this book can provide insight into how the KDE Project is organized. The directory structure and principles behind KDE are explained as example applications are demonstrated. You will learn how KDE accesses applications, where you can place graphics, and how you can hand-edit or explore configuration files to get the most out of KDE.