Функциональные спецификаторы

Металлический язык штриховки поддерживает следующие спецификаторы, ограничивающие, как может использоваться функция:

kernel

Параллельная данным функция, выполняющаяся по 1-, 2-или 3-мерной сетке.

vertex

Функция вершины, выполняющаяся для каждой вершины в потоке вершины и это генерирует на вершину вывод.

fragment

Функция фрагмента, выполняющаяся для каждого фрагмента (и его связанные данные) в потоке фрагмента и это генерирует на фрагмент вывод.

Функциональный спецификатор используется в начале функции перед ее типом возврата. Следующий пример показывает синтаксис для вычислить функции:

kernel void

foo(...)

{

    ...

}

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

Только графическая функция может быть объявлена с одним из vertex или fragment спецификаторы. Для графических функций тип возврата идентифицирует, является ли вывод, сгенерированный функцией, или на вершину или на фрагмент. Тип возврата для графической функции может быть void указание, что функция не генерирует вывод.

Функции то использование a kernel, vertex или fragment функциональный спецификатор не может вызвать функции, также использующие эти спецификаторы, или ошибка компиляции заканчивается.

Спецификаторы адресного пространства для переменных и параметров

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

• device (для большего количества подробных данных посмотрите Пространство адреса устройства),

• threadgroup (см. threadgroup Адресное пространство),

• constant (см. Пространство базового адреса),

• thread (см. Адресное пространство потока),

Все параметры графике (вершина или фрагмент) или вычисляют функцию, которые являются указателем, или ссылка на тип должна быть объявлена со спецификатором адресного пространства. Для графических функций параметр, который является указателем или ссылкой на тип, должен быть объявлен в device или constant адресное пространство. Для функций ядра параметр, который является указателем или ссылкой на тип, должен быть объявлен в device, threadgroup, или constant адресное пространство. Следующий пример представляет использование нескольких спецификаторов адресного пространства. ( threadgroup спецификатор поддерживается здесь для указателя l_data только если foo вызывается функцией ядра, как детализировано в threadgroup Адресном пространстве).

void foo(device int *g_data,

         threadgroup int *l_data,

         constant float *c_data)

{

    ...

}

Адресное пространство для переменной в объеме программы должно быть constant.

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

// an array of a float vector with 4 components

device float4 *color;

struct Foo {

    float a[3];

    int b[2];

};

// an array of Foo elements

device Foo *my_info;

kernel void
my_func(threadgroup float *a [[ threadgroup(0) ]], ...)
{
    // A float allocated in threadgroup address space
    threadgroup float x;

    // An array of 10 floats allocated in 
    // threadgroup address space
    threadgroup float b[10];
    ...
}

constant float samples[] = { 1.0f, 2.0f, 3.0f, 4.0f };

kernel void my_func(...)

{

    // A float allocated in the per-thread address space

    float x;

    // A pointer to variable x in per-thread address space

    thread float p = &x;

    ...

}

Аргументы функции и переменные

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

• буфер устройства — указатель или ссылка на любой тип данных в device адресное пространство (см. Буферы),

• постоянный буфер — указатель или ссылка на любой тип данных в constant адресное пространство (см. Буферы),

• a texture объект (см. Текстуры),

• a sampler объект (см. Сэмплеры),

• буфер, совместно использованный потоками в threadgroup — указатель на тип в threadgroup адресное пространство. (Этот буфер может только использоваться в качестве параметра с функциями ядра.)

Буферы (устройство и постоянный) указанный как значения аргументов к графике или функции ядра не могут быть alieased — т.е. буфер передал, поскольку значение аргумента не может наложиться, другой буфер передал отдельному параметру той же графики или функции ядра.

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

• расположение ресурса для параметра (см. Спецификаторы Атрибута для Определения местоположения Ресурсов),

• встроенные переменные, поддерживающие передающие данные между этапами стандартной функции и программируемого конвейера (см. Спецификаторы Атрибута для Определения местоположения Вводов На вершину),

• какие данные отправляются вниз конвейер от функции вершины для фрагментации функции (см. stage_in Спецификатор).

