OpenGL Insights: OpenGL, OpenGL ES, and WebGL Community Experiences

OpenGL Insights
Contents
Foreword
Preface
Tips
Section I: Discovering
Chapter 1: Teaching Computer Graphics Starting with Shader- Based OpenGL
1.1 Introduction
1.2 A Basic Course
1.3 Hello World in OpenGL: Old Style
1.4 Starting with Programmable Pipelines
1.5 Hello World: New Style
1.5.1 OpenGL ES and WebGL
1.5.2 The First Assignment
1.6 The Rest of the Course
1.6.1 Geometry
1.6.2 Transformations and Viewing
1.6.3 Lighting and Shading
1.6.4 Texturing and Discrete Processing
1.6.5 Advanced Topics
1.6.6 Issues
1.7 Conclusion
Bibliography
Chapter 2: Transitioning Students to Post- Deprecation OpenGL
2.1 Introduction
2.2 Naming Shader Variables: Introduction
2.3 Naming Shader Variables: Details
2.4 Indexed Vertex Buffer Object C++ Class
2.4.1 Usage Notes
2.4.2 Example Code
2.4.3 Implementation Notes
2.5 GLSLProgram C++ Class
2.5.1 Usage Notes
2.5.2 Example Code
2.5.3 Implementation Notes
2.6 Conclusion
Bibliography
Chapter 3: WebGL for OpenGL Developers
3.1 Introduction
3.2 The Benefits of WebGL
3.2.1 Zero-Footprint
3.2.2 Cross-Platform
3.2.3 Cross-Device
3.2.4 It’s Easy
3.2.5 Strong Tool Support
3.2.6 Performance
3.3 Security
3.3.1 Cross-Origin Requests
3.3.2 Context Loss
3.4 Deploying Shaders
3.5 The JavaScript Language
3.5.1 JavaScript Types
3.5.2 Dynamic Typing
3.5.3 Functional Scoping
3.5.4 Functional Programming
3.5.5 Prototypal Objects
3.5.6 The this Keyword
3.5.7 Code Organization
3.5.8 Common Errors
3.6 Resources
Bibliography
Chapter 4: Porting Mobile Apps to WebGL
4.1 Introduction
4.2 OpenGL across Platforms
4.3 Getting Started
4.3.1 Initializing an OpenGL ES context
4.3.2 Loading Shaders
4.3.3 Drawing Vertices
4.4 Loading Textures
4.4.1 Assigning a Texture
4.4.2 Handling Asynchronous Loads
4.5 Camera and Matrices
4.5.1 float vs. Float32Array
4.5.2 Passing a Matrix to a Shader
4.6 Controls
4.6.1 Getting Touch Events
4.6.2 Using Touch Events with the Camera and Collision
4.7 Other Considerations
4.7.1 Animation
4.7.2 Inheritance
4.8 Maintenance
4.8.1 Debugging
4.8.2 Profiling
4.8.3 Performance and Adoption
4.9 Conclusion
Bibliography
Chapter 5: The GLSL Shader Interfaces
5.1 Introduction
5.2 Variables and Blocks
5.2.1 User-Defined Variables and Blocks
5.2.2 Built-in Variables and Blocks
5.3 Locations
5.3.1 Definitions
5.3.2 Counting Locations
5.3.3 Location Limits
5.4 Matching Interfaces
5.4.1 Partial and Full Match
5.4.2 Type Matching
5.4.3 Matching by Name, Matching by Location
5.4.4 Matching with Blocks
5.4.5 Matching with Structures
5.4.6 Linked and Separated Programs
5.5 Working with Semantics
5.5.1 Varying Compiler-Generated Locations and Explicit
Locations
5.5.2 Vertex Array Attributes and Vertex Shader Inputs
5.5.3 Fragment Shader Outputs and Framebuffer Color
Attachments
5.5.4 Varying Outputs and Varying Inputs
5.5.5 Uniform Buffers and Uniform Blocks
5.6 Application-Side Validations for Debug Build Only
5.6.1 Vertex Inputs Validation
5.6.2 Varying Interfaces Validation
5.6.3 Fragment Outputs Validation
5.6.4 Variables Validation
5.6.5 Uniform Blocks Validation
5.7 Conclusion
Bibliography
Chapter 6: An Introduction to Tessellation Shaders
6.1 Introduction
6.1.1 Subdivision Surfaces
6.1.2 Smoothing Polygonal Data
6.1.3 GPU Compute
6.1.4 Curves, Hair, and Grass
6.1.5 Other Uses
6.2 The New Shading Pipeline
6.2.1 Life of a Patch
6.2.2 Threading Model
6.2.3 Inputs and Outputs
6.2.4 Tessellation Control Shaders
6.2.5 Tessellation Evaluation Shaders
6.2.6 Primitive Generation Using quads
6.2.7 Primitive Generation Using triangles
6.3 Tessellating a Teapot
6.4 Isolines and Spirals
6.5 Incorporating Other OpenGL Features
Bibliography
Chapter 7: Procedural Textures in GLSL
7.1 Introduction
7.2 Simple Functions
7.3 Antialiasing
7.4 Perlin Noise
7.5 Worley Noise
7.6 Animation
7.7 Texture Images
7.8 Performance
7.9 Conclusion
Bibliography
Chapter 8: OpenGL SC Emulation Based on OpenGL and OpenGL ES
8.1 Introduction
8.2 OpenGL SC Implementations
8.3 Design and Implementation
8.3.1 Overall Pipeline
8.3.2 Texture Pipeline
8.4 Results
8.5 Conclusion
Bibliography
Chapter 9: Mixing Graphics and Compute with Multiple GPUs
9.1 Introduction
9.2 Graphics and Compute Interoperability on an API Level
9.2.1 Interoperability Preparation
9.2.2 OpenGL Object Interaction
9.3 Graphics and Compute Interoperability on a System Level
9.4 Conclusion
Bibliography
Section II: Rendering Techniques
Chapter 10: GPU Tessellation: We Still Have a LOD of Terrain to Cover
10.1 Introduction
10.2 Rendering Terrains with OpenGL GPU Tessellation
10.2.1 GPU Tessellation Shaders
10.3 A Simple Approach to Dynamic Level of Detail
10.4 Roughness: When Detail Matters
10.4.1 Adding the Roughness Factor
10.5 Crunching Numbers, or Is This All That Matters?
10.5.1 Test Setup
10.5.2 Evaluating the Quality of the LOD Solutions
10.5.3 Performance
10.6 Conclusion
Bibliography
Chapter 11: Antialiased Volumetric Lines Using Shader- Based Extrusion
11.1 Introduction
11.2 Antialiased Lines Using Postprocess Antialiasing
11.3 Antialiased Volumetric Lines Using Geometry Extrusion
11.3.1 Geometry Extrusion Using a Vertex Shader
11.3.2 Geometry Extrusion Using a Geometry Shader
11.4 Performance
11.5 Conclusion
Bibliography
Chapter 12: 2D Shape Rendering by Distance Fields
12.1 Introduction
12.2 Method Overview
12.3 Better Distance Fields
12.4 Distance Textures
12.5 Hardware Accelerated Distance Transform
12.6 Fragment Rendering
12.7 Special Effects
12.8 Performance
12.9 Shortcomings
12.10 Conclusion
Bibliography
Chapter 13: Efficient Text Rendering in WebGL
13.1 Introduction
13.2 Canvas-Based Font Rendering
13.2.1 The HTML5 Canvas
13.2.2 Concept
13.2.3 Implementation
13.3 Bitmap Font Rendering
13.3.1 Concept
13.3.2 Creating Bitmap Fonts
13.3.3 Implementation
13.4 Comparison
13.4.1 Performance
13.4.2 Memory Footprint
13.4.3 Ease of Development
13.5 Conclusion
Bibliography
Chapter 14: Layered Textures Rendering Pipeline
14.1 Introduction
14.1.1 Terminology
14.1.2 Textures in Blender
14.2 Layered Pipeline
14.2.1 G-buffer Creation
14.2.2 Layers Resolution
14.2.3 Unified parallax offset
14.2.4 Lighting
14.3 Results
14.3.1 Implementation
14.3.2 Results
14.3.3 Conclusion
Bibliography
Chapter 15: Depth of Field with Bokeh Rendering
15.1 Introduction
15.2 Depth of Field Phenomemon
15.3 Related Work
15.4 Algorithm
15.4.1 Overview
15.4.2 Circle of Confusion Computation
15.4.3 Bokeh Detection
15.4.4 Blur-Based Depth of Field
15.4.5 Bokeh Rendering
15.5 Results
15.6 Discussion
15.7 Conclusion
Bibliography
Chapter 16: Shadow Proxies
16.1 Introduction
16.2 Anatomy of a Shadow Proxy
16.3 Setting Up the Pipeline
16.4 The ShadowProxy-Enabled Fragment Shader
16.5 Modulating the Shadow Volume
16.6 Performance
16.7 Conclusion and Future Work
Bibliography
Section III: Bending the Pipeline
Chapter 17: Real-Time Physically Based Deformation Using Transform Feedback
17.1 Introduction
17.2 Hardware Support and Evolution of Transform Feedback
17.3 The Mechanism of Transform Feedback
17.4 Mathematical Model
17.5 Implementation
17.5.1 The Verlet Integration Vertex Shader
17.5.2 Registering Attributes to Transform Feedback
17.5.3 The Array Buffer and Buffer Object Setup
17.5.4 On-the-Fly Modification of Data
17.6 Experimental Results and Comparisons
17.7 Conclusion
Bibliography
Chapter 18: Hierarchical Depth Culling and Bounding- Box Management on the GPU
18.1 Introduction
18.2 Pipeline
18.2.1 Early Depth Pass
18.2.2 Depth LOD Construction
18.2.3 Bounding-Boxes Update
18.2.4 Hierarchical Depth Cull
18.2.5 Bounding-Box Debug Draw
18.3 Order of Operations
18.4 Experimental Results
18.5 Conclusion and Future Work
Bibliography
Chapter 19: Massive Number of Shadow- Casting Lights with Layered Rendering
19.1 Introduction
19.2 Traditional Shadow Map Rendering in OpenGL
19.3 Our Shadow Map Generation Algorithm
19.4 Performance
19.4.1 Performance with Complex Vertex Shaders
19.4.2 View Frustum Culling Optimization
19.4.3 Back-Face Culling Optimization
19.5 Advanced Techniques
19.6 Limitations
19.7 Conclusion
Bibliography
Chapter 20: Efficient Layered Fragment Buffer Techniques
20.1 Introduction
20.2 Related Work
20.3 The Linked-List LFB
20.4 The Linearized LFB
20.4.1 Implementation Details
20.5 Performance Results
20.6 Conclusion
Bibliography
Chapter 21: Programmable Vertex Pulling
21.1 Introduction
21.2 Implementation
21.3 Performance
21.4 Application
21.5 Limitations
21.6 Conclusion
Bibliography
Chapter 22: Octree-Based Sparse Voxelization Using the GPU Hardware Rasterizer
22.1 Introduction
22.2 Previous Work
22.3 Unrestricted Memory Access in GLSL
22.4 Simple Voxelization Pipeline
22.4.1 Conservative Rasterization
22.4.2 Compositing Voxel Fragments
22.4.3 Results
22.5 Sparse Voxelization into an Octree
22.5.1 Octree Structure
22.5.2 Sparse-Voxelization Overview
22.5.3 Voxel-Fragment List Construction Using an Atomic
Counter
22.5.4 Node Subdivision
22.5.5 Writing and Mipmapping Values
22.5.6 Synchronization-Free Compute-Like Kernel Launch
Using draw indirect
22.5.7 Results and Discussion
22.6 Conclusion
Bibliography
Section IV: Performance
Chapter 23: Performance Tuning for Tile- Based Architectures
23.1 Introduction
23.2 Background
23.3 Clearing and Discarding the Framebuffer
23.4 Incremental Frame Updates
23.5 Flushing
23.6 Latency
23.7 Hidden Surface Removal
23.8 Blending
23.9 Multisampling
23.10 Performance Profiling
23.11 Summary
Bibliography
Chapter 24: Exploring Mobile vs. Desktop OpenGL Performance
24.1 Introduction
24.2 Important Differences and Constraints
24.2.1 Differences in Scale
24.2.2 Differences in Rendering Architecture
24.2.3 Differences in Memory Architecture
24.3 Reducing Memory Bandwidth
24.3.1 Relative Display Sizes
24.3.2 Framebuffer Bandwidth
24.3.3 Antialiasing
24.3.4 Texture Bandwidth
24.3.5 Texture Filtering and Bandwidth
24.4 Reducing Fragment Workload
24.4.1 Overdraw and Blending
24.4.2 Full-Screen Effects
24.4.3 Offscreen Passes
24.4.4 Shaving Fragment Work
24.5 Vertex Shading
24.5.1 Vertex vs. Fragment Work
24.6 Conclusion
Bibliography
Chapter 25: Improving Performance by Reducing Calls to the Driver
25.1 Introduction
25.2 Efficient OpenGL States Usage
25.2.1 Detecting Redundant State Modifications
25.2.2 General Methods for Efficient State Modification
25.3 Batching and Instancing
25.3.1 Batching
25.3.2 OpenGL Instancing
25.4 Conclusion
Bibliography
Chapter 26: Indexing Multiple Vertex Arrays
26.1 Introduction
26.2 The Problem
26.3 An Algorithm
26.4 Vertex Comparison Methods
26.4.1 If/Then/Else Version
26.4.2 memcmp() Version
26.4.3 Hashing Function
26.5 Performance
26.6 Conclusion
Bibliography
Chapter 27: Multi-GPU Rendering on NVIDIA Quadro
27.1 Introduction
27.2 Previous Scaling Approaches
27.3 Targeting a Specific GPU for Rendering
27.3.1 Enumerating GPUs and Displays
27.4 Optimized Data Transfer between GPUs
27.5 Application Structure for Multi-GPU
27.5.1 Synchronization between Multiple OpenGL
Contexts
27.6 Parallel Rendering Methodologies
27.6.1 Sort-First Image Decomposition
27.6.2 Sort-Last Data Decomposition
27.6.3 Stereo
27.6.4 Server-Side Rendering
27.7 Conclusion
Bibliography
Section V: Transfers
Chapter 28: Asynchronous Buffer Transfers
28.1 Introduction
28.1.1 Explanation of Terms
28.2 Buffer Objects
28.2.1 Memory Transfers
28.2.2 Usage Hints
28.2.3 Implicit Synchronization
28.2.4 Synchronization Primitives
28.3 Upload
28.3.1 Round-Robin Fashion (Multiple Buffer Objects)
28.3.2 Buffer Respecification (Orphaning)
28.3.3 Unsynchronized Buffers
28.3.4 AMD’s pinned memory Extension
28.4 Download
28.5 Copy
28.6 Multithreading and Shared Contexts
28.6.1 Introduction to Multithreaded OpenGL
28.6.2 Synchronization Issues
28.6.3 Performance Hit due to Internal Synchronization
28.6.4 Final Words on Shared Context
28.7 Usage Scenario
28.7.1 Method 1: Single Thread
28.7.2 Method 2: Two Threads and One OpenGL Context
28.7.3 Method 3: Two Threads and Two OpenGL Shared
Contexts
28.7.4 Performance Comparisons
28.8 Conclusion
Bibliography
Chapter 29: Fermi Asynchronous Texture Transfers
29.1 Introduction
29.2 OpenGL Command Buffer Execution
29.3 Current Texture Transfer Approaches
29.3.1 Synchronous Texture Transfers
29.3.2 CPU Asynchronous Texture Transfers
29.4 GPU Asynchronous Texture Transfers
29.5 Implementation Details
29.5.1 Multiple OpenGL Contexts
29.5.2 Synchronization
29.5.3 Copy Engine Considerations
29.6 Results and Analysis
29.6.1 Previous Generation Architecture
29.7 Conclusion
Bibliography
Chapter 30: WebGL Models: End-to-End
30.1 Introduction
30.2 Life of a 3D Model
30.2.1 Stage 1: Pipeline
30.2.2 Stage 2: Serving
30.2.3 Stage 3: Loading
30.2.4 Stage 4: Rendering
30.3 A Coherent Whole
30.3.1 Delta Coding
30.3.2 Delta Coding Analysis
30.3.3 ZigZag Coding
30.3.4 Delta + ZigZag Coding Analysis
30.3.5 The Compression Pipeline
30.4 Key Improvements
30.4.1 Interleaving vs. Transposing
30.4.2 High-Water Mark Prediction
30.4.3 Performance
30.4.4 Future Work
30.5 Conclusion
Bibliography
Chapter 31: In-Game Video Capture with Real- Time Texture Compression
31.1 Introduction
31.2 Overview of DXT Compression
31.3 DXT Compression Algorithms
31.3.1 Creating Compressed Textures Dynamically
31.4 Transformation to YUV Style Color Spaces
31.4.1 YCoCg Color Space
31.5 Comparison
31.6 Using Real-Time DXT Compression for Procedural Content and Video Capture
31.6.1 Video Capture Using YUYV-DXT Compression
31.6.2 Bandwidth Considerations
31.6.3 Format of the Video Stream
31.6.4 Download of Video Frames from the GPU
31.7 Conclusion
Bibliography
Chapter 32: An OpenGL-Friendly Geometry File Format and Its Maya Exporter
32.1 Introduction
32.2 Manifesto
32.2.1 Goals and Features
32.2.2 Existing Formats
32.3 The Drone Format
32.3.1 Binary Layout
32.3.2 Drone API
32.3.3 Scene API
32.4 Writing a Maya File Translator
32.4.1 Maya SDK 101
32.4.2 Writing a Translator
32.4.3 Walking through the Maya DAG
32.4.4 Exporting OpenGL-Ready Meshes
32.5 Results
32.6 Conclusion
Bibliography
Section VI: Debugging and Profiling
Chapter 33: ARB debug output: A Helping Hand for Desperate Developers
33.1 Introduction
33.2 Exposing the Extension
33.3 Using a Callback Function
33.4 Sorting Through the Cause of Events
33.4.1 Accessing the Call Stack Outside the IDE
33.5 Accessing the Message Log
33.6 Adding Custom User Events to the Log
33.7 Controlling the Event Output Volume
33.8 Preventing Impact on the Final Release
33.9 Clash of the Titans: Implementation Strategies
33.10 Further Thoughts on Debugging
33.11 Conclusion
Bibliography
Chapter 34: The OpenGL Timer Query
34.1 Introduction
34.2 Measuring OpenGL Execution Times
34.2.1 OpenGL Time
34.2.2 Synchronous Timer Query
34.2.3 Asynchronous Timer Query
34.2.4 Asynchronous Time Stamp Query
34.2.5 Considering Query Retrievals
34.3 Conclusion
Bibliography
Chapter 35: A Real-Time Profiling Tool
35.1 Introduction
35.2 Scope and Requirements
35.3 Design of the Tool
35.3.1 User Interface
35.3.2 Limitations and Workarounds
35.3.3 API
35.4 Implementation
35.4.1 Measuring Time on CPUs
35.4.2 Measuring Time on the GPU
35.4.3 Data Structures
35.4.4 Markers Management
35.5 Using the Profiler
35.5.1 Levels of Usage
35.5.2 Determining What Should be Measured
35.5.3 Artists
35.5.4 Limitations
35.6 Conclusions
Bibliography
Chapter 36: Browser Graphics Analysis and Optimizations
36.1 Introduction
36.2 The Stages of Bloom
36.3 Overhead of Bloom
36.4 Analyzing WebGL Applications
36.4.1 Almost Native Graphics Layer (ANGLE)
36.4.2 JavaScript profiling
36.4.3 WebGL Inspector
36.4.4 Intel Graphics Performance Analyzers (GPA)
36.5 Analysis Workflow on Windows
36.5.1 Tracking Down API Calls
36.6 Optimized Bloom
36.6.1 Lower Render Target Resolution
36.6.2 Unnecessary Mipmap Generation
36.6.3 Floating-Point Framebuffers
36.7 Conclusion
Bibliography
Chapter 37: Performance State Tracking
37.1 Introduction
37.2 Power Consumption Policies
37.3 P-State Tracking Using NVAPI
37.3.1 GPU Utilization
37.3.2 Reading P-States
37.4 P-State Tracking Using ADL
37.5 Conclusion
Bibliography
Chapter 38: Monitoring Graphics Memory Usage
38.1 Introduction
38.2 Graphics Memory Allocation
38.3 Querying Memory Status on NVIDIA Cards
38.4 Querying Memory Status on AMD Cards
38.5 Conclusion
Bibliography
Section VII: Software Design
Chapter 39: The ANGLE Project: Implementing OpenGL ES 2.0 on Direct3D
39.1 Introduction
39.2 Background
39.3 Implementation
39.3.1 Coordinate Systems
39.3.2 Shader Compiler and Linker
39.3.3 Vertex and Index Buffers
39.3.4 Textures
39.3.5 Vertex Texture Fetch
39.3.6 Primitive Types
39.3.7 Masked Clears
39.3.8 Separate Depth and Stencil Buffers
39.3.9 Synchronization
39.3.10 Multisampling
39.3.11 Multiple Contexts and Resource Sharing
39.3.12 Context Loss
39.3.13 Resource Limits
39.3.14 Optimizations
39.3.15 Recommended Practices
39.3.16 Performance Results
39.4 Future Work
39.5 Conclusion
39.6 Source Code
Bibliography
Chapter 40 SceneJS: A WebGL-Based Scene Graph Engine
40.1 Introduction
40.2 Efficiently Abstracting WebGL
40.2.1 Draw-List Compilation
40.2.2 State Sorting
40.3 Optimizing the Scene
40.3.1 Texture Atlases
40.3.2 VBO Sharing
40.3.3 Sharable Node Cores
40.4 Picking
40.5 Conclusion
Bibliography
Chapter 41: Features and Design Choices in SpiderGL
41.1 Introduction
41.2 Library Architecture
41.3 Representing 3D Objects
41.3.1 The Model Layer Stack
41.4 Direct Access to WebGL Object State
41.4.1 The Problem
41.4.2 A Solution
41.4.3 Bind Tracking and Binding Stack with
SGL current binding
41.4.4 Direct Object Access with SGL direct state access
41.4.5 Drawbacks
41.5 WebGLObject Wrappers
41.5.1 Keep Wrappers Updated with
SGL wrapper notify
41.6 Conclusion
Bibliography
Chapter 42: Multimodal Interactive Simulations on the Web
42.1 Introduction
42.2
-SoFMIS Design and Definitions of
Modules
42.3 Framework Implementation
42.3.1 Modularity
42.3.2 Shaders
42.3.3 File Format
42.4 Rendering Module
42.5 Simulation Module
42.6 Hardware Module
42.7 Case Study: LAGB Simulator
42.8 Conclusion
Bibliography
Chapter 43: A Subset Approach to Using OpenGL and OpenGL ES
43.1 Introduction
43.2 Making Legacy Code Modern
43.2.1 Immediate Mode vs. Vertex Attribute Arrays
43.2.2 Primitive Choices
43.2.3 Bitmaps and Polygon Stipples
43.3 Keeping Code Maintainable across API Variants
43.3.1 Vertex and Fragment Processing
43.3.2 GLX vs. EGL
43.3.3 Vertex Array Objects
43.3.4 Wireframe Mode
43.3.5 Texture Wrap Modes
43.3.6 Non-Power-of-Two Textures
43.3.7 Image Formats and Types
43.3.8 Image Layouts
43.3.9 Shading Language
43.4 What if I Need a Specific Piece of Functionality?
43.5 Conclusion
Bibliography
Chapter 44: The Build Syndrome
44.1 Introduction
44.2 Using Utility Libraries
44.2.1 “Hello World” with GLUT
44.2.2 “Hello World” with Qt
44.2.3 “Hello World” with EGL
44.3 OpenGL Agnosticism
44.4 Configuration Spaces
44.5 Metabuilds and CMake
44.6 CMake and the Configuration Space
44.7 CMake and Platform Specifics
44.7.1 Windows
44.7.2 Mac OS X
44.7.3 iOS
44.8 Conclusion
Bibliography
About the Contributors
Woojin Ahn
Alina Alt
Edward Angel
Nakhoon Baek
Mike Bailey
Francesco Banterle
Jesse Barker
Venceslas Biri
Nicolas Capens
Won Chun
Patrick Cozzi
Cyril Crassin
Suvranu De
Charles de Rousiers
Daniel Dekkers
Marco Di Benedetto
Aleksandar Dimitrijevi ´ c
Chris Dirks
Benjamin Encz
Lin Feng
Alexandros Frantzis
Lionel Fuentes
Fabio Ganovelli
Simon Green
Stefan Gustavson
Tansel Halic
Ashraf Samy Hegab
Adrien Herubel
Se ´bastien Hillaire
Ladislav Hrabcak
Scott Hunter
Lindsay Kay
Brano Kemen
Pyarelal Knowles
Daniel Koch
Geoff Leach
Hwanyong Lee
Christopher Lux
Dzmitry Malyshau
Arnaud Masserann
Jon McCaffrey
Bruce Merry
Muhammad Mobeen Movania
Bruno Oliveira
Matt Pettineo
Daniel Ra ´kos
Anto ´nio Ramires Fernandes
Christophe Riccio
Philip Rideout
Omar A. Rodriguez
Jochem van der Spek
Dirk Van Gelder
Shalini Venkataraman
Fabio Zambetta
Index
Poster