Free Sample
+ Collection

OpenSceneGraph 3.0: Beginner's Guide

Beginner's Guide
Rui Wang, Xuelei Qian

This book is a concise introduction to the main features of OpenSceneGraph which then leads you into the fundamentals of developing virtual reality applications. Practical instructions and explanations accompany you every step of the way.
RRP $29.99
RRP $49.99
Print + eBook

Want this title & more?

$12.99 p/month

Subscribe to PacktLib

Enjoy full and instant access to over 2000 books and videos – you’ll find everything you need to stay ahead of the curve and make sure you can always get the job done.

Book Details

ISBN 139781849512824
Paperback412 pages

About This Book

  • Gain a comprehensive view of the structure and main functionalities of OpenSceneGraph
  • An ideal introduction for developing applications using OpenSceneGraph
  • Develop applications around the concepts of scene graphs and design patterns
  • Extend your own scene elements from the base interfaces of OpenSceneGraph
  • Packed with examples, this book explains each knowledge point in detail and makes you practice your knowledge for better understanding

Who This Book Is For

This book is intended for software developers who are new to OpenSceneGraph and considering using it in their applications. It is assumed that you have basic knowledge of C++ before using this book, especially the standard template library (STL) constructs, of which OSG makes extensive use. Some familiarity with design patterns as implemented in C++ is also useful, but is not required.

You need to be familiar with OpenGL, the standard cross-platform low-level 3D graphics API. We'll meet some maths in the book—geometry and linear algebra—and familiarity with these topics will be great, but you don't need to be a maths whiz to use this book.

Table of Contents

Chapter 1: The Journey into OpenSceneGraph
A quick overview of rendering middleware
Scene graphs
The Birth and development of OSG
Why OSG?
Who uses OSG?
Have a quick taste
Time for action—say "Hello World" OSG style
Live in community
Chapter 2: Compilation and Installation of OpenSceneGraph
System requirements
Using the installer
Time for action—installing OSG
Running utilities
Time for action—playing with osgviewer
Using the project wizard
Time for action—creating your solution with one click
Prebuilts making trouble?
Cross-platform building
Starting CMake
Time for action—running CMake in GUI mode
Setting up options
Generating packages using Visual Studio
Time for action—building with a Visual Studio solution
Generating packages using gcc
Time for action—building with a UNIX makefile
Configuring environment variables
Chapter 3: Creating Your First OSG Program
Constructing your own projects
Time for action—building applications with CMake
Using a root node
Time for action—improving the "Hello World" example
Understanding memory management
ref_ptr<> and Referenced classes
Collecting garbage: why and how
Tracing the managed entities
Time for action—monitoring counted objects
Parsing command-line arguments
Time for action—reading the model filename from the command line
Tracing with the notifier
Redirecting the notifier
Time for action—saving the log file
Chapter 4: Building Geometry Models
How OpenGL draws objects
Geode and Drawable classes
Rendering basic shapes
Time for action—quickly creating simple objects
Storing array data
Vertices and vertex attributes
Specifying drawing types
Time for action—drawing a colored quad
Indexing primitives
Time for action—drawing an octahedron
Using polygonal techniques
Time for action—tessellating a polygon
Rereading geometry attributes
Customizing a primitive functor
Time for action—collecting triangle faces
Implementing your own drawables
Using OpenGL drawing calls
Time for action—creating the famous OpenGL teapot
Chapter 5: Managing Scene Graph
The Group interface
Managing parent nodes
Time for action—adding models to the scene graph
Traversing the scene graph
Transformation nodes
Understanding the matrix
The MatrixTransform class
Time for action—performing translations of child nodes
Switch nodes
Time for action—switching between the normal and damaged Cessna
Level-of-detail nodes
Time for action—constructing a LOD Cessna
Proxy and paging nodes
Time for action—loading a model at runtime
Customizing your own NodeKits
Time for action—animating the switch node
The visitor design pattern
Visiting scene graph structures
Time for action—analyzing the Cessna structure
Chapter 6: Creating Realistic Rendering Effects
Encapsulating the OpenGL state machine
Attributes and modes
Time for action—setting polygon modes of different nodes
Inheriting render states
Time for action—lighting the glider or not
Playing with fixed-function effects
Time for action—applying simple fog to models
Lights and light sources
Time for action—creating light sources in the scene
The Image class
The basis of texture mapping
Time for action—loading and applying 2D textures
Handling rendering order
Time for action—achieving the translucent effect
Understanding graphics shaders
Using uniforms
Time for action—implementing a cartoon cow
Working with the geometry shader
Time for action—generating a Bezier curve
Chapter 7: Viewing the World
From world to screen
The Camera class
Rendering order of cameras
Time for action—creating an HUD camera
Using a single viewer
Digging into the simulation loop
Time for action—customizing the simulation loop
Using a composite viewer
Time for action—rendering more scenes at one time
Changing global display settings
Time for action—enabling global multisampling
Stereo visualization
Time for action—rendering anaglyph stereo scenes
Rendering to textures
Frame buffer, pixel buffer, and FBO
Time for action—drawing aircrafts on a loaded terrain
Chapter 8: Animating Scene Objects
Taking references to functions
List of callbacks
Time for action—switching nodes in the update traversal
Avoiding conflicting modifications
Time for action—drawing a geometry dynamically
Understanding ease motions
Animating the transformation nodes
Time for action—making use of the animation path
Changing rendering states
Time for action—fading in
Playing movies on textures
Time for action—rendering a flashing spotlight
Creating complex key-frame animations
Channels and animation managers
Time for action—managing animation channels
Loading and rendering characters
Time for action—creating and driving a character system
Chapter 9: Interacting with Outside Elements
Various events
Handling mouse and keyboard inputs
Time for action—driving the Cessna
Adding customized events
Time for action—creating a user timer
Picking objects
Time for action—clicking and selecting geometries
Windows, graphics contexts, and cameras
The Traits class
Time for action—configuring the traits of a rendering window
Integrating OSG into a window
Time for action—attaching OSG with a window handle in Win32
Chapter 10: Saving and Loading Files
Understanding file I/O plugins
Discovery of specified extension
Supported file formats
The pseudo-loader
Time for action—reading files from the Internet
Configuring third-party dependencies
Time for action—adding libcurl support for OSG
Writing your own plugins
Handling the data stream
Time for action—designing and parsing a new file format
Serializing OSG native scenes
Creating serializers
Time for action—creating serializers for user-defined classes
Chapter 11: Developing Visual Components
Creating billboards in a scene
Time for action—creating banners facing you
Creating texts
Time for action—writing descriptions for the Cessna
Creating 3D texts
Time for action—creating texts in the world space
Creating particle animations
Time for action—building a fountain in the scene
Creating shadows on the ground
Time for action—receiving and casting shadows
Implementing special effects
Time for action—drawing the outline of models
Playing with more NodeKits
Chapter 12: Improving Rendering Efficiency
OpenThreads basics
Time for action—using a separate data receiver thread
Understanding multithreaded rendering
Time for action—switching between different threading models
Dynamic scene culling
Occluders and occludees
Time for action—adding occluders to a complex scene
Improving your application
Time for action—sharing textures with a customized callback
Paging huge scene data
Making use of the quad-tree
Time for action—building a quad-tree for massive rendering

