internal_interface.hpp

Go to the documentation of this file.

/*
 * Copyright 2015-2017 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef SPIRV_CROSS_INTERNAL_INTERFACE_HPP
#define SPIRV_CROSS_INTERNAL_INTERFACE_HPP

// This file must only be included by the shader generated by spirv-cross!

#ifndef GLM_FORCE_SWIZZLE
#define GLM_FORCE_SWIZZLE
#endif

#ifndef GLM_FORCE_RADIANS
#define GLM_FORCE_RADIANS
#endif

#include <glm/glm.hpp>

#include "barrier.hpp"
#include "external_interface.h"
#include "image.hpp"
#include "sampler.hpp"
#include "thread_group.hpp"
#include <assert.h>
#include <stdint.h>

namespace internal
{
// Adaptor helpers to adapt GLSL access chain syntax to C++.
// Don't bother with arrays of arrays on uniforms ...
// Would likely need horribly complex variadic template munging.

template <typename T>
struct Interface
{
    enum
    {
        ArraySize = 1,
        Size = sizeof(T)
    };

    Interface()
        : ptr(0)
    {
    }
    T &get()
    {
        assert(ptr);
        return *ptr;
    }

    T *ptr;
};

// For array types, return a pointer instead.
template <typename T, unsigned U>
struct Interface<T[U]>
{
    enum
    {
        ArraySize = U,
        Size = U * sizeof(T)
    };

    Interface()
        : ptr(0)
    {
    }
    T *get()
    {
        assert(ptr);
        return ptr;
    }

    T *ptr;
};

// For case when array size is 1, avoid double dereference.
template <typename T>
struct PointerInterface
{
    enum
    {
        ArraySize = 1,
        Size = sizeof(T *)
    };
    enum
    {
        PreDereference = true
    };

    PointerInterface()
        : ptr(0)
    {
    }

    T &get()
    {
        assert(ptr);
        return *ptr;
    }

    T *ptr;
};

// Automatically converts a pointer down to reference to match GLSL syntax.
template <typename T>
struct DereferenceAdaptor
{
    DereferenceAdaptor(T **ptr)
        : ptr(ptr)
    {
    }
    T &operator[](unsigned index) const
    {
        return *(ptr[index]);
    }
    T **ptr;
};

// We can't have a linear array of T* since T* can be an abstract type in case of samplers.
// We also need a list of pointers since we can have run-time length SSBOs.
template <typename T, unsigned U>
struct PointerInterface<T[U]>
{
    enum
    {
        ArraySize = U,
        Size = sizeof(T *) * U
    };
    enum
    {
        PreDereference = false
    };
    PointerInterface()
        : ptr(0)
    {
    }

    DereferenceAdaptor<T> get()
    {
        assert(ptr);
        return DereferenceAdaptor<T>(ptr);
    }

    T **ptr;
};

// Resources can be more abstract and be unsized,
// so we need to have an array of pointers for those cases.
template <typename T>
struct Resource : PointerInterface<T>
{
};

// POD with no unknown sizes, so we can express these as flat arrays.
template <typename T>
struct UniformConstant : Interface<T>
{
};
template <typename T>
struct StageInput : Interface<T>
{
};
template <typename T>
struct StageOutput : Interface<T>
{
};
template <typename T>
struct PushConstant : Interface<T>
{
};
}

struct spirv_cross_shader
{
    struct PPSize
    {
        PPSize()
            : ptr(0)
            , size(0)
        {
        }
        void **ptr;
        size_t size;
    };

    struct PPSizeResource
    {
        PPSizeResource()
            : ptr(0)
            , size(0)
            , pre_dereference(false)
        {
        }
        void **ptr;
        size_t size;
        bool pre_dereference;
    };

    PPSizeResource resources[SPIRV_CROSS_NUM_DESCRIPTOR_SETS][SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS];
    PPSize stage_inputs[SPIRV_CROSS_NUM_STAGE_INPUTS];
    PPSize stage_outputs[SPIRV_CROSS_NUM_STAGE_OUTPUTS];
    PPSize uniform_constants[SPIRV_CROSS_NUM_UNIFORM_CONSTANTS];
    PPSize push_constant;
    PPSize builtins[SPIRV_CROSS_NUM_BUILTINS];

    template <typename U>
    void register_builtin(spirv_cross_builtin builtin, const U &value)
    {
        assert(!builtins[builtin].ptr);

        builtins[builtin].ptr = (void **)&value.ptr;
        builtins[builtin].size = sizeof(*value.ptr) * U::ArraySize;
    }

    void set_builtin(spirv_cross_builtin builtin, void *data, size_t size)
    {
        assert(builtins[builtin].ptr);
        assert(size >= builtins[builtin].size);

        *builtins[builtin].ptr = data;
    }

    template <typename U>
    void register_resource(const internal::Resource<U> &value, unsigned set, unsigned binding)
    {
        assert(set < SPIRV_CROSS_NUM_DESCRIPTOR_SETS);
        assert(binding < SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS);
        assert(!resources[set][binding].ptr);

        resources[set][binding].ptr = (void **)&value.ptr;
        resources[set][binding].size = internal::Resource<U>::Size;
        resources[set][binding].pre_dereference = internal::Resource<U>::PreDereference;
    }

    template <typename U>
    void register_stage_input(const internal::StageInput<U> &value, unsigned location)
    {
        assert(location < SPIRV_CROSS_NUM_STAGE_INPUTS);
        assert(!stage_inputs[location].ptr);

        stage_inputs[location].ptr = (void **)&value.ptr;
        stage_inputs[location].size = internal::StageInput<U>::Size;
    }

    template <typename U>
    void register_stage_output(const internal::StageOutput<U> &value, unsigned location)
    {
        assert(location < SPIRV_CROSS_NUM_STAGE_OUTPUTS);
        assert(!stage_outputs[location].ptr);

        stage_outputs[location].ptr = (void **)&value.ptr;
        stage_outputs[location].size = internal::StageOutput<U>::Size;
    }

    template <typename U>
    void register_uniform_constant(const internal::UniformConstant<U> &value, unsigned location)
    {
        assert(location < SPIRV_CROSS_NUM_UNIFORM_CONSTANTS);
        assert(!uniform_constants[location].ptr);

        uniform_constants[location].ptr = (void **)&value.ptr;
        uniform_constants[location].size = internal::UniformConstant<U>::Size;
    }

    template <typename U>
    void register_push_constant(const internal::PushConstant<U> &value)
    {
        assert(!push_constant.ptr);

        push_constant.ptr = (void **)&value.ptr;
        push_constant.size = internal::PushConstant<U>::Size;
    }

    void set_stage_input(unsigned location, void *data, size_t size)
    {
        assert(location < SPIRV_CROSS_NUM_STAGE_INPUTS);
        assert(stage_inputs[location].ptr);
        assert(size >= stage_inputs[location].size);

        *stage_inputs[location].ptr = data;
    }

    void set_stage_output(unsigned location, void *data, size_t size)
    {
        assert(location < SPIRV_CROSS_NUM_STAGE_OUTPUTS);
        assert(stage_outputs[location].ptr);
        assert(size >= stage_outputs[location].size);

        *stage_outputs[location].ptr = data;
    }

    void set_uniform_constant(unsigned location, void *data, size_t size)
    {
        assert(location < SPIRV_CROSS_NUM_UNIFORM_CONSTANTS);
        assert(uniform_constants[location].ptr);
        assert(size >= uniform_constants[location].size);

        *uniform_constants[location].ptr = data;
    }

    void set_push_constant(void *data, size_t size)
    {
        assert(push_constant.ptr);
        assert(size >= push_constant.size);

        *push_constant.ptr = data;
    }

    void set_resource(unsigned set, unsigned binding, void **data, size_t size)
    {
        assert(set < SPIRV_CROSS_NUM_DESCRIPTOR_SETS);
        assert(binding < SPIRV_CROSS_NUM_DESCRIPTOR_BINDINGS);
        assert(resources[set][binding].ptr);
        assert(size >= resources[set][binding].size);

        // We're using the regular PointerInterface, dereference ahead of time.
        if (resources[set][binding].pre_dereference)
            *resources[set][binding].ptr = *data;
        else
            *resources[set][binding].ptr = data;
    }
};

namespace spirv_cross
{
template <typename T>
struct BaseShader : spirv_cross_shader
{
    void invoke()
    {
        static_cast<T *>(this)->main();
    }
};

struct FragmentResources
{
    internal::StageOutput<glm::vec4> gl_FragCoord;
    void init(spirv_cross_shader &s)
    {
        s.register_builtin(SPIRV_CROSS_BUILTIN_FRAG_COORD, gl_FragCoord);
    }
#define gl_FragCoord __res->gl_FragCoord.get()
};

template <typename T, typename Res>
struct FragmentShader : BaseShader<FragmentShader<T, Res>>
{
    inline void main()
    {
        impl.main();
    }

    FragmentShader()
    {
        resources.init(*this);
        impl.__res = &resources;
    }

    T impl;
    Res resources;
};

struct VertexResources
{
    internal::StageOutput<glm::vec4> gl_Position;
    void init(spirv_cross_shader &s)
    {
        s.register_builtin(SPIRV_CROSS_BUILTIN_POSITION, gl_Position);
    }
#define gl_Position __res->gl_Position.get()
};

template <typename T, typename Res>
struct VertexShader : BaseShader<VertexShader<T, Res>>
{
    inline void main()
    {
        impl.main();
    }

    VertexShader()
    {
        resources.init(*this);
        impl.__res = &resources;
    }

    T impl;
    Res resources;
};

struct TessEvaluationResources
{
    inline void init(spirv_cross_shader &)
    {
    }
};

template <typename T, typename Res>
struct TessEvaluationShader : BaseShader<TessEvaluationShader<T, Res>>
{
    inline void main()
    {
        impl.main();
    }

    TessEvaluationShader()
    {
        resources.init(*this);
        impl.__res = &resources;
    }

    T impl;
    Res resources;
};

struct TessControlResources
{
    inline void init(spirv_cross_shader &)
    {
    }
};

template <typename T, typename Res>
struct TessControlShader : BaseShader<TessControlShader<T, Res>>
{
    inline void main()
    {
        impl.main();
    }

    TessControlShader()
    {
        resources.init(*this);
        impl.__res = &resources;
    }

    T impl;
    Res resources;
};

struct GeometryResources
{
    inline void init(spirv_cross_shader &)
    {
    }
};

template <typename T, typename Res>
struct GeometryShader : BaseShader<GeometryShader<T, Res>>
{
    inline void main()
    {
        impl.main();
    }

    GeometryShader()
    {
        resources.init(*this);
        impl.__res = &resources;
    }

    T impl;
    Res resources;
};

struct ComputeResources
{
    internal::StageInput<glm::uvec3> gl_WorkGroupID__;
    internal::StageInput<glm::uvec3> gl_NumWorkGroups__;
    void init(spirv_cross_shader &s)
    {
        s.register_builtin(SPIRV_CROSS_BUILTIN_WORK_GROUP_ID, gl_WorkGroupID__);
        s.register_builtin(SPIRV_CROSS_BUILTIN_NUM_WORK_GROUPS, gl_NumWorkGroups__);
    }
#define gl_WorkGroupID __res->gl_WorkGroupID__.get()
#define gl_NumWorkGroups __res->gl_NumWorkGroups__.get()

    Barrier barrier__;
#define barrier() __res->barrier__.wait()
};

struct ComputePrivateResources
{
    uint32_t gl_LocalInvocationIndex__;
#define gl_LocalInvocationIndex __priv_res.gl_LocalInvocationIndex__
    glm::uvec3 gl_LocalInvocationID__;
#define gl_LocalInvocationID __priv_res.gl_LocalInvocationID__
    glm::uvec3 gl_GlobalInvocationID__;
#define gl_GlobalInvocationID __priv_res.gl_GlobalInvocationID__
};

template <typename T, typename Res, unsigned WorkGroupX, unsigned WorkGroupY, unsigned WorkGroupZ>
struct ComputeShader : BaseShader<ComputeShader<T, Res, WorkGroupX, WorkGroupY, WorkGroupZ>>
{
    inline void main()
    {
        resources.barrier__.reset_counter();

        for (unsigned z = 0; z < WorkGroupZ; z++)
            for (unsigned y = 0; y < WorkGroupY; y++)
                for (unsigned x = 0; x < WorkGroupX; x++)
                    impl[z][y][x].__priv_res.gl_GlobalInvocationID__ =
                        glm::uvec3(WorkGroupX, WorkGroupY, WorkGroupZ) * resources.gl_WorkGroupID__.get() +
                        glm::uvec3(x, y, z);

        group.run();
        group.wait();
    }

    ComputeShader()
        : group(&impl[0][0][0])
    {
        resources.init(*this);
        resources.barrier__.set_release_divisor(WorkGroupX * WorkGroupY * WorkGroupZ);

        unsigned i = 0;
        for (unsigned z = 0; z < WorkGroupZ; z++)
        {
            for (unsigned y = 0; y < WorkGroupY; y++)
            {
                for (unsigned x = 0; x < WorkGroupX; x++)
                {
                    impl[z][y][x].__priv_res.gl_LocalInvocationID__ = glm::uvec3(x, y, z);
                    impl[z][y][x].__priv_res.gl_LocalInvocationIndex__ = i++;
                    impl[z][y][x].__res = &resources;
                }
            }
        }
    }

    T impl[WorkGroupZ][WorkGroupY][WorkGroupX];
    ThreadGroup<T, WorkGroupX * WorkGroupY * WorkGroupZ> group;
    Res resources;
};

inline void memoryBarrierShared()
{
    Barrier::memoryBarrier();
}
inline void memoryBarrier()
{
    Barrier::memoryBarrier();
}
// TODO: Rest of the barriers.

// Atomics
template <typename T>
inline T atomicAdd(T &v, T a)
{
    static_assert(sizeof(std::atomic<T>) == sizeof(T), "Cannot cast properly to std::atomic<T>.");

    // We need explicit memory barriers in GLSL to enfore any ordering.
    // FIXME: Can we really cast this? There is no other way I think ...
    return std::atomic_fetch_add_explicit(reinterpret_cast<std::atomic<T> *>(&v), a, std::memory_order_relaxed);
}
}

void spirv_cross_set_stage_input(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size)
{
    shader->set_stage_input(location, data, size);
}

void spirv_cross_set_stage_output(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size)
{
    shader->set_stage_output(location, data, size);
}

void spirv_cross_set_uniform_constant(spirv_cross_shader_t *shader, unsigned location, void *data, size_t size)
{
    shader->set_uniform_constant(location, data, size);
}

void spirv_cross_set_resource(spirv_cross_shader_t *shader, unsigned set, unsigned binding, void **data, size_t size)
{
    shader->set_resource(set, binding, data, size);
}

void spirv_cross_set_push_constant(spirv_cross_shader_t *shader, void *data, size_t size)
{
    shader->set_push_constant(data, size);
}

void spirv_cross_set_builtin(spirv_cross_shader_t *shader, spirv_cross_builtin builtin, void *data, size_t size)
{
    shader->set_builtin(builtin, data, size);
}

#endif