kernel void 
add_vectors(const device float4 *inA [[ buffer(0) ]], 
            const device float4 *inB [[ buffer(1) ]],
            device float4 *out [[ buffer(2) ]],
            uint id [[ thread_position_in_grid ]])
{
    out[id] = inA[id] + inB[id];
}

kernel void

my_kernel(device float4 *p [[ buffer(0) ]],

          texture2d<float> img [[ texture(0) ]],

          sampler sam [[ sampler(1) ]])

{

    ...

}

#include <metal_stdlib>
using namespace metal;

struct VertexOutput {
    float4 position [[ position ]];
    float4 color;
    float2 texcoord;
};

struct VertexInput {
    float4 position;
    float3 normal;
    float2 texcoord;
};

constexpr constant uint MAX_LIGHTS = 4;

struct LightDesc {
    uint   num_lights;
    float4 light_position[MAX_LIGHTS];
    float4 light_color[MAX_LIGHTS];
    float4 light_attenuation_factors[MAX_LIGHTS];
};

vertex VertexOutput 
render_vertex(const device VertexInput* v_in [[ buffer(0) ]],
              constant float4x4& mvp_matrix [[ buffer(1) ]],
              constant LightDesc& light_desc [[ buffer(2) ]],
              device float4* xform_pos_output [[ buffer(3) ]],
              uint v_id [[ vertex_id ]] )
{
    VertexOutput v_out;
    v_out.position = v_in[v_id].position * mvp_matrix;
    v_out.color = do_lighting(v_in[v_id].position, 
                    v_in[v_id].normal,
                    light_desc);

    v_out.texcoord = v_in[v_id].texcoord;

    // output position to a buffer
    xform_pos_output[v_id] = v_out.position;

    return v_out;
}

#include <metal_stdlib>
using namespace metal;

struct VertexInput {
    float4 position [[ attribute(0) ]];
    float3 normal   [[ attribute(1) ]];
    half4 color     [[ attribute(2) ]];
    half2 texcoord  [[ attribute(3) ]];
};

constexpr constant uint MAX_LIGHTS = 4;

struct LightDesc {
    uint   num_lights;
    float4 light_position[MAX_LIGHTS];
    float4 light_color[MAX_LIGHTS];
    float4 light_attenuation_factors[MAX_LIGHTS];
};

constexpr sampler s = sampler(coord::normalized, 
                              address::clamp_to_zero,
                              filter::linear);

vertex VertexOutput
render_vertex(VertexInput v_in [[ stage_in ]],
              constant float4x4& mvp_matrix [[ buffer(1) ]],
              constant LightDesc& lights [[ buffer(2) ]],
              uint v_id [[ vertex_id ]])
{
    VertexOutput v_out;
    ...
    return v_out;
}

#include <metal_stdlib>
using namespace metal;

struct VertexInput {
    float4 position [[ attribute(0) ]];
    float3 normal   [[ attribute(1) ]];
};

struct VertexInput2 {
    half4 color;
    half2 texcoord[4];
};

constexpr constant uint MAX_LIGHTS = 4;

struct LightDesc {
    uint   num_lights;
    float4 light_position[MAX_LIGHTS];
    float4 light_color[MAX_LIGHTS];
    float4 light_attenuation_factors[MAX_LIGHTS];
};

constexpr sampler s = sampler(coord::normalized, 
                              address::clamp_to_zero,
                              filter::linear);

vertex VertexOutput
render_vertex(VertexInput v_in [[ stage_in ]],
              VertexInput2 v_in2 [[ buffer(0) ]],
              constant float4x4& mvp_matrix [[ buffer(1) ]],
              constant LightDesc& lights [[ buffer(2) ]],
              uint v_id [[ vertex_id ]])
{
    VertexOutput vOut;
    ...
    return vOut;
}

struct VertexOutput {
     float4 position [[ position ]];
     float4 color;
     float2 texcoord;
}; 

