OpenGL

You are currently browsing articles tagged OpenGL.

I’ve learnt of two new books in the past few weeks, worth mentioning as books to check out at SIGGRAPH (or using Amazon’s “Look Inside”, of course):

iPhone 3D Programming: Developing Graphical Applications with OpenGL ES, by Philip Rideout, O’Reilly Press. A better title might have been “Programming OpenGL ES on the iPhone”, as it focuses on OpenGL ES more than on the iPhone per se. Which is fine; there are already lots of iPhone programming books, and almost none that are focused more on OpenGL ES itself (the only other OpenGL ES 2.0 book I know of is this one). The book is C++ oriented, with some Objective C as needed for glue. From my brief skim, this looks like a well-illustrated, readable guide that hits many different effects: reflection maps, skinning, antialiasing, etc. That said, I haven’t yet had the opportunity to program on any mobile devices, so can’t give an expert review. When I do give it a try, this looks like the book I’ll read first.

Update: A draft of this book is free on the web, see it here. It looks to be essentially the same as the published work (but with some hand-drawn figures), and is nicer in some ways, as the pages allow color images (always good for a graphics book).

Light & Skin Interactions: Simulations for Computer Graphics Applications, by Gladimir V. G. Baranoski and Aravind Krishnaswamy, Morgan-Kaufmann Press. This one’s out of my league as a casual skim. Paging through and seeing “the eumelanin absorption coefficient is given by…” and “Scattering in either the stratum corneum or epidermis…” shows me how little I know of the world in general. Anyway, interesting to see a whole book about this critical type of material. Searching through it, there’s minimal coverage of, for example, d’Eon and Luebke’s work, so I can’t say it has much direct application to interactive computer graphics at this point.

That’s all for the real books…

The half a book (at best): Game GPU Graphics Gems: Real-Time Rendering The Redux (aka GGGG:RTRTR), by anyone who wants to edit it. When I “edited” the quasi-book Another Introduction to Ray Tracing a few months ago, I thought back then that I’d start another book for SIGGRAPH. Like the first stunning collection, this was an hour of work gathering Wikipedia articles (hardest part was choosing a cover). There are plenty more articles to gather about interactive rendering, and you’re most welcome to add any good ones you find to this book, make your own, etc. – it’s a wiki page, after all. More seriously, I like having a single, tight page of links to Wikipedia articles about interactive rendering, vs. wandering around and haphazardly seeing what’s there.

Tags: , , , , ,

7 things, with images for each as some quick eye candy – is it worth my adding these images?

  • Here’s a nice rundown of much of the graphical goodness (and badness, e.g. temporal antialiasing) of the Halo: Reach beta. It’s worth a skim just to get a sense of the state of the art in a wide range of areas. The motion blur video appears to not be available currently. (thanks, Mauricio)
  • Unlimited Detail Technology is a voxel-based renderer with an interesting history: it was developed by a self-taught hobbyist who once ran a supermarket chain. There’s been interest in voxels for awhile, e.g. Jon Olick’s SIGGRAPH presentation in 2008 (slides here). Voxel rendering reminds me of the CPU-side heightfield renderer used in Novalogic’s Comanche and Delta Force game series from 1992 on. Novalogic’s was a 2.5 D system using contour following, while the Unlimited Detail system is full 3D voxels. Looking at UD’s presentations, it seems like a form of 3D clipmapping, where the level of detail of the voxels needed are determined by distance. The look reminds me of dribble sand castles. The coolest part: no GPU needed, it’s all CPU. I can imagine 18 limitations to this system: animation/deformation, sharp-edges not possible, shading models have limitations, transparency doesn’t work, textures are difficult to apply, fuzzy objects can’t be rendered, etc. Still, fun to see and a fascinating option. (another thanks, Mauricio)
  • The Ruin Island demo was created by some students in France. Parallax occlusion mapping, depth of field, NPR toon rendering, motion blur, glow and bloom, and more – it’s a grab-bag of effects in OpenGL. What’s nice is that the source code is provided. (Geeks3D)
  • Norbert Nopper has a small set of standalone OpenGL 3.2 and GLSL 1.5 tutorial programs with code for various effects. (Morgan McGuire)
  • The demoscene demo agenda circling forth uses particle clouds for a beautiful look. Note that the links for the video and demo are just under the image at the top of the page.
  • The photorealistic Octane Renderer uses CUDA for acceleration. To try it out you’ll need a fairly up-to-date NVIDIA driver, the demosuite, and the executable. It’s actually pretty cool to see the frameless rendering in action, it’s quite interactive for their simple scenes. There’s golden thread rendering: the longer you sit, the better the image gets. (Geeks3D)
  • 3D printing with ice. (BoingBoing)

