Что такое более быстрый glUniform4f / glUniform4fv с учетом всех видов оптимизации?

С *v вариант в основном существует для установки униформы, которые имеют тип массива, спецификация OpenGL явно позволяет использовать варианты массива также для установки скалярных значений, используя количество единиц.

позвольте мне процитировать спецификацию OpenGL (подчеркивает добавил себя):

команды glUniform{1/2/3/4}{f / i}v можно использовать для изменения одна равномерная переменная или однородный массив переменных. Эти команды проходят счетчик и указатель на значения загружается в однородную переменную или массив однородных переменных. счет 1 следует использовать при изменении значения одна равномерная переменная, и количество 1 или больше может использоваться для изменения всего массива или его части.

это OpenGL 2.1 Spec, однако он гласит то же самое для OpenGL 4.2 Spec.

на самом деле наоборот разрешены. Предположим, у вас есть униформа типа vec3 v[2] и вы запрашиваете его местоположение с помощью glGetUniformLocation(), вернуть 6. Это значит, что 6 на самом деле расположении v[0].

теперь вернемся к первоначальному вопросу: какой вариант быстрее?

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

Е. Г. рассмотрим следующий код:

void glUniform1f(GLint  location,  GLfloat  v0)
{
    glUniform1fv(location, 1, &v0);
}

в этом случае вариант выбора будет быстрее. Однако возможен и следующий вариант:

void glUniform1fv(GLint  location, GLsizei count, GLfloat * value)
{
    int i;

    for (i = 0; i < count; i++) {
        glUniform1f(location, *value);
        value++;
        location++;
    }
}

в этом случае вариант без массива будет быстрее.

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

варианты выбора имеют и другие преимущества. Рассмотрим следующая функция:

struct v3 {
     GLfloat x;
     GLfloat y;
     GLfloat z;
};

void setUniform (GLint location, struct v3 * vPtr) {
    glUniform3f(location, vPtr->x, vPtr->y, vPtr->z);
}

разыменование vPtr три раза просто для вызова функции без массива довольно глупо и вряд ли когда-либо быстрее, чем следующая реализация:

void setUniform (GLint location, struct v3 * vPtr) {
    glUniform3fv(location, 1, (const GLfloat *)vPtr);
}

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