book

OpenGL® SuperBible, Third Edition

by Richard S. Wright, Benjamin Lipchak

June 2004

Intermediate to advanced

1200 pages

24h 40m

English

Sams

Read now

Unlock full access

Copyright
Dedication
About the Authors
Acknowledgments
We Want to Hear from You!
Introduction
What's in This BookPart I: Classic OpenGLPart II: OpenGL EverywherePart III: OpenGL: The Next GenerationConventions Used in This BookAbout the Companion CDBuilding the Sample ProgramsDare to Dream in 3D!
I. Classic OpenGL
1. Introduction to 3D Graphics and OpenGL
What's This All About?A Brief History of Computer GraphicsEnter the CRTGoing 3D2D + Perspective = 3D3D ArtifactsA Survey of 3D EffectsPerspectiveColor and ShadingLight and ShadowsTexture MappingFogBlending and TransparencyAntialiasingCommon Uses for 3D GraphicsReal-Time 3DNon–Real-Time 3DBasic 3D Programming PrinciplesImmediate Mode and Retained Mode (Scene Graphs)Coordinate Systems2D Cartesian CoordinatesCoordinate ClippingViewports: Mapping Drawing Coordinates to Window CoordinatesThe Vertex–A Position in Space3D Cartesian CoordinatesProjections: Getting 3D to 2DOrthographic ProjectionsPerspective ProjectionsSummary
2. Using OpenGL
What Is OpenGL?Evolution of a StandardThe OpenGL ARBLicensing and ConformanceThe API WarsEnter DirectXOpenGL Comes to the PCOpenGL for Games?Direct3D's Head StartDirty PoolThe Future of OpenGLHow Does OpenGL Work?Generic ImplementationsHardware ImplementationsThe PipelineOpenGL: An API, Not a LanguageLibraries and HeadersAPI SpecificsData TypesFunction-Naming ConventionsPlatform IndependenceUsing GLUTSetting Up Your Programming EnvironmentYour First ProgramThe HeaderThe BodyDisplay Mode: Single BufferedCreating the OpenGL WindowDisplaying CallbackSet Up the Context and Go!OpenGL Graphics CallsClearing the Color BufferFlushing That QueueDrawing Shapes with OpenGLDrawing a RectangleScaling to the WindowSetting the Viewport and Clipping VolumeDefining the ViewportDefining the Clipped Viewing VolumeKeeping a Square SquareAnimation with OpenGL and GLUTDouble-BufferingThe OpenGL State MachineSaving and Restoring StatesOpenGL ErrorsWhen Bad Things Happen to Good CodeIdentifying the VersionGetting a Clue with glHintUsing ExtensionsChecking for an ExtensionWho's Extension Is This?Getting to OpenGL Beyond 1.1 on WindowsSummaryReference
3. Drawing in Space: Geometric Primitives and Buffers
Drawing Points in 3DSetting Up a 3D CanvasA 3D Point: The VertexDraw Something!Drawing PointsOur First ExampleSetting the Point SizeDrawing Lines in 3DLine Strips and LoopsApproximating Curves with Straight LinesSetting the Line WidthLine StipplingDrawing Triangles in 3DTriangles: Your First PolygonWindingTriangle StripsTriangle FansBuilding Solid ObjectsSetting Polygon ColorsHidden Surface RemovalCulling: Hiding Surfaces for PerformancePolygon ModesOther PrimitivesFour-Sided Polygons: QuadsQuad StripsGeneral PolygonsFilling Polygons, or Stippling RevisitedPolygon Construction RulesSubdivision and EdgesOther Buffer TricksUsing Buffer TargetsManipulating the Depth BufferCutting It Out with ScissorsUsing the Stencil BufferCreating the Stencil PatternSummaryReference
4. Geometric Transformations: The Pipeline
Is This the Dreaded Math Chapter?Understanding TransformationsEye CoordinatesViewing TransformationsModeling TransformationsThe Modelview DualityProjection TransformationsViewport TransformationsThe Matrix: Mathematical Currency for 3D GraphicsWhat Is a Matrix?The Transformation PipelineThe Modelview MatrixTranslationRotationScalingThe Identity MatrixThe Matrix StacksA Nuclear ExampleUsing ProjectionsOrthographic ProjectionsPerspective ProjectionsA Far-Out ExampleAdvanced Matrix ManipulationLoading a MatrixPerforming Your Own TransformationsAdding Transformations TogetherMoving Around in OpenGL Using Cameras and ActorsAn Actor FrameEuler Angles: “Use the Frame, Luke!”Camera ManagementBringing It All TogetherSummaryReference

