#include <includer.h>

Inheritance diagram for impeller::compiler::Includer:

Public Member Functions
	Includer (std::shared_ptr< fml::UniqueFD > working_directory, std::vector< IncludeDir > include_dirs, std::function< void(std::string)> on_file_included)

	~Includer () override

shaderc_include_result *	GetInclude (const char requested_source, shaderc_include_type type, const char requesting_source, size_t include_depth) override

void	ReleaseInclude (shaderc_include_result *data) override

Detailed Description

Definition at line 25 of file includer.h.

Constructor & Destructor Documentation

◆ Includer()

impeller::compiler::Includer::Includer	(	std::shared_ptr< fml::UniqueFD >	working_directory,
		std::vector< IncludeDir >	include_dirs,
		std::function< void(std::string)>	on_file_included
	)

Definition at line 14 of file includer.cc.

    : working_directory_(std::move(working_directory)),
      include_dirs_(std::move(include_dirs)),
      on_file_included_(std::move(on_file_included)) {}

◆ ~Includer()

impeller::compiler::Includer::~Includer ( )

overridedefault

Member Function Documentation

◆ GetInclude()

shaderc_include_result * impeller::compiler::Includer::GetInclude	(	const char *	requested_source,
		shaderc_include_type	type,
		const char *	requesting_source,
		size_t	include_depth
	)

override

Definition at line 71 of file includer.cc.

                                                                   {
  auto result = std::make_unique<shaderc_include_result>();
 
  // Default initialize to failed inclusion.
  result->source_name = "";
  result->source_name_length = 0;
 
  constexpr const char* kFileNotFoundMessage = "Included file not found.";
  result->content = kFileNotFoundMessage;
  result->content_length = ::strlen(kFileNotFoundMessage);
  result->user_data = nullptr;
 
  if (!working_directory_ || !working_directory_->is_valid()) {
    return result.release();
  }
 
  if (requested_source == nullptr) {
    return result.release();
  }
 
  auto file = FindFirstMapping(requested_source);
 
  if (!file || file->GetMapping() == nullptr) {
    return result.release();
  }
 
  auto includer_data =
      std::make_unique<IncluderData>(requested_source, std::move(file));
 
  result->source_name = includer_data->file_name.c_str();
  result->source_name_length = includer_data->file_name.length();
  result->content = reinterpret_cast<decltype(result->content)>(
      includer_data->mapping->GetMapping());
  result->content_length = includer_data->mapping->GetSize();
  result->user_data = includer_data.release();
 
  return result.release();
}

◆ ReleaseInclude()

void impeller::compiler::Includer::ReleaseInclude ( shaderc_include_result * data )