Is there a way to use an union in GLSL? - glsl

Question

I was wondering if there is a way to use an union in GLSL. I haven't seen any documentation about this. If not, is there a clean workaround to using a union.
I basically want an array of something. And that something might be either of 2 things, therefore I would like to use a union to define it.
Thanks!
P.S. There might be some weird casting trick to do this that I don't know about, feel free to suggest a better method.
Edit:
Code example(would not compile because union is not available):
struct A{
bool isA;
float value;
};
struct B{
bool isA;
int value;
};
/* union */
union AandB {
A a;
B b;
}
void main()
{
AandB foo;
if(foo.a.isA)
/* process on A */
else
/* process on B */
}
Also, imagine A and B are huge, you wouldn't want to duplicate them.
Edit 2:
Here's some more information, hope it helps:
This data would come from "outside" and be vertex specific. It would have to be treated differently depending on the type(A or B). They'd probably be accessed from a VBO.

Answer 1

Since we are talking about vertex attributes, you can do this:
layout(location = 0) vec4 floatVal;
layout(location = 0) ivec4 intVal;
OpenGL refers to this as attribute aliasing, and it is explicitly allowed, with the following caveat. Either only one of the aliased attributes is accessed, or each code path through the shader only accesses one of the attributes. So if you guard the access and value computation with a boolean condition, you'll be fine:
//Don't use either variable yet
if(isFloat)
{
//Do something with `floatVal`
}
else
{
//Do something with `intVal`
}
//Don't use either variable again.
Well, you'll be fine theoretically. Attribute aliasing is a very odd corner-case, and it's highly unlikely that any major programs that use OpenGL actually do this. Which means that implementation support will likely be buggy (code that isn't used is code that hasn't been tested). So I would advise you to switch programs if you want to make sure your code actually works across platforms.

Answer 2

According to GLSL specification, the keyword union is reserved for future use and will indeed result in a compilation error.
One way around that would be supported by GLSL, since they encourage you to go with straightforward data structures (no evil pointer allocation or weird casting tricks), would be to use an array of struct with a flag.
struct AandB {
A a;
B b;
bool isA;
};
Then, you can use it has intended with something like this:
AandB foo;
if (a.isA) {
/* a process */
}
else {
/* b process */
}
However, if an item has the possibility of containing neither of the types, you should be careful with the fact that the flag will be initially false and assume type B. In that case, a workaround would be to use two flags and set the correct one.
UPDATE:
If memory usage is an issue, there is still a way around, but it needs a funnier data structure. One way that comes in mind is having an array of item definitions that will hold an index and a flag. Let's imagine this data structure:
struct Item {
bool isA;
int index;
};
Item items[5];
A a[5];
B b[5];
Item firstAItem;
firstItem.isA = true;
firstItem.index = 0;
items[0] = firstAItem;
Item firstBItem;
firstBItem.isA = false;
firstBItem.index = 0;
items[1] = firstBItem;
When iterating, you could check the flag and go to the associated index, like this, assuming that N_items is the number of items you have:
for (int i=0; i<N_items; i++) {
Item currentItem = items[i];
if (currentItem.isA) {
A foo = a[currentItem.index];
/* do some stuff with foo */
} else {
B bar = b[currentItem.index];
/* do some stuff with bar */
}
}