vertex VertexOutput 
process_vertex(...)
{
    VertexOutput v_out;

    // compute per-vertex output
    ...

    return v_out;
}

struct MyFragmentOutput {
    // color attachment 0
    float4 clr_f [[ color(0) ]]; 

    // color attachment 1
    int4 clr_i [[ color(1) ]]; 

    // color attachment 2
    uint4 clr_ui [[ color(2) ]]; 
};

fragment MyFragmentOutput
my_frag_shader( ... )
{
     MyFragmentOutput f; 
     ....
     f.clr_f = ...;
     ...
     return f;
}

#include <metal_stdlib>
using namespace metal;

struct VertexOutput {
    float4 position [[ position ]];
    float4 color;
    float2 texcoord[4];
};

struct VertexInput {
    float4 position [[ attribute(0) ]];
    float3 normal   [[ attribute(1) ]];
    half4 color     [[ attribute(2) ]];
    half2 texcoord  [[ attribute(3) ]];
};

constexpr constant uint MAX_LIGHTS = 4;

struct LightDesc {
    uint   num_lights;
    float4 light_position[MAX_LIGHTS];
    float4 light_color[MAX_LIGHTS];
    float4 light_attenuation_factors[MAX_LIGHTS];
};

constexpr sampler s = sampler(coord::normalized, 
                              address::clamp_to_zero,
                              filter::linear);


vertex VertexOutput
render_vertex(VertexInput v_in [[ stage_in ]],
              constant float4x4& mvp_matrix [[ buffer(1) ]],
              constant LightDesc& lights [[ buffer(2) ]],
              uint v_id [[ vertex_id ]])
{
    VertexOutput v_out;
    v_out.position = v_in.position * mvp_matrix;
    v_out.color = do_lighting(v_in.position, 
                              v_in.normal,
                              lights);
    ...
    return v_out;
}

#include <metal_stdlib>
using namespace metal;

struct VertexOutput {
    float4 position [[ position ]];
    float4 color;
    float2 texcoord;
}; 

struct VertexInput {
    float4 position;
    float3 normal;
    float2 texcoord;
};

constexpr constant uint MAX_LIGHTS = 4;

struct LightDesc {
    uint   num_lights;
    float4 light_position[MAX_LIGHTS];
    float4 light_color[MAX_LIGHTS];
    float4 light_attenuation_factors[MAX_LIGHTS];
};

constexpr sampler s = sampler(coord::normalized, 
                              address::clamp_to_border,
                              filter::linear);

vertex VertexOutput
render_vertex(const device VertexInput* v_in [[ buffer(0) ]],
              constant float4x4& mvp_matrix [[ buffer(1) ]],
              constant LightDesc& lights [[ buffer(2) ]],
              uint v_id [[ vertex_id ]])
{
    VertexOutput v_out;
    v_out.position = v_in[v_id].position * mvp_matrix;
    v_out.color = do_lighting(v_in[v_id].position, 
                              v_in[v_id].normal,
                              lights);
    v_out.texcoord = v_in[v_id].texcoord;
    return v_out;
}

fragment float4 
render_pixel(VertexOutput input [[ stage_in ]], 
             texture2d<float> imgA [[ texture(0) ]], 
             texture2d<float> imgB [[ texture(1) ]])
{
    float4 tex_clr0 = imgA.sample(s, input.texcoord);
    float4 tex_clr1 = imgB.sample(s, input.texcoord);
    // compute color
    float4 clr = compute_color(tex_clr0, tex_clr1, ...);
    return clr;
}

Спецификаторы класса памяти

Металлический язык штриховки поддерживает extern и static спецификаторы класса памяти. Металл не поддерживает thread_local спецификаторы класса памяти.

Используйте extern спецификатор класса памяти только для функций и переменных, объявленных в объеме программы или для переменных, объявленных в функции. Используйте static спецификатор класса памяти только для переменных, объявленных в объеме программы (см. Пространство базового адреса), а не для переменных, объявленных в графике или функции ядра. В следующем примере, static спецификатор неправильно используется переменными b и c объявленный в функции ядра:

