Rapid Prototyping of Graphics Shaders in Modern C++

/*
 * red mesh                   red shaded mesh
 */
surface basic() {             surface simple(color myOpacity = 1) {
    Ci = (1.0, 0.0, 0.0);         color myColor = (1.0, 0.0, 0.0);
    Oi = 1;                       normal Nn = normalize(N);
}                                 Ci = myColor * myOpacity * diff;
                                  Oi = myOpacity;
                              }

varying vec3 N;
varying vec3 v;
void main(void)
{
   vec3 L = normalize(gl_LightSource[0].position.xyz - v);
   vec4 Idiff = gl_FrontLightProduct[0].diffuse * max(dot(N,L), 0);
   Idiff = clamp(Idiff, 0.0, 1.0);
   gl_FragColor = Idiff;
}

float4 main(
    float3 Light: TEXCOORD0,
    float3 Norm : TEXCOORD1) : COLOR
{
    float4 diffuse = { 1.0, 0.0, 0.0, 1.0 };
    float4 ambient = { 0.1, 0.0, 0.0, 1.0 };
    return ambient + diffuse * saturate(dot(Light, Norm));
}

// vectors are generic
vec2 texcoord1, texcoord2;
vec3 position;
vec4 myRGBA;
ivec2 textureLookup;
bvec3 less;

// matrices are floating point only
mat2 mat2D;
mat3 optMatrix;
mat4 view, projection;

vec4 v4;
v4.rgba;  // is a vec4 and the same as just using v4,
v4.rgb;   // is a vec3,
v4.b;     // is a float,
v4.xy;    // is a vec2,

vec4 pos = vec4(1.0, 2.0, 3.0, 4.0);
vec4 swiz= pos.wzyx; // swiz = (4.0, 3.0, 2.0, 1.0)
vec4 dup = vec4(pos.xx, pos.yy);

pos.xw = vec2(5.0, 6.0); // pos = (5.0, 2.0, 3.0, 6.0)
pos.xx = vec2(3.0, 4.0); // illegal - 'x' used twice

vec3 calcNormal( in vec3 pos )
{
    vec2 e = vec2(1.0, -1.0) * 0.0005;

    return normalize(
        e.xyy * map( pos + e.xyy ).x +
        e.yyx * map( pos + e.yyx ).x +
        e.yxy * map( pos + e.yxy ).x +
        e.xxx * map( pos + e.xxx ).x );
}

vector()
{
    static_for<0, N>()([this](size_t i) {
        data[i] = 0;
    });
}

explicit vector(scalar_type s)
{
    static_for<0, N>()([s, this](size_t i) {
        data[i] = s;
    });
}

using vec2 = vector<int, 2>;
using vec3 = vector<int, 3>;

vec3 v = vec3(98, vec2(99, 100));
//             ^    ^
//             |    |
//             `-- scalar construct gets called
//                  |
//                  `---- sub-vector construct gets called
//                        and then recursively again

int main()
{
    float a, b;
    scanf("%f %f", &a, &b);

    auto v = vec3(1.f, vec2(a, b));

    printf("%f %f", v.x, v.y);
}

