include/spirv_cross/internal_interface.hpp - third_party/spirv-cross - Git at Google

 /*
  * 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
	/*
	* 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