OpenGL 4 for 2010


Published on

"OpenGL 4 for 2010" presented at NVIDIA Sponsored Session at SIGGRAPH 2010 in Los Angeles on July 28.

Barthold Lichtenbelt & Mark Kilgard

  • Be the first to comment

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide
  • Introduce Mark and myself
  • Before we delve into OpenGL, I wanted to make you aware of four new Quadro cards we announced yesterday, based on the Fermi architecture. Check them out in the NVIDIA booth, their performance is impressive! DHIC – Dual Host Interface Card
  • We also announced the new Mobile Workstation solution, the 5000m. We are showing one in use in the “family room” in the “HP Innovation Zone” in our booth.
  • Finally, Siggraph is where we introduce 3D Vision Pro as well. Again, come to the booth for more information. Now on to OpenGL!
  • One way to view the OpenGL offerings from NVIDIA is as a tool to enable awesome visual applications to be developed through a comprehensive stack of software solutions. We offer: Cg: A shading language and effects system to develop rendering effects and techniques, and deploy them on various platforms and APIs, including OpenGL. Scenix: OpenGL based professional scene graph used in many markets today. Automotive styling, visualization, simulation, broadcast graphics, and more. Applications can quickly add features such as stereo, SDI, 30-bit color, scene distribution and interactive ray tracing Optix: Is an interactive ray-tracing engine built on top of CUDA and OpenGL. Hybrid rendering, mixing of traditional graphics rendering and ray tracing, are also enabled. OptiX integrates with SceniX. With Optix, you accelerate an existing renderer, or build a new one yourself. Complex: Maintains interactivity for large scenes as they exceed the limits of a single GPU, allowing massive data sets to be explored, using multiple GPUs in a system. The CompleX engine can be adopted by any product using OpenGL, and can be enabled immediately by an application using SceniX Parallel Nsight is an advanced debugger and analyzer fully integrated with Visual Studio. It enables you to better see what is going on with your OpenGL, CUDA, Direct3D, DirectCompute or OpenCL application.
  • This is a close-up taken out of the Fermi Rocket Sled demo. This shows how hybrid rendering works. With traditional OpenGL rendering you generate your image, for example using SceniX, and then enhance it by using OptiX to add reflection and shadows. One of our experts on this, Tristan, is available if you have more questions on how you can do this in your application. Tristan, raise your hand please.
  • OpenGL enables every NVIDIA business, and therefore is extremely important for us. Some of them might not be immediately obvious, I will show more detail in the upcoming slides why this is the case.
  • Here I tried to list what recent initiatives we’ve introduced to enhance OpenGL usage, and enable you to build better, faster, more visually rich applications. First, NVIDIA continues to enhance the OpenGL API, and leverage that into OpenGL ES and WebGL. More on that later. Second, we recognize that there are different APIs, each with their own strengths to get a specific problem solved. Hence, we have and are actively working on ways for you to transfer data into and out of OpenGL into those other APIs. Third, with OpenGL we enable a long list of Quadro features, specifically aimed at the professional workstation market. The list is so long it doesn’t fit here. Hence [next slide]
  • I continued the list here. I am not going to go through the list in detail. I do want to point out that through Quadro and OpenGL you get access to all these workstation features, a top notch stable OpenGL implementation, and awesome support from our support team. We continuously add new features, based on feedback from you, our developers and customers.
  • OpenGL Interoperability means the ability to share data among different APIs. You can, for example, map a D3D surface as a texture or renderbuffer in OpenGL directly. Or map an OpenGL buffer object as a CUDA memory object. It is also possible to transfer data between two OpenGL contexts in a multi-GPU situation with maximum efficiency.
  • Here is an example of interop with CUDA. The application makes OpenGL and CUDA calls. For example, process a video stream in CUDA, then transfer it over to OpenGL using interop for more processing and display. This works on a single card as well as multi-card systems. Performance between Quadro cards will be higher than between GeForce cards.
  • This slide is almost the same as the previous one, except it shows interop between two OpenGL contexts, each talking to a separate graphics card. The application is using GPU affinity to direct rendering to a particular GPU. Again, you need interop to transfer the data from one card to the other. For example, to composite the final frame of a rendering split over many GPUs. Note that both GPU affinity and fast GL to GL interop with NV_copy_image are Quadro only solutions.
  • Tesla is the brand for high performance computing. Tesla solutions scale from a single board solution to multi-rack mounted data centers. Because of its extreme efficiency in computing, some developers see 100x times speedup over a quad-core CPU, which enables all kinds of new applications. In scientific fields like chemistry, fluid dynamics, electromagnetics, medical imaging, weather prediction, but also in financial analysis and prediction. Obviously, with a Tesla board and a Quadro board together in a system, you can build awesome visual applications. You will need to use interop, as I just talked about, for this.
  • Tegra is a system on a chip – a super low power complete visual computing processor. It is, or will be, deployed in many different mobile devices. OpenGL ES is a version of the OpenGL API for mobile platforms. You can think of OpenGL ES as offering that subset of OpenGL that is suitable for the capabilities of the mobile devices of today. Smart phones doesn’t need more introduction. For Cars, think of augmented driver reality, in dash navigation, a fully electronic instrument cluster like your speedometer, movie players for the kids in the back, but not for the driver, etc. Tablets are another big target market for Tegra. A handheld, lightweight computer that needs to run forever on a battery charge. Tegra is ideally suited for this application. And finally, Tegra is deployed in music players, like the Zune HD. Tegra offers a whole suite of APIs to make this all possible, including native support for OpenGL ES.
  • We fully support OpenGL 4 and GLSL 4 on GeForce, including the Compatibility and Core profiles. Traditionally, supporting OpenGL based games has and is important, however we realize you can do much more with OpenGL than write an awesome game. So called lifestyle applications use OpenGL, like the Adobe Creative Suite, to accelerate image processing and video processing. With the upcoming release of WebGL you’ll see more and more 3D content delivered through your browser. All these kind of applications we care about, and support on GeForce.
  • Next, OpenGL 4.0 introduces now programmability features But first a word about GLSL
  • After Mark’s deep-dive, I’ll pull you back up into the higher level view of where OpenGL fits in as the 3D graphics API.
  • OpenGL is the only Cross Platform 3D API. Every major Operating System provides a version or flavor of OpenGL. Windows, Mac OS, iOS, Linux and Android.
  • OpenGL is a desktop API, as you’ve seen by now. OpenGL ES is the sister API for mobile and embedded devices. By keeping both APIs closely aligned, content can flow from there up into OpenGL enabled platforms and back down to OpenGL ES enabled platforms. WebGL was announced last year. It provides JavaScript bindings to OpenGL ES and provides plug-in less 3D graphics in a web browser. WebGL gives you access to the GPU in the system inside of a browser. Beta implementations of WebGL are already available from Mozilla, Google and Opera. For NVIDIA this means we will support and enhance OpenGL and WebGL on GeForce and OpenGL ES and WebGL on Tegra for the mobile market.
  • Joke about quiz. This slide is a bit of an eye sore. Don’t worry if you can’t read it in the back. There will be a quiz later to make sure you caught all of it. Two points to make here – OpenGL is defined by the OpenGL ARB, the standards body responsible for moving OpenGL forward. OpenGL 4 is a collaborative effort among several companies, that also compete with each other in the market place. Without these companies working well together, there would not be an OpenGL 4. Second point I wanted to make, NVIDIA contributes the most technology. Not all of it, but most of it.
  • As you might know, I also chair the OpenGL ARB Working group. On Monday, OpenGL 4.1 was announced by The OpenGL ARB and Khronos. In early 2008 the OpenGL ARB realized it had to change the way it is developing APIs. As a result, the ARB has become very schedule driven, and is enabling all those HW gates in those advanced GPUs we all love, at a very rapid rate, in an incremental fashion. This in turn enables you, application developers, to build the best applications out there. Here is a quick overview of what is in OpenGL 4.1.
  • With Get program binary you can retrieve and set the binary for a program object. This enables an application to avoid the cost of compiling GLSL shaders over and over again. One usage model would be to compile shaders once after the application is installed, query the program binaries, and then store them away to be used on the next application invocation. Program binaries can also be created by offline compilers. Loading a binary can fail, for example when the HW has changed or a driver has been updated. Therefore it is advised that the GLSL source code is always available to re-compile in an event like this. OpenGL 4 has five programmable stages. Vertex, Tessellation Control, Tessellation Evaluation, Geometry and Fragment stages. Separate Shader Objects adopts a "mix-and-match" approach to specifying GLSL shaders independently for these different shader stages. Allowing the application to populate program objects with only the shader stages that best suit its needs. ES2 compatibility adds a few API commands that OpenGL ES 2.0 has, but OpenGL does not. Examples are ReleaseShaderCompiler, ShaderBinary, GetShaderPrecisionFormat and the float versions of DepthRange and ClearDepth. Plus the FIXED data type for vertex attributes . Vertex attrib 64 builds on the general 64 bit floating point support we added with OpenGL 4.0. This extension offers GLSL support and API support for providing 64 bit fp per component vertex data. ARB_viewport_array – This enables more efficient rendering if an application wants to render to several rectangles, by providing multiple viewports for the same rendering surface. The geometry shader selects which viewport to render into. ARB_shader_precision more precisely documents precision requirements for several floating point operations. It provides a minimum precision guarantee for algorithms that fall apart in low-precision cases. Note that all functionality is also available as ARB extensions, enabling OpenGL implementers to provide select pieces of functionality for older hardware, if so desired.
  • Robustness addresses three areas. 1) Out of bounds vertex buffer accesses cannot result in termination of an application. This behavior can be turned on and off with a context creation flag. 2) Queries that return data to the application now have an explicit parameter indicating how many bytes can be returned. 3) Detection of a graphics hw reset, so that an application can then decide to re-build the objects for that context, or not. A query is provided to indicate if the current context or another context was responsible for the graphics hw reset. This is an “opt in” behavior, which you specify when creating a context Shader stencil export effectively lets the fragment shader write a value to the stencil buffer, with a GL_REPLACE stencil operation. Debug output provides a mechanism to provide much more information about what is going on in the GL. Messages are returned back to the application through a callback mechanism or a list of messages that you can query. Messages can be generated by the GL API, the GLSL shader compiler, the application, a third-party library, or a debugger. Message can be errors, a performance warning, undefined behavior, affects portability etc. The stream of messages can be controlled by filtering various message properties. CL_event offers a mechanism to more efficiently share buffers between OpenGL and OpenCL, without flushing the graphics pipeline . You can associate a OpenCL event with an OpenGL sync object and then use the existing OpenGL Sync object API to synchronize your OpenGL commands with OpenCL commands.
  • I showed a similar slide for OpenGL 4.0 earlier in the talk. As you can see, OpenGL 4.1 is again a collaborative effort, with NVIDIA again contributing the most technology. In fact, we’ve done that for all of OpenGL 3 as well.
  • Come to the OpenGL BOF – and learn more about OpenGL 4.1, GLSL 4.1, Viewperf 11, updates to the OpenGL Ecosystem, and an awesome gDEBugger demonstration. To entice you to come, there will be free beer and soda, as well as some awesome give away prices, including a Quadro 5000 as a giveaway, just announced yesterday!
  • ×