Halo: Reach motion blur:

Unlimited Detail voxel image:

Ruin Island demo:

OpenGL 3.2 Nopper demo image:

agenda circling forth:

Octane Rendering, after 2 merged frames (interactive update) and after 5685 frames (a few minutes):

3D ice printing:

Tags: , , , ,

  • The first three are from Geeks3D, which is a worthwhile site I frequently reference. First: some noise textures, in case you don’t feel like making some yourself.
  • Next, a night-vision filter in GLSL, developed with their GeeXLab tool for prototyping shaders.
  • Finally, PyOpenGL_Lab, which calls OpenGL from Python. Interpreted languages like Python are lovely in that there’s no compilation step, making experimentation much more rapid. If you’re a Perl person, there’s this module.
  • Daniel Rákos has an article about how to perform instance culling using the GPU, using OpenGL 3.2. The basic idea is to run the bounding volumes through the geometry shader for frustum culling and pipe out results as transform feedback, which is then used in a second pass for which instances to actually render. This type of technique has been done using DirectX (e.g., Froblins), Daniel shows how to do it in OpenGL and provides source.
  • Aras Pranckevičius has a worthwhile post on deferred rendering and mipmap bugs, along with some good follow-up comments.
  • John Ratcliff’s Code Suppository has lots of little handy graphics code tidbits and chunks. It’s moving here and here on Google Code, but the original page is much easier to skim.
  • Wolfgang Engel provides a nice little page of books and resources he recommends for upcoming graphics programmers, with some good follow-up comments. I hadn’t heard of the 3D Math Primer before. It gets high ratings on Amazon, and you can use Look Inside. Skimming it over, it does look like a good book, covering many topics with the space they deserve (vs. our sometimes quick zoom through them in our own book). Code snippets are also given throughout. The book mentions “The First Law of Computer Graphics,” but unfortunately the pages explaining it are blocked. Happily, I found it on Google Books: “If it looks right, it is right”. Whew, good, I honestly was concerned there was some law I had been breaking all these years.

… and I’m all caught up, my queue is empty! Well, there will be a special post tomorrow.

Tags: , , , , , ,

I use a LIFO stack for these link collections, so we’re starting to get into older news. Olds? Still good stuff, though.

  • I hadn’t noticed this set of notes before from Valve, “Post Processing in the Orange Box.” It’s about sRGB (think, gamma correction), tone mapping (think, rescaling using the histogram), and motion blur (think, types of blur). Interesting that a variable frame rate combined with blur made people sick. They’d also turn blur off if a single frame was taking too long. (from Morgan)
  • Wolfgang Engel has posted DirectX 11 and DirectX 10 pipeline overview charts. In a similar vein, Mark Kilgard has a talk about the changes from OpenGL 1.0 to 3.2 with some worthwhile data flow diagrams and other material.
  • openSourceVFX.org is a catalog of open source projects that are particularly suited for film visual effects and animation work. It is maintained by professionals in the field, so the resources listed are those known to actually be used and production-worthy. (thanks, Larry)
  • Here’s another PhysX demo, of water—a little jelly-like (good spray is hard, since it’s so fine-grained), but pretty amazing to see happen at interactive rates.
  • One resource I didn’t recall for my blog entry about tools for teaching about graphics and game creation: Kodu, from Microsoft. For grade schoolers, it uses a visual language. Surprisingly, it’s in 3D, with a funky chiclet terrain system. For still more tools, check the comments on the original blog entry—some great additions there. (pointed out by Mark DeLoura)
  • Another interesting graphics programming tool is NodeBox 2, now in beta. It uses a node graph-based approached, see some examples here.
  • The story of Duke Nukem in Wired is just fascinating. We all like to tell and listen to stories, so it’s hard to know how true any narrative is, but this one seems reasonably on the mark. A little balance is provided by Raphael van Lierop.

