OpenSceneGraph 3.0: Beginner's Guide

OpenSceneGraph 3.0: Beginner's Guide
eBook: $29.99
Formats: PDF, PacktLib, ePub and Mobi formats
save 15%!
Print + free eBook + free PacktLib access to the book: $79.98    Print cover: $49.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Table of Contents
Sample Chapters
  • 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

Book Details

Language : English
Paperback : 412 pages [ 235mm x 191mm ]
Release Date : December 2010
ISBN : 1849512825
ISBN 13 : 9781849512824
Author(s) : Rui Wang, Xuelei Qian
Topics and Technologies : All Books, Game Development, Beginner's Guides, Open Source, Web Graphics & Video

Table of Contents

Chapter 1: The Journey into OpenSceneGraph
Chapter 2: Compilation and Installation of OpenSceneGraph
Chapter 3: Creating Your First OSG Program
Chapter 4: Building Geometry Models
Chapter 5: Managing Scene Graph
Chapter 6: Creating Realistic Rendering Effects
Chapter 7: Viewing the World
Chapter 8: Animating Scene Objects
Chapter 9: Interacting with Outside Elements
Chapter 10: Saving and Loading Files
Chapter 11: Developing Visual Components
Chapter 12: Improving Rendering Efficiency
Appendix: Pop Quiz Answers
  • Chapter 1: The Journey into OpenSceneGraph
    • A quick overview of rendering middleware
    • Scene graphs
    • The Birth and development of OSG
    • Components
    • Why OSG?
    • Who uses OSG?
    • Have a quick taste
    • Time for action – say "Hello World" OSG style
    • Live in community
    • Summary
    • 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
      • Summary
      • 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
        • Summary
        • 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
          • Summary
          • 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
            • Summary
            • 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
              • Summary
              • 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
                • Summary
                • 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
                  • Summary
                  • 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
                    • Intersection
                    • 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
                    • Summary
                    • 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
                      • Summary
                      • 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
                        • Summary
                        • 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
                          • Summary
                          • Appendix: Pop Quiz Answers
                            • Chapter 2
                              • Dependencies of osgviewer
                              • The difference between ALL_BUILD and 'build all'
                            • Chapter 3
                              • Configuring OSG path options yourselves
                              • Release a smart pointer
                            • Chapter 4
                              • Results of different primitive types
                              • Optimizing indexed geometries
                            • Chapter 5
                              • Fast dynamic casting
                              • Matrix multiplications
                            • Chapter 6
                              • Lights without sources
                              • Replacements of built-in uniforms
                            • Chapter 7
                              • Changing model positions in the HUD camera
                              • Another way to display the same scene in different views
                            • Chapter 8
                              • Adding or setting callbacks
                              • Choosing the alpha setter and the callback
                            • Chapter 9
                              • Handling events within nodes
                              • Global and node-related events
                            • Chapter 10
                              • Getting rid of pseudo-loaders
                              • Understanding the inheritance relations
                            • Chapter 11
                              • Text positions and the projection matrix
                            • Chapter 12
                              • Carefully blocking threads
                              • Number of created levels and files

                            Rui Wang

                            Rui Wang is a Software Engineer at Beijing Crystal Digital Technology Co., Ltd. (Crystal CG), in charge of the new media interactive application design and development. He wrote a Chinese book called OpenSceneGraph Design and Implementation in 2009. He also wrote the book OpenSceneGraph 3.0 Beginner's Guide in 2010 and OpenSceneGraph 3.0 Cookbook in 2012, both of which are published by Packt Publishing and co-authored by Xuelei Qian. In his spare time he also writes novels and is a guitar lover.

                            Xuelei Qian

                            Xuelei Qian received his Ph.D. in applied graphic computing from the University of Derby in 2005. From 2006 to 2008 he worked as a post-doctoral research fellow in the Dept. of Precision Instrument and Mechanology at Tsinghua University. In 2008 he was appointed by the School of Scientific Research and Development of Tsinghua University. He is also the Deputy Director of the Overseas R&D Management Office of Tsinghua University and Deputy Secretary in General of UniversityIndustry Cooperation Committee, Tsinghua University.
                            Sorry, we don't have any reviews for this title yet.

                            Code Downloads

                            Download the code and support files for this book.

                            Submit Errata

                            Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                            - 1 submitted: last submission 06 Feb 2014

                            Errata type: Others | Page number: 360

                            For the case of representng an octahedron, we could use a triangle strip primitve set (2, 5, 3, 4, 1, 0, 2, 3, ................... should be: For the case of representng an octahedron, we could use a triangle strip primitve set (3,5,4,1,0,2,3,5)


                            Sample chapters

                            You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                            Frequently bought together

                            OpenSceneGraph 3.0: Beginner's Guide +    Building Websites with OpenCms =
                            50% Off
                            the second eBook
                            Price for both: €30.90

                            Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                            What you will learn from this book

                            • 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.

                            With plenty of examples to get you started quickly, you'll master developing with OpenSceneGraph in no time, the 3D graphics engine based on OpenGL


                            Written with a fast-paced but friendly and engaging approach, this Packt Beginner's Guide is designed to be placed alongside the computer as your guide and mentor. Step-by-step tutorials are bolstered by explanations of the reasoning behind what you are doing. You will quickly pick up the necessary skills, tips, and tricks for creating successful 3D graphics with practical examples that help you to learn by experiment and play.

                            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.

                            Code Download and Errata
                            Packt Anytime, Anywhere
                            Register Books
                            Print Upgrades
                            eBook Downloads
                            Video Support
                            Contact Us
                            Awards Voting Nominations Previous Winners
                            Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                            Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software