#include <metal_stdlib>
using namespace metal;

extern constant float4 noise_table[256];
static constant float4 color_table[256] = { ... };  // static is okay

extern void my_foo(texture2d<float> img);
extern void my_bar(device float *a);

kernel void my_func(texture2d<float> img [[ texture(0) ]], 
                    device float *ptr [[ buffer(0) ]])
{
    extern constant float4 a;
    static constant float4 b;    // static is an error.
    static float c;             // static is an error.
    ...
    my_foo(img);
    ...
    my_bar(ptr);
    ...
}

Выборка и спецификаторы интерполяции

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

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

center_perspective

center_no_perspective

centroid_perspective

centroid_no_perspective

sample_perspective

sample_no_perspective

flat

center_perspective выборка по умолчанию и спецификатор интерполяции для всех спецификаторов атрибута для типов возврата функций вершины и параметров функциям фрагмента, за исключением [[ position ]], который может быть объявлен только с center_no_perspective.

Следующим примером является определяемая пользователем структура, указывающая, как интерполированы данные в определенных элементах:

struct FragmentInput {
        float4 pos [[ center_no_perspective ]];
        float4 color [[ center_perspective ]];
        float2 texcoord;
        int index [[ flat ]]; 
        float f [[ sample_perspective ]]; 
};

Для целых типов единственный допустимый спецификатор интерполяции flat.

Варианты спецификатора выборки (sample_perspective и sample_no_perspective) интерполируйте в демонстрационном расположении, а не в пиксельном центре. Когда Вы маркируете одну или более переменных a sample спецификатор вместо a center или centroid спецификатор, функции фрагмента (или блоки кода в функции фрагмента) использующий эти переменные выполняется на выборку, а не на фрагмент.

Функция на фрагмент по сравнению с функцией на выборку

Функция фрагмента обычно выполняется на фрагмент. Если какой-либо ввод фрагмента должен быть интерполирован в на выборку по сравнению с на фрагмент, спецификатор выборки идентифицирует. Точно так же [[ sample_id ]] атрибут используется для идентификации текущего демонстрационного индекса и [[ color(m) ]] атрибут используется для идентификации целевого цвета фрагмента или демонстрационного цвета (для присоединения мультивыбранного цвета) значение. Если какой-либо из этих спецификаторов используется с параметрами функции фрагмента, функция фрагмента может выполниться на выборку вместо на пиксель. (Реализация может решить только выполнить код на выборку, зависящую от на демонстрационные значения, и остальная часть функции фрагмента может выполниться на фрагмент.)

Только вводы с указанной выборкой (или объявленный с [[ sample_id ]] или [[ color(m) ]] спецификатор), отличаются между вызовами на фрагмент или на выборку, тогда как другие вводы все еще интерполируют в пиксельном центре.

Следующий пример использует [[ color(m) ]] атрибут, чтобы указать, что эта функция фрагмента должна быть выполнена на основе на выборку:

#include <metal_stdlib>
using namespace metal;

fragment float4
my_frag_shader(float2 tex_coord [[ stage_in ]],
               texture2d<float> img [[ texture(0) ]],
               sampler s [[ sampler(0) ]],
               float4 framebuffer [[ color(0) ]])
{
    return c = mix(img.sample(s, tex_coord), framebuffer, 
                   mix_factor);
}

Программируемое смешивание

Функция фрагмента может использоваться для выполнения программируемого смешивания на выборку или на фрагмент. Цветной присоединяемый индекс, идентифицированный [[ color(m) ]] спецификатор атрибута может быть указан как параметр функции фрагмента.

Пример ниже демонстрирует программируемый смешивающий OpenGL ES, с помощью метода, детализированного в Данных Кадрового буфера Выборки для Программируемого Смешивания для применения полутонового эффекта преобразования к тому, что представляется, прежде чем программа построения теней выполняется. Перечисление 4-1 показывает программу построения теней GLSL 1.0 фрагмента (для использования с OpenGL ES 2.0), и Перечисление 4-2 показывает эквивалентную Металлическую функцию фрагмента.