What You Will Learn

  • Gain an overview of scene graphs and the basic concepts in OpenSceneGraph (OSG)
  • Build and configure an OSG development environment, either with the prebuilt binaries or wholly from the source code
  • Understand memory management and the notification system in OSG
  • Create geometry entities with vertices and drawing primitives and use these features in your applications successfully
  • Make use of various types of scene graph nodes with special focus on some commonly used ones
  • Implement different rendering attributes, texture mapping, OpenGL shaders, and render-to-texture technique in OSG
  • Understand coordinates, cameras, manipulators, and stereo supports and make them work together
  • Create various animated graphics presentations in the 3D scene
  • Use mouse and keyboard devices to interact with OSG, as well as integrate other GUI toolkits with OSG rendering windows
  • Read scene data and write them out with extendable file I/O plugins
  • Develop advanced scene graph components including billboards, texts, height mapped terrains and shadows
  • Introduce techniques necessary for building a fast real-time rendering system and help developers work with massive data in a very efficient manner


In Detail

Virtual reality has quite a lot of demand in computer science today and OpenSceneGraph, being one of the best 3D graphics toolkits, is being used widely. Although you can use the powerful OpenSceneGraph, based on the low-level OpenGL API, to implement virtual-reality applications that simulate different environments in the 3D world, developing picture-perfect applications is easier said than done.

This book has been written with the goal of helping readers become familiar with the structure and main functionalities of OpenSceneGraph (OSG), and guide them to develop virtual-reality applications using this powerful 3D graphics engine. This book covers the essence of OpenSceneGraph (OSG), providing programmers with detailed explanations and examples of scene graph APIs.

This book helps you take full advantages of the key features and functionalities of OpenSceneGraph (OSG). You will learn almost all of the core elements required in a virtual reality application, including memory management, geometry creation, the structure of the scene graph, realistic rendering effects, scene navigation, animation, interaction with input devices and external user interfaces, file reading and writing, and so on.

With the essential knowledge contained in this book, you will be able to start using OSG in your own projects and research fields, and extend its functionalities by referring to OSG's source code, official examples and API documentation.

This handy book divides the core functionalities of the proved and comprehensive OpenSceneGraph (OSG) 3D graphics engine into different aspects, which are introduced in separate chapters. Each chapter can be treated as an individual part that covers one important field of OSG programming, along with several examples illustrating concrete usages and solutions. But the sequence of chapters is also organized from the easy to the more difficult, to help you get to grips with OSG.

By the end of the whole book, you will have gained a ready-to-use OSG development environment for yourself and have the general ability to develop OSG-based applications and extend practical functionalities for your own purposes.


Read More

Recommended for You