OpenGL Programming Guide · The Official Guide to Learning OpenGL, Version 4.5 with SPIR-V by Kessenich, John -- Read -- Imperial Library of Trantor

Index

About This E-Book Title Page Copyright Page Praise for previous editions of OpenGL® Programming Guide Dedication Page Contents Figures Tables Examples About This Guide

What This Guide Contains What’s New in This Edition What You Should Know Before Reading This Guide How to Obtain the Sample Code Errata Style Conventions About the OpenGL Series

Acknowledgments

John Kessenich Graham Sellers Dave Shreiner

Chapter 1. Introduction to OpenGL

What Is OpenGL? Your First Look at an OpenGL Program OpenGL Syntax OpenGL’s Rendering Pipeline

Preparing to Send Data to OpenGL Sending Data to OpenGL Vertex Shading Tessellation Shading Geometry Shading Primitive Assembly Clipping Rasterization Fragment Shading Per-Fragment Operations

Our First Program: A Detailed Discussion

Entering main() OpenGL Initialization Our First OpenGL Drawing

Chapter 2. Shader Fundamentals

Shaders and OpenGL OpenGL’s Programmable Pipeline An Overview of the OpenGL Shading Language

Creating Shaders with GLSL Storage Qualifiers Statements Computational Invariance Shader Preprocessor Compiler Control Global Shader-Compilation Option

Interface Blocks

Uniform Blocks Specifying Uniform Blocks in Shaders Accessing Uniform Blocks from Your Application Buffer Blocks In/Out Blocks, Locations, and Components

Compiling Shaders Shader Subroutines

Advanced GLSL Subroutine Setup Selecting Shader Subroutines

Separate Shader Objects

Advanced

SPIR-V

Reasons to Choose SPIR-V Using SPIR-V with OpenGL Using GLSL to Generate SPIR-V for OpenGL Glslang What’s Inside SPIR-V?

Chapter 3. Drawing with OpenGL

OpenGL Graphics Primitives

Points Lines, Strips, and Loops Triangles, Strips, and Fans

Data in OpenGL Buffers

Creating and Allocating Buffers Getting Data into and out of Buffers Accessing the Content of Buffers Discarding Buffer Data

Vertex Specification

VertexAttribPointer in Depth Static Vertex-Attribute Specification

OpenGL Drawing Commands

Restarting Primitives Instanced Rendering

Chapter 4. Color, Pixels, and Fragments

Basic Color Theory Buffers and Their Uses

Color Buffers Depth Buffer Stencil Buffer Clearing Buffers Masking Buffers

Color and OpenGL

Color Representation and OpenGL Smoothly Interpolating Data

Testing and Operating on Fragments

Scissor Test Multisample Fragment Operations Stencil Test Stencil Examples Depth Test Blending Logical Operations Occlusion Query Conditional Rendering

Multisampling

Sample Shading

Per-Primitive Antialiasing

Antialiasing Lines Antialiasing Polygons

Reading and Copying Pixel Data

Clamping Returned Values

Copying Pixel Rectangles

Chapter 5. Viewing Transformations, Culling, Clipping, and Feedback

Viewing

Viewing Model Camera Model Orthographic Viewing Model

User Transformations

Matrix Multiply Refresher Homogeneous Coordinates Linear Transformations and Matrices Transforming Normals OpenGL Matrices

OpenGL Transformations

Advanced: User Culling and Clipping Controlling OpenGL Transformations

Transform Feedback

Transform Feedback Objects Transform Feedback Buffers Configuring Transform Feedback Varyings Starting and Stopping Transform Feedback Transform Feedback Example—Particle System

Chapter 6. Textures and Framebuffers

Introduction to Texturing Basic Texture Types Creating and Initializing Textures

Proxy Textures

Specifying Texture Data

Explicitly Setting Texture Data Loading Textures from Buffers Loading Images from Files Retrieving Texture Data Texture Data Layout

Texture Formats

Internal Formats External Formats

Compressed Textures Sampler Objects

Sampler Parameters

Using Textures

Texture Coordinates Arranging Texture Data Using Multiple Textures

Complex Texture Types

3D Textures Array Textures Cube-Map Textures Shadow Samplers Depth-Stencil Textures Buffer Textures

Texture Views Filtering

Linear Filtering Using and Generating Mipmaps Calculating the Mipmap Level Mipmap Level-of-Detail Control

Advanced Texture Lookup Functions

Explicit Level of Detail Explicit Gradient Specification Texture Fetch with Offsets Projective Texturing Texture Queries in Shaders Gathering Texels Combining Special Functions

Bindless Textures

Texture Handles Texture Residency Sampling Bindless Textures

Sparse Textures

Sparse Texture Commitment Sparse Texture Pages

Point Sprites

Textured Point Sprites Controlling the Appearance of Points

Framebuffer Objects Rendering to Texture Maps

Discarding Rendered Data Renderbuffers Creating Renderbuffer Storage Framebuffer Attachments Framebuffer Completeness Invalidating Framebuffers Writing to Multiple Renderbuffers Simultaneously Selecting Color Buffers for Writing and Reading Dual-Source Blending

Chapter Summary

Texture Redux Texture Best Practices

Chapter 7. Light and Shadow

Lighting Introduction Classic Lighting Model

Fragment Shaders for Different Light Styles Moving Calculations to the Vertex Shader Multiple Lights and Materials Lighting Coordinate Systems Limitations of the Classic Lighting Model

Advanced Lighting Models

Hemisphere Lighting Image-Based Lighting Lighting with Spherical Harmonics