Перечисление 4-1  , программируемое смешивающий OpenGL ES 2.0

#extension GL_APPLE_shader_framebuffer_fetch : require

void main()
{
    // RGB to grayscale
    mediump float lum = dot(gl_LastFragData[0].rgb,
                            vec3(0.30,0.59,0.11));
    gl_FragColor = vec4(lum, lum, lum, 1.0);
}

Перечисление 4-2  , программируемое смешивающий металл

#include <metal_stdlib>
using namespace metal;

fragment half4
paint_grayscale(half4 dst_color [[ color(0) ]]) 
{
    // RGB to grayscale
    half lum = dot(dst_color.rgb, 
                   half3(0.30h, 0.59h, 0.11h));
    return half4(lum, lum, lum, 1.0h);
}

Объединение функций вершины и фрагмента в графическом конвейере

Типичный Металлический графический конвейер комбинирует функцию вершины и функцию фрагмента. В самом простом случае Вы определяете функцию вершины и функцию фрагмента вместе, такой, что выходной тип функции вершины является входным типом функции фрагмента. Перечисление 4-3 иллюстрирует этот сценарий.

Перечисление 4-3  простая комбинация функций вершины и фрагмента

struct VertexOutput
{
    float4 position [[ position ]];
    float3 normal;
    float2 texcoord;
};

vertex VertexOutput 
my_vertex_shader(...) 
{ 
    VertexOutput v;

    ... 
    return v;
}