Tags: , , , , , , , , , ,

Comin’ at ya, lots of one-liners, vs. yesterday’s verbose posting.

Tags: , , , , , , , ,

With the excitement of Ground Hog’s Day and James Joyce’s birthday over, it’s time to take off the silly paper hats and get back to writing “7 things” columns. Here goes:

  • Jeremy Shopf gives a nice summary of recent ambient occlusion papers. AO is becoming the new Shadows—every conference must have a paper on the topic. Honestly, it’s amazing that some of these ideas haven’t popped up earlier, like the line integral method. If you accept the basic approximation of AO from the start, then it’s a matter of how to best integrate the hemisphere around the point. I’m not downplaying the contribution of this research. Just the opposite, it’s more along the lines of “d’oh, brilliant, and why didn’t anyone think of that earlier?” The answer is both, “because those guys are smart” and, “they actually tried it out, vs. thinking of an idea and not pursuing it.”
  • Thinking about C++ and looking at my old utilities post, I realized I forgot an add-on I use just about every day: Visual Assist X. This product makes Visual Studio much more usable for C++. Over the years it’s become indispensable to me, as more and more features get integrated into how I work. I started off small: there’s a great button that simply switches you between the .cpp and .h version of the file. Then I noticed that other button which takes a set of lines I’ve selected and comments them out in a single mouse press, and the other button that uncomments them back. Then I found I could add a control that lets me type in a few characters to find a code file, or find a class. On and on it goes… Anyway, there’s a free trial, and for individuals it’s an entirely reasonable (for what you get) $99 license. By the way, you really don’t need to get the maintenance renewal every year.
  • As you may know, MIT has had a mandate for a number of years to put all of its courses online in some form—there are now 1900 of them. The EE & CS department, naturally enough, has quite a selection. The third most visited course on the whole site is Introduction to Computer Science and Programming, from Fall 2008 (and I approve: they use Python!). There’s only one computer graphics course, from 2003, but it covers unchanging principles and concepts so the “ancient” date is a minor problem.
  • Naty pointed out this article about deferred rendering. He notes, “A nice description of a deferred rendering system used in a demo—of particular interest is the use of raytraced distance fields for rendering fluids, and the integration of this into the overall deferred system.”
  • A month and a half ago I listed some articles about reconstructing the position or linear z-depth in a shader. Here’s another.
  • It’s the ongoing debate, back again. No, not dark vs. milk chocolate, nor Ferrari vs. Porsche, but DirectX vs. OpenGL. My own feeling is “whatever, we support both”. By the way, the upcoming book GPU PRO (which also has a blog, and has just been listed on Amazon) includes an in-depth article on porting from DX9 to OpenGL 2.0. Mark Kilgard’s presentation also discusses the differences, including the coordinate space and window space conventions.
  • I love human pixels. The Arirang Festival in North Korea is a famous example, check out Google Images. But that’s just a card stunt, impressive as it is. This video shows a technique I hadn’t seen before (note that some of it is sped up—check the speed of the people on the field—but still fantastic). There are other videos, such as this and this.

Tags: , , , , , ,

Here are 7 for the day:

Tags: , , , , , ,