Shadow Mapping

Creating a Shadow Map Using a Shadow Map

Chapter 8. Procedural Texturing

Procedural Texturing

Regular Patterns Toy Ball Lattice Procedural Shading Summary

Bump Mapping

Application Setup Vertex Shader Fragment Shader Normal Maps

Antialiasing Procedural Textures

Sources of Aliasing Avoiding Aliasing Increasing Resolution Antialiasing High Frequencies Frequency Clamping Procedural Antialiasing Summary

Noise

Definition of Noise Noise Textures Trade-Offs A Simple Noise Shader Turbulence Marble Granite Wood Noise Summary

Further Information

Chapter 9. Tessellation Shaders

Tessellation Shaders Tessellation Patches Tessellation Control Shaders

Generating Output-Patch Vertices Tessellation Control Shader Variables Controlling Tessellation

Tessellation Evaluation Shaders

Specifying the Primitive Generation Domain Specifying the Face Winding for Generated Primitives Specifying the Spacing of Tessellation Coordinates Additional Tessellation Evaluation Shader layout Options Specifying a Vertex’s Position Tessellation Evaluation Shader Variables

A Tessellation Example: The Teapot

Processing Patch Input Vertices Evaluating Tessellation Coordinates for the Teapot

Additional Tessellation Techniques

View-Dependent Tessellation Shared Tessellated Edges and Cracking Displacement Mapping

Chapter 10. Geometry Shaders

Creating a Geometry Shader Geometry Shader Inputs and Outputs

Geometry Shader Inputs Special Geometry Shader Primitives Geometry Shader Outputs

Producing Primitives

Culling Geometry Geometry Amplification

Advanced Transform Feedback

Multiple Output Streams Primitive Queries Using Transform Feedback Results

Geometry Shader Instancing Multiple Viewports and Layered Rendering

Viewport Index Layered Rendering

Chapter Summary

Geometry Shader Redux Geometry Shader Best Practices

Chapter 11. Memory

Using Textures for Generic Data Storage

Binding Textures to Image Units Reading and Writing to Images

Shader Storage Buffer Objects

Writing Structured Data

Atomic Operations and Synchronization

Atomic Operations on Images Atomic Operations on Buffers Sync Objects Image Qualifiers and Barriers High-Performance Atomic Counters

Example: Order-Independent Transparency

Principles of Operation Initialization Rendering Sorting and Blending Results

Chapter 12. Compute Shaders

Overview Workgroups and Dispatch

Knowing Where You Are

Communication and Synchronization

Communication Synchronization

Examples

Physical Simulation Image Processing

Chapter Summary

Compute Shader Redux Compute Shader Best Practices

Appendix A. Support Libraries

Basics of GLFW: The OpenGL Utility Framework Initializing and Creating a Window Handling User Input Controlling the Window Shutting Down Cleanly GL3W: OpenGL Glue

Appendix B. OpenGL ES and WebGL

OpenGL ES WebGL

Setting Up WebGL Within an HTML5 Page Initializing Shaders in WebGL Initializing Vertex Data in WebGL Using Texture Maps in WebGL

Appendix C. Built-in GLSL Variables and Functions

Built-in Variables

Built-in Variable Declarations Built-in Variable Descriptions

Built-in Constants Built-in Functions

Angle and Trigonometry Functions Exponential Functions Common Functions Floating-Point Pack and Unpack Functions Geometric Functions Matrix Functions Vector Relational Functions Integer Functions Texture Functions Atomic-Counter Functions Atomic Memory Functions Image Functions Fragment Processing Functions Geometry Shader Functions Shader Invocation Control Functions Shader Memory Control Functions

Appendix D. State Variables

The Query Commands OpenGL State Variables

Current Values and Associated Data Vertex Array Object State Vertex Array Data Buffer Object State Transformation State Coloring State Rasterization State Multisampling Textures Pixel Operations Framebuffer Controls Framebuffer State Renderbuffer State Pixel State Shader Object State Shader Program Pipeline Object State Shader Program Object State Program Interface State Program Object Resource State Vertex and Geometry Shader State Query Object State Image State Transform Feedback State Atomic Counter State Shader Storage Buffer State Sync Object State Hints Compute Dispatch State Implementation-Dependent Values Tessellation Shader Implementation-Dependent Limits Geometry Shader Implementation-Dependent Limits Fragment Shader Implementation-Dependent Limits Implementation-Dependent Compute Shader Limits Implementation-Dependent Shader Limits Implementation-Dependent Debug Output State Implementation-Dependent Values Internal Format-Dependent Values Implementation-Dependent Transform Feedback Limits Framebuffer-Dependent Values Miscellaneous

Appendix E. Homogeneous Coordinates and Transformation Matrices

Homogeneous Coordinates

Transforming Vertices Transforming Normals

Transformation Matrices

Translation Scaling Rotation Perspective Projection Orthographic Projection

Appendix F. Floating-Point Formats for Textures, Framebuffers, and Renderbuffers

Reduced-Precision Floating-Point Values 16-Bit Floating-Point Values 10- and 11-Bit Unsigned Floating-Point Values

Appendix G. Debugging and Profiling OpenGL

Creating a Debug Context Debug Output

Debug Messages Filtering Messages Application-Generated Messages

Debug Groups

Naming Objects

Profiling

Profiling Tools In-Application Profiling

Appendix H. Buffer Object Layouts

Using Standard Layout Qualifiers The std140 Layout Rules The std430 Layout Rules

Glossary Index Code Snippets

← Prev
Back
Next →

← Prev
Back
Next →