void static_for<0ul, 3ul>::operator()<vector<float, 3ul>...
    push    rbp
    mov     rbp, rsp
    sub     rsp, 32
    mov     QWORD PTR [rbp-24], rdi
    mov     QWORD PTR [rbp-32], rsi
    mov     rax, QWORD PTR [rbp-32]
    mov     esi, 0
    mov     rdi, rax
    call    vector<float, 3ul>::vector(float)::{lambda(unsigned...
    mov     rax, QWORD PTR [rbp-32]
    mov     rdi, rax
    call    vector<float, 3ul>::vector(float)::{lambda(unsigned...
    mov     rdx, rax
    lea     rax, [rbp-1]
    mov     rsi, rdx
    mov     rdi, rax
    call    void static_for<1ul, 3ul>::operator()<vector...
    nop
    leave
    ret

template<typename A0, typename... Args>
explicit vector(A0&& a0, Args&&... args)
{
    size_t i = 0; // advances as we consume args

    // consume the first one
    construct_at_index(i, std::forward<A0>(a0));

    // consume the rest, if any
    (construct_at_index(i, std::forward<Args>(args)), ...);
}

template<typename T>
struct vector_base<T, 2>
{
    union
    {
        T data[2];
        struct { T x, y; };
        struct { T s, t; };
        struct { T u, v; };
    }
};

template<typename T>
struct vector_base<T, 3>
{
    union
    {
        T data[3];
        struct { T x, y, z; };
        struct { T r, g, b; };
        struct { T s, t, p; };
    }
};

template<typename T>
struct vector_base<T, 4>
{
    union
    {
        T data[4];
        struct { T x, y, z, w; };
        struct { T r, g, b, a; };
        struct { T s, t, p, q; };
    }
};

template<class vector_type, class T, size_t N, size_t... indices>
struct swizzler
{
    T data[N];

(etc)

union
{
    T data[3];

    struct {
        swizzler<0>::type x;
        swizzler<1>::type y;
        swizzler<2>::type z;
    };
    struct {
        swizzler<0>::type r;
        swizzler<1>::type g;
        swizzler<2>::type b;
    };
    struct {
        swizzler<0>::type s;
        swizzler<1>::type t;
        swizzler<2>::type p;
    };
    ...

    ...
    swizzler<0, 0>::type xx, rr, ss;
    swizzler<0, 1>::type xy, rg, st;
    swizzler<0, 2>::type xz, rb, sp;
    swizzler<1, 0>::type yx, gr, ts;
    swizzler<1, 1>::type yy, gg, tt;
    swizzler<1, 2>::type yz, gb, tp;
    swizzler<2, 0>::type zx, br, ps;
    swizzler<2, 1>::type zy, bg, pt;
    swizzler<2, 2>::type zz, bb, pp;
    ...

    ...
    swizzler<0, 0, 0>::type xxx, rrr, sss;
    swizzler<0, 0, 1>::type xxy, rrg, sst;
    swizzler<0, 0, 2>::type xxz, rrb, ssp;
    swizzler<0, 1, 0>::type xyx, rgr, sts;
    swizzler<0, 1, 1>::type xyy, rgg, stt;
    swizzler<0, 1, 2>::type xyz, rgb, stp;
    swizzler<0, 2, 0>::type xzx, rbr, sps;
    swizzler<0, 2, 1>::type xzy, rbg, spt;
    swizzler<0, 2, 2>::type xzz, rbb, spp;
    swizzler<1, 0, 0>::type yxx, grr, tss;
    swizzler<1, 0, 1>::type yxy, grg, tst;
    swizzler<1, 0, 2>::type yxz, grb, tsp;
    ...

    ...
    swizzler<2, 1, 2, 0>::type zyzx, bgbr, ptps;
    swizzler<2, 1, 2, 1>::type zyzy, bgbg, ptpt;
    swizzler<2, 1, 2, 2>::type zyzz, bgbb, ptpp;
    swizzler<2, 2, 0, 0>::type zzxx, bbrr, ppss;
    swizzler<2, 2, 0, 1>::type zzxy, bbrg, ppst;
    swizzler<2, 2, 0, 2>::type zzxz, bbrb, ppsp;
    swizzler<2, 2, 1, 0>::type zzyx, bbgr, ppts;
    swizzler<2, 2, 1, 1>::type zzyy, bbgg, pptt;
    swizzler<2, 2, 1, 2>::type zzyz, bbgb, pptp;
    swizzler<2, 2, 2, 0>::type zzzx, bbbr, ppps;
    swizzler<2, 2, 2, 1>::type zzzy, bbbg, pppt;
    swizzler<2, 2, 2, 2>::type zzzz, bbbb, pppp;
};

template<
    typename vector_type,
    typename scalar_type,
    size_t N,
    size_t... indices>
struct swizzler
{
    T data[N];
    // N might differ from vector_type::num_components
    // ex: .xxxx from vec2

(etc)

vec3 v = vec4(other.xy, other.zw);

> error: no matching function for call to [...]
> template argument deduction/substitution failed: [...]

vec3 v = vec3(1, 0, 0);
float n = dot(v.xzx, v.zyx);

> 'dot': no matching overloaded function found
> could not deduce template argument

...
MAKE_LIB_FUNC(abs)
MAKE_LIB_FUNC(sign)
MAKE_LIB_FUNC(floor)
MAKE_LIB_FUNC(trunc)
MAKE_LIB_FUNC(ceil)
MAKE_LIB_FUNC(fract)
MAKE_LIB_FUNC(mod)
MAKE_LIB_FUNC(min)
MAKE_LIB_FUNC(max)
MAKE_LIB_FUNC(clamp)
MAKE_LIB_FUNC(mix)
MAKE_LIB_FUNC(step)
MAKE_LIB_FUNC(smoothstep)
...

return max(-d2, d1);
//            ||
//            ||
//            \/
    promote_to_vec<float, float>
//            ||
//            ||
//            \/
return vector<float, 0>::max(-d2, d1);

template<
    typename,
    template<typename, size_t...> class vector_type,
    typename...
>
struct matrix;

template<size_t...>
struct indices_pack;

using vec2 = vector<float, 0, 1>;
using vec3 = vector<float, 0, 1, 2>;

using mat2 = matrix<float, vector,
    indices_pack<0, 1>, indices_pack<0, 1>>;

using mat3 = matrix<float, vector,
    indices_pack<0, 1, 2>, indices_pack<0, 1, 2>>;

using mat2x3 = matrix<float, vector,
    indices_pack<0, 1>, indices_pack<0, 1, 2>>;