The Power of Leveraged Frameworks that workPosted: May 30, 2012
I was browsing the Opengl.org web site recently, when I ran across a talk by Mark Kilgard. The talk was at a recent GPU Technology Conference (GTC 2012 – San Jose). The talk was entitled “NVIDIA OpenGL in 2012“.
It was a general overview talk, covering the history of OpenGL, it’s present, and near future. There are lots of little details related to OpenGL of course, but there were a couple that stood out for me. At roughly 49:15 into the talk, there’s a slide entitled “What is path rendering?”, whith a bunch of 2D path rendered images on it. Now this gets really interesting.
Basically, if you’ve been doing 2D graphics for the past few years, you realize that the GPU revolution has largely left you behind. Yes, you can render milliions of triangles per second, but just try to render some nicely kerned text, say for a web page, and you’re pretty much on your own. OpenGL has got nothing for you, or rather, what it does have for you will leave you completely dealing with the rasterization and process, for the most part.
What this means is that if you want to render high quality path driven stuff, like what you find in postscript, OpenVG, or HTML text, you’re going to have to do a whole bunch of work. But wait! Seeing the sad state of affairs, perhaps feeling guilty for their sins, nVidia has decided to tackle the problem space of path based rendering, using the GPU to accelerate. What a novel idea! I think it stems from the fact that their growth market is underpowered mobile devices, which have GPUs. The more you can offload to the GPU the better as it’s more energy efficient for certain things than a CPU would be.
During the presentation, he talks about the various 2D APIs such as Quartz, OpenVG, Direct2D, Cairo, Skia, Qt::QPainter, Anti-grain… All APIs I’ve touched one way or another over the years. He goes on about the greatness of these new extensions, which apparently have been in the nVidia drivers for a while. Then I get to thinking.
I want 2D graphics. I want it to work across multiple platforms, I want it to be fast and efficient. At first I thought, maybe I should get Cairo and use that as my cross platform 2D graphics system. Eventually Cairo will likely utilize this new path rendering stuff, and I’ll eventually benefit. So, I looked at Cairo, took one look at the build system, and turned green. Then I had another thought.
OpenGL is already THE cross platform graphics API. And, since I have Lua, and more specifically LuaJIT with FFI, and I’ve already coded up my opengl interfaces, I can just use that, and it should work across multiple platforms.
So, sounds good. I went off to the nVidia site to see what I could see with regards to the using this newfangled path rendering stuff. Right now it’s only in the nVidia driver, so AMD, not so much. I took one of the whitepapers that has examples on it, and just started coding what was there. After a few turns of the crank, I was finally able to generate the image seen above.
Here’s one sequence of calls that I used:
local ogl = require "OglMan" ogl.glMatrixLoadIdentityEXT(GL_PROJECTION); ogl.glMatrixOrthoEXT(GL_PROJECTION, 0, 500, 0, 400, -1, 1); ogl.glMatrixLoadIdentityEXT(GL_MODELVIEW); ogl.glPathStringNV(pathObj, GL_PATH_FORMAT_SVG_NV, #svgPathString, svgPathString); ogl.glStencilFillPathNV(pathObj, GL_COUNT_UP_NV, 0x1F);
OglMan is my OpenGL Manager. It’s effectively the same thing as using the familiar GLEW (GL Extension Wrangler), but done up in Lua, not as an interop thing.
I was not familiar with any of these calls before I wrote this code. But, just putting ‘ogl.’ at the front of each one of them, I assumed they would just work, and they did! I was actually amazed at how simple it was to code up this example.
This speaks volumes to the ease of use of Lua as a rapid prototyping tools. To do the same in C, would take me a lot more scaffolding, compiling, sweating and praying. In my little HeadsUp harness, I can just code and go, trying things out, with zero “compile”.
At any rate, it’s nice to know that seeing the world through a Lua lense is not a bad thing. I am just as capable as anyone on any other platform. I am asking myself this question now… If I could have a high quality text renderer done using nothing more than the GPU, and whatever text rendering library I write in Lua, could I write a nicely specialized HTML viewer?