Pete's GPU Notes

Running out of VRAM on OS X

Wed, 28 Jun 2006 12:31:25 -0800

OpenGL on OS X virtualizes texture memory. This means you can allocate an almost unlimited amount of textures, and the OS will keep them in system memory, and only copy them up to the graphics card when they're needed. This is a lot better than the old model of keeping all textures only in VRAM, and texture creation failing once you run out of memory there. But there's still cases where you have to worry about how much VRAM is available.

Debugging OpenGL on OS X

Mon, 12 Jun 2006 12:32:37 -0800

It's tough to debug OpenGL problems, especially with pixel shaders. I'll cover some tips for any platform, and then some of the OS X built-in tools that can help.

Fragment Program Utilities

Mon, 27 Jun 2005 17:11:01 -0800

Here's a couple of functions to check that a fragment program can be run, and to load it and return the ID. The code is inline below, or you can download it.

Fragment Program Reference

Wed, 18 May 2005 16:28:52 -0800

The OpenGL Extensions Guide has a great chapter on the ARB fragment program language, I recommend buying it, but there aren't many good references online. The most useful is the official spec, but it's designed as an exhaustive guide, not a quick reference for programmers. Here's a rundown of the instruction set, and some tips and tricks.

Mac PBuffers

Tue, 17 May 2005 17:25:12 -0800

If you ever need to do more image processing than you can with a single fragment program pass, you'll need to render to a texture. The best way to do that on OS X is using a pbuffer, here's some example code for creating and using them.

I've included the code inline below, or you can get a zip of the code from PBufferUtils.zip here

Emulating Bilinear Filtering

Tue, 17 May 2005 16:32:56 -0800

Most graphics cards that support float textures can't bilinear filter them. We can use a fragment program to do the filtering for us, but it's tricky to get right. Here's an example of how to do it:

GPU Optical Flow

Tue, 10 May 2005 18:02:50 -0800

Optical flow analysis is heavily used by video and film processing apps, to retime images smoothly, apply motion blur as a post-process, and guide the application of other processes. It's traditionally a slow operation, I wanted to see if a GPU version was possible.

Random Numbers in Fragment Programs

Tue, 10 May 2005 17:06:37 -0800

It's hard to write a fragment program that will calculate pseudo-random numbers. The usual random number algorithms need two things that we don't have on our GPU's:

Quick and Dirty Vectorization

Tue, 10 May 2005 17:05:45 -0800

There aren't many fast techniques for vectorizing an image into polygons that approximate the original, or that take advantage of 3d hardware, so here's one I've used.

Fragment Program Snippets

Tue, 10 May 2005 17:04:57 -0800

Here's some instruction sequences for common operations:

Fragment Programs-ATI R3xx vs NVidia NV34

Tue, 10 May 2005 17:03:01 -0800

ATI and NVidia cards have some differences it's important to know about when you're writing fragment programs to run on both.

Mac OpenGL contexts

Tue, 10 May 2005 17:02:30 -0800

A context is a container for the GL state information, things like the current color, transformation matrix, texture ID and anything else that needs to be remembered by OpenGL.

Straight Alpha and Bilinear Filtering

Tue, 10 May 2005 17:00:56 -0800

There's a subtle problem using graphics hardware to do bilinear filtering on straight alpha images.

Animating Worley Noise

Tue, 10 May 2005 16:38:33 -0800

Texturing and Modelling has a chapter by Steve Worley on using Voronoi diagrams to create a procedural noise pattern. I needed to find a way to animate and render this on a 2D plane using OpenGL.