• Пользовательские функции должны быть объявлены до первой ссылки на них.

• Эти функции автоматически компилируются компилятором, поэтому рекурсия не будет работать. Чтобы написать рекурсивный алгоритм, вы должны использовать шейдерные вызовы.

• Как и в языке RenderMan Shading Language, параметры для пользовательских функций всегда передаются по ссылке, поэтому изменения в пользовательской функции влияют на переменную, с которой была вызвана функция. Вы можете принудительно сделать параметр шейдера доступным только для чтения, используя перед ним ключевое слово const. Чтобы гарантировать, что пользовательская функция записывается в выходной параметр, используйте перед ним ключевое слово export.

• Количество пользовательских функций не ограничено

• Вы можете иметь более одного оператора возврата return в функции.

• Вы можете напрямую обращаться к глобальным переменным (в отличие от RenderMan Shading Language, вам не нужно объявлять их с помощью extern). Однако мы рекомендуем избегать доступа к глобальным переменным, поскольку это ограничивает вашу функцию работой только в одном контексте (там, где существуют эти глобальные переменные). Вместо этого передайте глобальные переменные функции в качестве параметров.

• Функции могут быть определены внутри функции (вложенные функции).

Пользовательский интерфейс, созданный из этой программы Houdini, будет минимальным, в основном просто имя переменной и общее текстовое поле, основанное на типе данных. Например, вы можете указать, что frequency (частота) должна быть слайдером с определенным диапазоном, и что clr следует рассматривать в качестве цвета (предоставляя ему интерфейс выбора цвета). Вы можете сделать это с помощью псевдокомментариев пользовательского интерфейса компилятора.

#pragma opname        noise_surf
#pragma oplabel        "Noisy Surface"

#pragma label    clr            "Color"
#pragma label    frequency    "Frequency"

#pragma hint    clr            color
#pragma range    frequency    0.1 10

surface noise_surf(vector clr = {1,1,1}; float frequency = 1;
           export vector nml = {0,0,0})
{
    Cf = clr * (float(noise(frequency * P)) + 0.5) * diffuse(normalize(N));
    nml = normalize(N)*0.5 + 0.5;
}

Вы можете использовать операцию точка (.) для получения доступа к отдельным компонентам вектора, матрицы или структуры (struct).

Для векторов имена компонентов фиксированы.

• .x или .u для ссылки на первый элемент vector2.

• .x или .r для ссылки на первый элемент vector и vector4.

• .y или .v для ссылки на второй элемент vector2.

• .y или .g для ссылки на второй элемент vector и vector4.

• .z или .b для ссылки на третий элемент vector и vector4

• .w или .a для ссылки на четвертый элемент vector4.

Выбор букв u,v/x,y,z/r,g,b произволен; те же буквы применяются даже если вектор не содержит точку или цвет.

Для матриц вы можете использовать пары букв:

• .xx для ссылки на [0][0] элемент

• .zz для ссылки на [2][2] элемент

• .ax для ссылки на [3][0] элемент

В дополнение, операция точка может использоваться для перестановки (swizzle) компонентов вектора. Например:

• v.zyx эквивалентно set(v.z, v.y, v.x)

• v4.bgab эквивалентно set(v4.b, v4.g, v4.a, v4.b)

Операции сравнения (==, !=, <, <=, >, >=) определяются, когда левая сторона того же типа, что и правая сторона, только для строковых, вещественных и целочисленных типов. Результатом операции является целочисленное значение.

Логические (&&, ||, и !) и побитовые (& |, ^, и ~) операции определены только для целых чисел.

Операции расположенные выше в таблице имеют более высокий приоритет.

• Когда вы применяете операцию к float и int, результатом является тип слева от оператора. То есть, float * int = float, тогда как int * float = int.

• Если вы добавляете, делите или вычитаете скалярное значение из вектора (int или float), VEX возвращает вектор того же размера, при этом операция применяется поэлементно. Например:

  {1.0, 2.0, 3.0} * 2.0 == {2.0, 4.0, 6.0}
  

• Если вы добавляете, умножаете, делите и вычитаете векторы разного размера, VEX возвращает вектор большего размера. Операция применяется поэлементно.

  Важно: "отсутствующие" элементы меньших векторов заполняются как {0.0, 0.0, 0.0, 1.0}

  {1.0, 2.0, 3.0} * {2.0, 3.0, 4.0, 5.0} == {2.0, 6.0, 12.0, 5.0}
  

  // Третий элемент vector2 рассматривается как 0,
  // но четвертый элемент рассматривается как 1.0
  {1.0, 2.0} + {1.0, 2.0, 3.0, 4.0} == {2.0, 4.0, 3.0, 5.0}
  

Вы можете определять функции внутри структур, чтобы организовать свой код и реализовать ограниченную форму объектно-ориентированного программирования.

• Вы можете использовать this внутри структурной функции, чтобы ссылаться на экземпляр структуры.

• Вы можете ссылаться на поля структуры внутри структурных функций по имени, как если бы они были переменными (например, basis - это аналог this.basis).

• Вы можете вызывать структурные функции в экземплярах структур с помощью операции ->, например, sampler->sample(). Обратите внимание, что внутри структурной функции вы можете вызывать другие методы в структуре с помощью this->method().

struct randsampler {
    // Поля
    int        seed;

    // Методы
    float sample()
    {
        // Структурные функции могут ссылаться на поля по имени
        return random(seed++);
    }
} 

cvex shader()
{
    randsampler sampler = randsampler(11);
    for (int i = 0; i < 10; i++)
    {
        // Использование -> для вызова метода экземпляра структуры
        printf("%f\n", sampler->sample());
    }
}

Это похоже на приведение типов в языке C++ или Java: вы преобразовываете значение одного типа в значение другого типа (например, int в float).

В некоторых случаях это необходимо, например, когда у вас следующая ситуация:

int a, b;
float c;
c = a / b;

В данном примере компилятор будет выполнять целочисленное деление (смотрите разрешение типов). Если вы хотите сделать деление с плавающей запятой, вам необходимо явно преобразовать a и b в числа с плавающей запятой (float):

int a, b;
float c;
c = (float)a / (float)b;

Это создает дополнительные инструкции для выполнения приведений, что может быть проблемой в разделах, чувствительных к производительности вашего кода.

VEX выполняет функции основываясь не только на типах аргументов (как C++ или Java), но и на возвращаемом типе. Для устранения неоднозначности вызовов функций с теми же типами аргументов, но с разными типами возвращаемого значения, вы можете использовать приведение функций.

Например, функция шума может принимать разные типы параметров, но также может возвращать разные типы: шум может возвращать либо float, либо vector.

В коде:

float n;
n = noise(noise(P));

…VEX может выполнить либо float noise(vector), либо vector noise(vector).

Для приведения вызова функции используйте следующую конструкцию имя типа( ... ), как в:

n = noise( vector( noise(P) ) );

Хоть это и выглядит как вызов ещё одной функции, данная конструкция ничего не делает, кроме устранения неоднозначности вызова функции внутри и не вызывает потери в производительности.

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

vector n = vector( noise(P) );        // Ненужное приведение функции
vector n = noise(P);

Поскольку приведение функций не генерирует никаких преобразований типов (оно просто выбирает функцию для вызова), её использование не сказывается на производительности. Может стать хорошим правилом, использование приведения функций там, где это возможно, и использовать приведение переменных только в тех случаях, когда требуется явное преобразование.