fragment float4
my_fragment_shader(VertexOutput f [[ stage_in ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

fragment float4
my_fragment_shader2(VertexOutput f [[ stage_in ]], 
                    bool is_front_face [[ front_facing ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

В этом примере можно соединиться my_vertex_shader функция с любым my_fragment_shader функционируйте или my_fragment_shader2 функция для конфигурирования конвейера рендеринга.

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

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

• Ввод на фрагмент к функции фрагмента, объявленной с [[ stage_in ]] спецификатор. Они выводятся связанной функцией вершины.

• Встроенные переменные, объявленные с одним из спецификаторов атрибута, определенных в Спецификаторах Атрибута для Определения местоположения Вводов На вершину. Они сгенерированы любой функцией вершины (такой как [[ position ]], [[ point_size ]], [[ clip_distance ]]) или rasterizer (такой как [[ point_coord ]], [[ front_facing ]], [[ sample_id ]], [[ sample_mask ]]) Или они могут обратиться к значению цвета кадрового буфера (такой как [[ color ]]) переданный как ввод функции фрагмента.

• Определяемые пользователем переменные, объявленные с синтаксисом спецификатора атрибута [[ user(name) ]].

Функция вершины и функция фрагмента, как полагают, имеют соответствие подписей и таким образом имеют право быть объединенными в графическом конвейере в любом из двух случаев:

1. Если функция фрагмента не объявляет входного аргумента с [[ stage_in ]] спецификатор.

2. Если функция фрагмента объявляет входной аргумент с [[ stage_in ]] спецификатор и соблюдающие правила применяются:

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

   • Каждая пользовательская сгенерированная переменная во входном аргументе указана с a [[ user(name) ]] спецификатор, где имя соответствует a [[ user(name) ]] спецификатор в типе возврата функции вершины. Типы данных элементов с соответствием [[ user(name) ]] спецификаторы должны также соответствовать.

     Также, если входной аргумент содержит определяемые пользователем переменные, не указанные с [[ user(name) ]] спецификатор, и имена и типы переменных должен соответствовать.

Перечисление 4-4 показывает пример совместимых подписей.

Перечисление 4-4  совместимые функциональные подписи со спецификаторами для пользовательских сгенерированных переменных

struct VertexOutput
{
    float4 position [[ position ]];
    float3 vertex_normal [[ user(normal) ]];
    float2 texcoord [[ user(texturecoord) ]];
};

struct FragInput
{
    float3 frag_normal [[ user(normal) ]];
    float4 position [[ position ]];
    float4 framebuffer_color [[ color(0) ]];
    bool is_front_face [[ front_facing ]];
};

vertex VertexOutput 
my_vertex_shader(...) 
{ 
    VertexOutput v;

    ... 
    return v;
}

fragment float4
my_fragment_shader(FragInput f [[ stage_in ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

В этом примере, функции вершины my_vertex_shader совместимо с функцией фрагмента my_fragment_shader потому что:

• Функция фрагмента использует [[ position ]] и [[ user(normal) ]] атрибуты выводятся от вершинного шейдера.

• Другие атрибуты, используемые в функции фрагмента, сгенерированы rasterizer или считаны из кадрового буфера.

Обратите внимание на то, что функции рассматривают, соответствуя даже при том, что функция фрагмента не использует [[ user(texturecoord) ]] атрибут выводится от функции вершины.

Перечисление 4-5 показывает другой пример совместимых подписей.

Перечисление 4-5  совместимые функциональные подписи с соответствием имен элементов

struct VertexOutput
{
    float4 position [[ position ]];
    float3 normal;
    float2 texcoord;
};

struct FragInput
{
    float4 position [[ position ]];
    float2 texcoord;
};

vertex VertexOutput 
my_vertex_shader(...) 
{ 
    VertexOutput v;

    ... 
    return v;
}

fragment float4
my_fragment_shader(FragInput f [[ stage_in ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

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

Перечисление 4-6 показывает третий пример совместимых подписей.

Перечисление 4-6  Совместимые Подписи Без stage_in Спецификатора

struct VertexOutput
{
    float4 position [[ position ]];
    float3 normal;
    float2 texcoord;
};

vertex VertexOutput
my_vertex_shader(...) 
{ 
    VertexOutput v;

    ... 
    return v;
}

fragment float4
my_fragment_shader(float4 p [[ position ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

В этом примере, функции фрагмента my_fragment_shader не имеет никакого ввода, объявленного с [[ stage_in ]] спецификатор, но соответствия, вершина функционирует my_vertex_shader, потому что оба используют [[ position ]] атрибут.

Перечисление 4-7 и Перечисление 4-8 иллюстрируют несовместимые подписи:

Перечисление 4-7  несовместимое использование типов

struct VertexOutput
{
    float4 position [[ position ]];
    float3 normal;
    float2 texcoord;
};

struct FragInput
{
    float4 position [[ position ]];
    half3 normal;
};

vertex VertexOutput 
my_vertex_shader(...) 
{ 
    VertexOutput v;

    ... 
    return v;
}

fragment float4
my_fragment_shader(FragInput f [[ stage_in ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

Перечисление 4-8  несовместимое использование определяемых пользователем переменных

struct VertexOutput
{
    float4 position [[ position ]];
    float3 normal [[ user(normal) ]];
    float2 texcoord [[ user(texturecoord) ]];
};

struct FragInput
{
    float3 normal [[ user(foo) ]];
    float4 position [[ position ]];
};

vertex VertexOutput 
my_vertex_shader(...) 
{ 
    VertexOutput v;

    ... 
    return v;
}

fragment float4
my_fragment_shader(FragInput f [[ stage_in ]], ...)
{
    float4 clr;

    ... 
    return clr;
}

Оба примера пытаются соответствовать названный элемент normal между VertexOutput и FragInput структуры. Однако в Перечислении 4-7, типы этих элементов не соответствуют. В Перечислении 4-8, [[ user(name) ]] спецификаторы не соответствуют.

Дополнительные ограничения

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

• Записи к буферу или текстуре запрещены от функции фрагмента.

• Записи к текстуре запрещены от вершинного шейдера.

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

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

• Максимум 128 скаляров может использоваться в качестве вводов к функции фрагмента, объявленной с stage_in спецификатор. Если ввод к функции фрагмента является вектором, то входной вектор рассчитывает как n скаляры, где n является числом компонентов в векторе.

  Это ограничение не включает встроенные переменные, объявленные с одним из следующих атрибутов: [[ color(m) ]], [[ front_facing ]], [[ sample_id ]], и [[ sample_mask ]].