5. Color, Materials, and Lighting: The Basics
What Is Color?Light as a WaveLight as a ParticleYour Personal Photon DetectorThe Computer as a Photon GeneratorPC Color HardwarePC Display ModesScreen ResolutionColor DepthThe 4-Bit Color ModeThe 8-Bit Color ModeThe 24-Bit Color ModeThe 16- and 32-Bit Color ModesUsing Color in OpenGLThe Color CubeSetting the Drawing ColorShadingSetting the Shading ModelColor in the Real WorldAmbient LightDiffuse LightSpecular LightPutting It All TogetherMaterials in the Real WorldMaterial PropertiesAdding Light to MaterialsCalculating Ambient Light EffectsDiffuse and Specular EffectsAdding Light to a SceneEnabling the LightingSetting Up the Lighting ModelSetting Material PropertiesUsing a Light SourceWhich Way Is Up?Surface NormalsSpecifying a NormalUnit NormalsFinding a NormalSetting Up a SourceSetting the Material PropertiesSpecifying the PolygonsLighting EffectsSpecular HighlightsSpecular LightSpecular ReflectanceSpecular ExponentNormal AveragingPutting It All TogetherCreating a SpotlightDrawing a SpotlightShadowsWhat Is a Shadow?Squish CodeA Shadow ExampleSphere World RevisitedSummaryReference
6. More on Colors and Materials
BlendingCombining ColorsChanging the Blending EquationAntialiasingMultisampleFogAccumulation BufferOther Color OperationsColor MaskingColor Logical OperationsAlpha TestingDitheringSummaryReference
7. Imaging with OpenGL
BitmapsA Bitmapped SampleSetting the Raster PositionDrawing the BitmapPixel PackingPixmapsPacked Pixel FormatsA More Colorful ExampleMoving Pixels AroundSaving PixelsMore Fun with PixelsPixel ZoomPixel TransferPixel MappingThe Imaging “Subset”Imaging PipelineColor MatrixColor LookupProxiesOther OperationsConvolutionsFrom the Color BufferSeparable FiltersOne-Dimensional KernelsOther Convolution TweaksHistogramMinMax OperationsSummaryReference
8. Texture Mapping: The Basics
Loading TexturesUsing the Color BufferUpdating TexturesMapping Textures to GeometryTexture MatrixA Simple 2D ExampleTexture EnvironmentTexture ParametersBasic FilteringTexture WrapCartoons with TextureMipmappingMipmap FilteringGenerating Mip LevelsHardware Generation of MipmapsLOD BIASTexture ObjectsManaging Multiple TexturesResident TexturesTexture PrioritiesSummaryReference
9. Texture Mapping: Beyond the Basics
Secondary ColorAnisotropic FilteringTexture CompressionCompressing TexturesLoading Compressed TexturesTexture Coordinate GenerationObject Linear MappingEye Linear MappingSphere MappingCube MappingLoading Cube MapsUsing Cube MapsMultitextureMultiple Texture CoordinatesA Multitextured ExampleTexture CombinersSummaryReference
10. Curves and Surfaces
Built-in SurfacesSetting Quadric StatesDrawing QuadricsModeling with QuadricsBézier Curves and SurfacesParametric RepresentationControl PointsContinuityEvaluatorsA 2D CurveEvaluating a CurveA 3D SurfaceLighting and Normal VectorsNURBSFrom Bézier to B-SplinesKnotsCreating a NURBS SurfaceNURBS PropertiesDefining the SurfaceTrimmingNURBS CurvesTessellationThe TessellatorTessellator CallbacksSpecifying Vertex DataPutting It All TogetherSummaryReference
11. It's All About the Pipeline: Faster Geometry Throughput
Model Assembly 101Pieces and PartsThe HeadThe ShaftThe ThreadPutting It TogetherDisplay ListsBatch ProcessingPreprocessed BatchesDisplay List CaveatsConverting to Display ListsMeasuring PerformanceA Better ExampleVertex ArraysLoading the GeometryEnabling ArraysWhere's the Data?Draw!Indexed Vertex ArraysA Simple CubeGetting SeriousMeasuring the CostCreating a Suitable Indexed ArrayComparing the CostSummaryReference
12. Interactive Graphics
SelectionNaming Your PrimitivesWorking with Selection ModeThe Selection BufferPickingHierarchical PickingFeedbackThe Feedback BufferFeedback DataPassthrough MarkersA Feedback ExampleLabel the Objects for FeedbackStep 1: Select the ObjectStep 2: Get Feedback on the ObjectSummaryReference
II. OpenGL Everywhere
13. Wiggle: OpenGL on Windows
OpenGL Implementations on WindowsGeneric OpenGLInstallable Client DriverMini-Client DriverMini-DriverExtended OpenGLBasic Windows RenderingGDI Device ContextsPixel FormatsDescribing a Pixel FormatEnumerating Pixel FormatsSelecting and Setting a Pixel FormatThe OpenGL Rendering ContextPutting It All TogetherCreating the WindowFirst, You Need a Device ContextEnter Win32Three Steps Forward, Two Steps BackAll Is Not LostUsing the OpenGL Rendering ContextInitializing the Rendering ContextShutting Down the Rendering ContextOther Windows MessagesThe WM_PAINT MessageWindows PalettesColor MatchingPalette ArbitrationCreating a Palette for OpenGLDo You Need a Palette?The Palette's StructureThe 3-3-2 PaletteBuilding the PalettePalette Creation and DisposalSome Restrictions ApplyOpenGL and Windows Fonts3D Fonts and TextRendering 3D Text2D Fonts and TextFull-Screen RenderingCreating a Frameless WindowCreating a Full-Screen WindowMultithreaded RenderingOpenGL and WGL ExtensionsSimple ExtensionsUsing New EntrypointsWGL ExtensionsExtended Pixel FormatsWin32 to the MaxSummaryReference
14. OpenGL on MacOS X
The BasicsFrameworksUsing the GLUT APIUsing the AGL and Carbon APIsPixel FormatsManaging ContextsDoing Double-Buffered RenderingYour First AGL ProgramUsing Bitmap FontsUsing the Cocoa APIThe NSOpenGL ClassYour First Cocoa ProgramSummaryReference
15. GLX: OpenGL on Linux
The BasicsUsing the OpenGL and X11 LibrariesUsing the GLUT LibraryOpenGL on LinuxOpenGL Emulation: MesaThe OpenGL Extension for the X Window SystemX Window System BasicsChoosing a VisualManaging OpenGL ContextsCreating an OpenGL WindowDouble-Buffered WindowsPutting It All TogetherCreating Bitmap Fonts for OpenGLOffscreen RenderingUsing GLX PixmapsUsing PbuffersUsing the Motif LibraryGLwDrawingArea and GLwMDrawingArea: The OpenGL WidgetsCallbacksThe GLwNexposeCallback CallbackThe GLwNginitCallback CallbackThe GLwNinputCallback CallbackThe GLwNresizeCallback CallbackFunctionsPutting It All TogetherSummaryReference
III. OpenGL: The Next Generation
16. Buffer Objects: It's Your Video Memory; You Manage It!
First, You Need Vertex ArraysGenerating the Spherical Particle CloudsEnabling the Vertex ArraysMore Spheres, Please!Migration to Buffer ObjectsBuffer Object ManagementRendering with Buffer ObjectsLoading Data into Buffer ObjectsCopying Data into the Buffer ObjectMapping the Buffer Object DirectlyA Few Loose EndsSummaryReference
17. Occlusion Queries: Why Do More Work Than You Need To?
The World Before Occlusion QueriesBounding BoxesQuerying the Query ObjectSummaryReference
18. Depth Textures and Shadows
Be That LightFit the Scene to the WindowNo Bells or Whistles, PleaseA New Kind of TextureDraw the Shadows First?!And Then There Was LightProjecting Your Shadow Map: The “Why”Projecting Your Shadow Map: The “How”The Shadow ComparisonTwo Out of Three Ain't BadA Few Words About Polygon OffsetSummaryReference
19. Programmable Pipeline: This Isn't Your Father's OpenGL
Out with the OldFixed Vertex ProcessingVertex TransformationLightingTexture Coordinate Generation and TransformationClippingFixed Fragment ProcessingTexture Application and EnvironmentColor SumFog ApplicationAntialiasing ApplicationIn with the NewProgrammable Vertex ShadersReplacing Vertex TransformationReplacing LightingReplacing Texture Coordinate ProcessingFixed Functionality GlueProgrammable Fragment ShadersReplacing TexturingReplacing Color SumReplacing FogIntroduction to Shader ExtensionsLow-Level ExtensionsHigh-Level ExtensionsSummary
20. Low-Level Shading: Coding to the Metal
Managing Low-Level ShadersCreating and Binding ShadersLoading ShadersDeleting ShadersSetting Up the ExtensionsInstruction SetsCommon InstructionsVertex-Specific InstructionsFragment-Specific InstructionsVariable TypesTemporariesParametersInline ConstantsState-Bound ParametersProgram ParametersParameter ArraysAttributesVertex AttributesFragment AttributesOutputsVertex OutputsFragment OutputsAliasesAddressesInput and Output ModifiersInput NegateInput SwizzleOutput WritemaskOutput ClampResource Consumption and QueriesParser LimitsTexture IndirectionsNative LimitsOther QueriesShader OptionsPosition-Invariant Vertex OptionFog Application Fragment OptionsPrecision Hint Fragment OptionSummaryReference
21. High-Level Shading: The Real Slim Shader
Managing High-Level ShadersShader ObjectsCreating and DeletingSpecifying Shader TextCompiling ShadersProgram ObjectsCreating and DeletingAttaching and DetachingLinking ProgramsValidating ProgramsUsing ProgramsSetting Up the ExtensionsVariablesBasic TypesStructuresArraysQualifiersBuilt-in VariablesExpressionsOperatorsArray AccessConstructorsComponent SelectorsControl FlowLoopsif/elsediscardFunctionsTexture Lookup FunctionsSummaryReference
22. Vertex Shading: Do-It-Yourself Transform, Lighting, and Texgen
Getting Your Feet WetDiffuse LightingSpecular LightingImproved Specular LightingPer-Vertex FogPer-Vertex Point SizeCustomized Vertex TransformationVertex BlendingSummary
23. Fragment Shading: Empower Your Pixel Processing
Color ConversionGrayscaleSepia ToneInversionHeat SignatureDependent Texture LookupsPer-Fragment FogImage ProcessingBlurSharpenDilation and ErosionEdge DetectionLightingDiffuse LightingMultiple Specular LightsProcedural Texture MappingCheckerboard TextureBeach Ball TextureToy Ball TextureSummary
A. Further Reading
Other Good OpenGL Books3D Graphics BooksWeb Sites
B. Glossary
C. OpenGL ES
Reduction of Data TypesTotally GoneGreatly Reduced FunctionalityTexture MappingRaster OperationsLightingConclusion
CD-ROM
What's on the CD-ROMWindows Installation InstructionsLicense Agreement

Content preview from OpenGL® SuperBible, Third Edition

Chapter 16. Buffer Objects: It's Your Video Memory; You Manage It!

by Benjamin Lipchak

WHAT YOU'LL LEARN IN THIS CHAPTER:

How To	Functions You'll Use
Create, bind to, and delete buffer objects	`glGenBuffers/glBindBuffer/glDeleteBuffers`
Send data into a buffer object indirectly	`glBufferData/glBufferSubData`
Write data into a buffer object directly	`glMapBuffer/glUnmapBuffer`

Graphics cards today have nearly as much memory as the rest of the system they're plugged into. The amount of graphics card memory tends to at least be within an order of magnitude, say 25%, of the amount of system memory. That's quite a resource to exploit—or to waste by not making the best use of it.

Video memory has traditionally been used for storing the following:

Front buffers (what ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0672326019Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

OpenGL® SuperBible, Third Edition

by Richard S. Wright, Benjamin Lipchak

Chapter 16. Buffer Objects: It's Your Video Memory; You Manage It!

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.