demotool/shaders.cc

#include "externals.hh"
#include "shaders.hh"


namespace {
	const std::regex PreprocDirective_( "^\\s*//!\\s*([a-z]+(\\s+([^\\s]+))*)\\s*$" );

	const std::map< std::string , E_ShaderInput > InputTypes_( ([] {
		std::map< std::string , E_ShaderInput > t;
		t.emplace( "chunk" , E_ShaderInput::CHUNK );
		t.emplace( "library" , E_ShaderInput::LIBRARY );
		t.emplace( "lib" , E_ShaderInput::LIBRARY );
		t.emplace( "vertex" , E_ShaderInput::VERTEX );
		t.emplace( "fragment" , E_ShaderInput::FRAGMENT );
		return t;
	})());


	struct T_InputReader_
	{
		using T_Tokens_ = std::vector< std::string >;

		FILE* const file;
		T_ShaderInput& input;
		uint32_t line{ 0 };

		char* buffer{ nullptr };
		ssize_t readCount;

		std::string accumulator{ };
		uint32_t accumLines{ 0 };

		T_InputReader_( __rd__ FILE* const file ,
				__rw__ T_ShaderInput& input )
			: file( file ) , input( input )
		{ }
		~T_InputReader_( );

		void read( );
		void addAccumulated( );
		void handleDirective(
				__rd__ T_Tokens_ const& tokens );
		void error( __rd__ std::string const& err );
	};

	T_InputReader_::~T_InputReader_( )
	{
		if ( buffer ) {
			free( buffer );
		}
		fclose( file );
	}

	void T_InputReader_::read( )
	{
		size_t bsz( 0 );
		while ( ( readCount = getline( &buffer , &bsz , file ) ) != -1 ) {
			line ++;
			std::cmatch match;
			if ( std::regex_match( buffer , match , PreprocDirective_ ) ) {
				const T_Tokens_ tokens( ([](std::string const& a) {
					using stri = std::istream_iterator< std::string >;
					std::istringstream iss( a );
					return T_Tokens_{ stri( iss ) , stri( ) };
				})( match[ 1 ].str( ) ) );
				assert( tokens.size( ) >= 1 );
				handleDirective( tokens );
			} else {
				accumulator += buffer;
				accumLines ++;
			}
		}
		addAccumulated( );
	}

	void T_InputReader_::addAccumulated( )
	{
		if ( accumLines ) {
			auto& ck( input.chunks );
			ck.emplace( ck.end( ) , E_ShaderInputChunk::CODE ,
					accumulator , accumLines );
			accumulator = {};
			accumLines = 0;
		}
	}

	void T_InputReader_::handleDirective(
			__rd__ T_Tokens_ const& tokens )
	{
		auto const& directive( tokens[ 0 ] );

		if ( directive == "include" ) {
			if ( tokens.size( ) != 2 ) {
				error( "invalid arguments" );
				return;
			}
			auto& ck( input.chunks );
			ck.emplace( ck.end( ) , E_ShaderInputChunk::INCLUDE , tokens[ 1 ] , 1 );

		} else if ( directive == "type" ) {
			if ( tokens.size( ) != 2 ) {
				error( "invalid arguments" );
				return;
			}
			auto pos( InputTypes_.find( tokens[ 1 ] ) );
			if ( pos == InputTypes_.end( ) ) {
				error( "unknown type" );
			} else {
				input.type = pos->second;
			}

		} else {
			error( "unknown directive" );
		}
	}

	void T_InputReader_::error(
			__rd__ std::string const& err )
	{
		input.errors.push_back( T_ShaderInputError{
				line , err } );
	}

} // namespace


bool T_ShaderInput::load(
		__rd__ std::string const& path )
{
	type = E_ShaderInput::CHUNK;
	chunks.clear( );
	errors.clear( );

	FILE* const file{ fopen( path.c_str( ) , "r" ) };
	if ( !file ) {
		errors.push_back( T_ShaderInputError{ 0 , "unable to open" } );
		return false;
	}

	T_InputReader_ reader( file , *this );
	reader.read( );

	return true;
}


#if 0
void testLoadShaderFile( )
{
	const std::string source( "test-loader.glsl" );
	const std::string sPath( "shaders/" + source );

	T_ShaderInput input;
	const bool ok( input.load( sPath ) );
	printf( "OK? %s\n" , ok ? "yes" : "no" );
	printf( "type: %d\n" , int( input.type ) );
	printf( "chunks: %zu\n" , input.chunks.size( ) );
	printf( "errors: %zu\n" , input.errors.size( ) );
	for ( auto const& error : input.errors ) {
		printf( "\tl%d: %s\n" , error.line , error.error.c_str( ) );
	}
}
#endif