Method define_entry_point

source/effect_codegen_spirv.cpp:1237–1567

	}

	void define_entry_point(function &func) override
	{
		assert(!func.unique_name.empty() && func.unique_name[0] == 'F');
		func.unique_name[0] = 'E';

		// Modify entry point name so each thread configuration is made separate
		if (func.type == shader_type::compute)
			func.unique_name +=
				'_' + std::to_string(func.num_threads[0]) +
				'_' + std::to_string(func.num_threads[1]) +
				'_' + std::to_string(func.num_threads[2]);

		if (std::find_if(_module.entry_points.begin(), _module.entry_points.end(),
				[&func](const std::pair<std::string, shader_type> &entry_point) {
					return entry_point.first == func.unique_name;
				}) != _module.entry_points.end())
			return;

		_module.entry_points.emplace_back(func.unique_name, func.type);

		spv::Id position_variable = 0;
		spv::Id point_size_variable = 0;
		std::vector<spv::Id> inputs_and_outputs;
		std::vector<expression> call_params;

		// Generate the glue entry point function
		function entry_point = func;
		entry_point.referenced_functions.push_back(func.id);

		// Change function signature to 'void main()'
		entry_point.return_type = { type::t_void };
		entry_point.return_semantic.clear();
		entry_point.parameter_list.clear();

		const id entry_point_definition = define_function({}, entry_point);
		enter_block(create_block());

		const auto create_varying_param = [this, &call_params](const member_type &param) {
			// Initialize all output variables with zero
			const spv::Id variable = define_variable({}, param.type, nullptr, spv::StorageClassFunction, spv::ImageFormatUnknown, emit_constant(param.type, 0u));

			expression &call_param = call_params.emplace_back();
			call_param.reset_to_lvalue({}, variable, param.type);

			return variable;
		};

		const auto create_varying_variable = [this, &inputs_and_outputs, &position_variable, &point_size_variable, stype = func.type](const type &param_type, const std::string &semantic, spv::StorageClass storage, int a = 0) {
			const spv::Id variable = define_variable({}, param_type, nullptr, storage);

			if (const spv::BuiltIn builtin = semantic_to_builtin(semantic, stype);
				builtin != spv::BuiltInMax)
			{
				assert(a == 0); // Built-in variables cannot be arrays

				add_builtin(variable, builtin);

				if (builtin == spv::BuiltInPosition && storage == spv::StorageClassOutput)