No simple way, as far as I can tell. You could try the following, though:

1. Include the header "allegro5\internal\aintern_shader.h" so that you get the definition of ALLEGRO_SHADER.

2. Get your shader pointer and cast it to an unsigned char pointer, so that you can do simple byte-length pointer arithmetic.

3. Add sizeof(ALLEGRO_SHADER) to this pointer.

4. Add ((sizeof(GLuint) * 2) to this pointer

5. Cast this pointer to a GLuint pointer

If everything worked as expected, this GLuint pointer should now point to the memory holding the program ID.

Note that this might not work at all. Like, if ALLEGRO_SHADER_GLSL_S happens not to be a tightly packed struct, this method will fail. Even if it doesn't fail, note that this is a highly platform-specific solution, becaues different compilers might pack structs differently (even the same compiler could pack structs differently depending on whether you're doing a 32- or a 64-bit build). If you go with this method, make sure to thoroughly test the outcome on all platforms you're interested in. The foolproof version would be to either build a GL shader yourself or build the Allegro library, though.

Hey thebicnic,

Good news is you can do it, I've used essentially the exact same process you describe to add a GL_TEXTURE_CUBE_MAP / sampler_cube and extending it to sampler3d should be very similar. There are a few critical things:

1) You should upgrade to the latest version of Allegro 5.1.13. It has al_get_opengl_program_object() which was literally just added in this version. Here's the change log. Building and/or getting Allegro since 5.1.9 has been made quite a bit easier than Previous versions, across all platforms. Shader API has also improved.

2) Always reference the latest documentation from the official Allegro 5 repo. It's the most up to date. The manuals on allegro.cc are out of date - don't use them.

3) To add anything OpenGL specific to Allegro 5 you just need to #include <allegro5/allegro_opengl.h> (and link the opengl libraries to build).

4) Here is how I implemented adding GL_TEXTURE_CUBE_MAP and sampler_cube:
- cubemap.h
- cubemap.cpp
- setting the cube map uniform in the shader
- here's a vertex shader that uses the cubemap
- here's the corresponding fragment shader that uses the cubemap

Shaders are relatively-ish new. Their behavior is a little undocumented and you will find some peculiarities, for example with al_set_target_bitmap() which stores/flushes/resets some state, including projection. That is, for example, each bitmap has its own projection transform. Also, when using al_draw_bitmap(), al_draw_prim(), and friends, Allegro binds the first texture TEXTURE0 to the ALLEGRO_BITMAP that you pass into those functions (or does nothing if you pass NULL).

Allegro could really benefit from a great shader tutorial since the exact bounds of these behaviors is still yet to be outlined in the docs. They're completely usable, however.

Ok, so I'm on 5.1.13 and I can get the program ID now.

Running into issues with texture3d() / glTexImage3D() now.

Does anyone have a working code snippet of generating/binding a 3D texture buffer? I can't imagine its all that different from 2D and the (very few) examples I've seen of glTexImage3D() appear to be very similar (to each other, and to what I have.)

Marks cube map is interesting and I don't see anything that is being done there that I'm not doing (albeit for texture3d) in my own code.

It seems like no matter what my data is (all bytes = 0 or all bytes = 255) I cant read anything sensible in the shader using texture3d() (ie: from vec(1,1,1) or vec(0,0,0) or vec (0.5,0.5,0.5) texture3d() is still returning color values like (0.1,0.9,0.1) when I've uploaded a buffer full of zeros?

I'm still grabbing glGetError after every single GL call and nothing is throwing an error with the shader compile/link or attaching the texture to a uniform at draw time.

I'm totally stumped. Day #2 ....

EDIT: Well.. moments after I posted this, of course, I discovered that I was passing a reference of a pointer to glTexImage3D() so.. yeah... don't do that.

... I still blame OpenGL for my basic C++ snafu

Color correction look-up table (LUT)

Other than that, it appears to be used for volumetric rendering (clouds, water?) and maybe voxel rendering but thats all way above my head!

Here's a brief overview of my current color correction lookup table solution. I just learned about the possibility of doing this last week, so I am by no means an expert.

I just thought I'd share cause there doesn't seem to be any reasonably complete examples anywhere, let alone any that use Allegro. While this may have a few pieces missing, I think all of the heavy lifting is documented... If I left something important out, let me know.

I'm no artist, but see attachments for examples of what a LUT can do to transform an image in real time, with no other processing. ("lut-natural" is the way the game draws without any color correction)

Also see attachments for a neutral LUT (RGBTable16x1.png) that you can use to build your own.

How it works...

To make a LUT, just draw your game as you normally would, screenshot, take it into Photoshop and paste a neutral LUT into a corner somewhere. Then modify the colours, saturation, hue, contrast, etc until the image looks how you want.
Then just take the LUT portion and save it as a new PNG which we'll load into the shader later.

This "look up table" basically contains every colour that you can draw, in a 3D cube, and corrected using the rules we used to modify the colours in Photoshop. When you draw a pixel with a shader, all the colour correction shader will do is use the source colour as a position in the LUT cube and see what the new colour should be based on the LUT image we loaded up. 16x16x16 colours is enough to do a decent linear interpolation for my needs but you may want to go to 32x32x32 if you're into that sort of thing.

The Code...

At program start, call loadShaders() to load the pixel/vertex shaders and build any LUTs that are specified in LUTList / LUTStrings[].

buildLut() will take an image (ie: the PNG we created above) and then load it into a GL_TEXTURE_3D array so that we can use Sampler3D in our shader.

We can use Allegro to build the shaders as long as we can get the OpenGL ID later with al_get_opengl_program_object() so it'll require the latest version of Allegro to do it that way.

We can't use Allegro to bind the 3D texture to the shader though, so EnableLUTDrawing()
allows us to do that.

To draw using a lookup table, just enable the LUT shader with a specified table ID
for example:

PIXEL SHADER (Colour Correction)

VERTEX SHADER (DEFAULT)

Shader Manager (partial)