Блог

Мне было интересно, есть ли способ использовать объединение в GLSL. Я не видел никакой документации по этому поводу. Если нет, есть ли чистый обходной путь для использования объединения.

Я в основном хочу массив чего-то. И это что-то может быть одной из двух вещей, поэтому я хотел бы использовать объединение для его определения.

Спасибо!

PS Для этого может быть какой-то странный трюк с приведением, о котором я не знаю, не стесняйтесь предлагать лучший метод.

Редактировать:

Пример кода (не будет компилироваться, поскольку объединение недоступно):

 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 */
}
  

Кроме того, представьте, что A и B огромны, вы не хотели бы их дублировать.

Редактировать 2:

Вот еще немного информации, надеюсь, это поможет:

Эти данные будут поступать «извне» и будут зависеть от вершины. Его нужно было бы обрабатывать по-разному в зависимости от типа (A или B). К ним, вероятно, можно было бы получить доступ из VBO.

Поскольку мы говорим об атрибутах вершин, вы можете сделать это:

 layout(location = 0) vec4 floatVal;
layout(location = 0) ivec4 intVal;
  

OpenGL ссылается на это как наложения атрибутов, и это явно разрешено, со следующим предостережением. Либо доступен только один из атрибутов с псевдонимами, либо каждый путь кода через шейдер обращается только к одному из атрибутов. Так что, если вы защитите вычисление доступа и значения с помощью логического условия, все будет в порядке:

 //Don't use either variable yet

if(isFloat)
{
  //Do something with `floatVal`
}
else
{
  //Do something with `intVal`
}

//Don't use either variable again.
  

Ну, теоретически все будет в порядке. Сглаживание атрибутов — очень странный угловой случай, и маловероятно, что какие-либо основные программы, использующие OpenGL, действительно делают это. Это означает, что поддержка реализации, скорее всего, будет ошибочной (неиспользуемый код — это код, который не был протестирован). Поэтому я бы посоветовал вам переключать программы, если вы хотите убедиться, что ваш код действительно работает на разных платформах.

Согласно спецификации GLSL, ключевое union слово зарезервировано для будущего использования и действительно приведет к ошибке компиляции.

Одним из способов обойти это было бы поддержано GLSL, поскольку они поощряют вас использовать простые структуры данных (без злого выделения указателей или странных трюков с приведением), было бы использование массива struct с флагом.

 struct AandB {
   A a;
   B b;
   bool isA;
};
  

Затем вы можете использовать его по назначению с чем-то вроде этого:

 AandB foo;

if (a.isA) {
   /* a process */
}
else {
   /* b process */
}
  

Однако, если элемент может содержать ни один из типов, вы должны быть осторожны с тем фактом, что флаг изначально будет false и примет тип B. В этом случае обходным путем было бы использовать два флага и установить правильный.

Обновить:

Если использование памяти является проблемой, все еще есть обходной путь, но для этого нужна более забавная структура данных. Один из способов, который приходит на ум, — это наличие массива определений элементов, которые будут содержать индекс и флаг. Давайте представим эту структуру данных:

 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;
  

При повторении вы можете проверить флаг и перейти к связанному индексу, например, так, предполагая, что N_items это количество элементов, которые у вас есть:

 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 */
   }
}