While at SIGGRAPH I like to look at new books at the booths. One you may wish to check out is Graphics Shaders: Theory and Practice, from AK Peters (or just use “Look Inside” on Amazon). I received a review copy and skimmed through it. If you’re interested in programming in GLSL 1.2 (part of OpenGL 2.1), consider looking at this one. A minor problem is that it’s not quite as up-to-date as the Orange Book (now on OpenGL 3.1), but the difference in core concepts between language versions is not large. The Graphics Shaders book is full color and comes with a lot of GLSL code examples. It has a bias towards scientific visualization, though not so much that it neglects the basics. I particularly enjoyed the chapter on noise, as it gave one of the clearest explanations I’ve seen on the differences between various types of basic interactive noise functions. One or two elements in the book are a little weak – the flowcharts for pipelines are often too small and difficult to read, for example – but all in all this looks like a solid contribution to the field. Don’t expect more elaborate effects, e.g., shadows are not touched upon. It does cover the basics, plus some additional topics like image post-processing (not normally covered in texts I’ve seen). One of the authors wrote a nice learning tool for GLSL, glman, free for download. If you find you like this tool, definitely consider the book.

Another book I noticed recently is Fluid Simulation for Computer Graphics. This is a topic I know little about, I was just interested to see that there’s any book at all. It looks pretty equation-filled, so is definitely for the serious practitioner.

Speaking of fluid simulation, Intel has an article on this topic for games. One of the chief strengths of any publication is that its staff makes a decision based on merit as to what is published and what is culled. So, I have to admit to being leery of anything that says, “Sponsored Feature”, as that means editorial review and decision-making are gone. I tend to err on the side of ignoring such articles (there’s plenty to read already). That said, Intel’s had quite a number of these articles recently, including such topics as instancing, ocean fog, FFT’s for image processing, and quite a few on parallelism.

In the “clearing the queue” category of links, I don’t think I ever pointed out this handy page, which presents all AMD/ATI and NVIDIA presentations at GDC 2009.

There’s now a (not very active, but at least it exists) Microsoft DirectX blog.

On the OpenGL front, NVIDIA has introduced bindless graphics to help avoid L2 cache misses. I will be interested to see how APIs evolve, as the elements in the current APIs that are bottlenecks are not so much CPU or GPU limitations as due to the API constructs themselves.

Thing for the day: an advertisement with interesting stippling.

Tags: , , , , , , , ,

This and That

I’ll someday run out of titles for these occasional summaries of new(ish) resources, but in the meantime, this one’s “This and That”.

Christer Ericson’s article on dealing with grouping and sorting objects for rendering is excellent. It mostly depends on input latency, but has concepts that can be applied in immediate mode.

An element that continues to renew the field of computer graphics is that the rules change. This article is about taking Quake 2 (from 1997) and moving it to a modern GPU.

If you haven’t seen it yet, Farbrausch’s demo “debris” is truly impressive. It’s only 183,462 bytes, and is absolutely packed with procedural content. Download here (last link works). Or be lazy and watch on YouTube.

NVIDIA’s pulled together its resources for shadow generation and ambient occlusion all onto one handy page (plus ray tracing – just one entry so far, but it’s a good one).

How to deal with various rendering paradigms on multiple platforms? GRAMPS looks intriguing.

Gamasutra put a useful Game Developer article online, all about commercial middleware game engines currently available.

OpenGL will always exist, since Macs and Linux need it. It’s easier to use in college courses because of its clarity and readability. But otherwise the pendulum’s swung far towards DirectX. Phil Taylor comments on and gives some historical context to the controversy around the latest release, OpenGL 3.0.

A nice trend for OpenGL is that people continue to write useful bits, such as GLee, which manages extensions.

New info on older effects: blur and glow, volumetric clouds, and particle systems.

The glorious teapot. I like “a wireframe view”. Yes, the real thing is taller than the synthetic model, as the model makers were compensating for non-square pixels.

“What’s the future hold?” is always a fun topic, one we’ve used each edition to end our book. I liked this presentation on SlideShare for its sheer “here are a hundred things that hurtle us towards the Singularity” feel, though I don’t buy it for a minute. SlideShare, where it is hosted, is a pleasant medium-attention-span kind of place, with all sorts of random and fun slidesets.

Finally, I am pleased to find that LittleBIGPlanet is just as gorgeous as it looked like it would be. I’ve played myself for only a bit, but walking by when my kids are playing I find I have to stop and stare.

Tags: , , , , , , , , , , ,

The Khronos group has finally released the spec for OpenGL 3.0. More details can be found here.

Tags:

Newer entries »