Add some shader source files to trinity

CMakeLists.txt

@@ -103,6 +103,7 @@ endif ()
 
 add_subdirectory(trinityal)
 add_subdirectory(trinity)
+add_subdirectory(shaders)
 
 if(CMAKE_PROJECT_NAME STREQUAL carbon-trinity AND NOT BUILD_FOR_PYTHON_2)
     # Determine if/when to generate/build documentation. The rules are as follows:
@@ -139,3 +140,4 @@ if(CMAKE_PROJECT_NAME STREQUAL carbon-trinity AND NOT BUILD_FOR_PYTHON_2)
         )
     endif()
 endif()
+

shadercompiler/CachingIncludeHandler.cpp

@@ -61,6 +61,26 @@ std::optional<std::string> JoinPath( const char* path1, const char* path2 )
 #endif
 }
 
+std::optional<std::string> JoinPathAndCheckExists( const char* path1, const char* path2 )
+{
+	if( auto joined = JoinPath( path1, path2 ) )
+	{
+#if _WIN32
+		if( PathFileExists( joined->c_str() ) )
+		{
+			return joined;
+		}
+#else
+		struct stat buffer;
+		if( stat( joined->c_str(), &buffer ) == 0 )
+		{
+			return joined;
+		}
+#endif
+	}
+	return std::nullopt;
+}
+
 }
 
 
@@ -85,37 +105,62 @@ CachingIncludeHandler::~CachingIncludeHandler()
 //     used for resolving relative paths
 //   rootPath - Custom root path for resolving relative paths
 // --------------------------------------------------------------------------------------
-std::optional<CachingIncludeHandler::IncludedFile> CachingIncludeHandler::Open( const char* fileName, const char* parentData, const char* rootPath )
+std::optional<CachingIncludeHandler::IncludedFile> CachingIncludeHandler::Open( const char* fileName, IncludeType includeType, const char* parentData, const char* rootPath )
 {
 	std::lock_guard scope( m_cs );
 
 	std::string fullPath;
 	if( PathIsRelative( fileName ) )
 	{
-		std::string parentPath;
-		if( parentData == nullptr )
-		{
-			parentPath = rootPath ? rootPath : m_rootPath;
-		}
-		else
-		{
-			auto parent = m_pathFromFile.find( parentData - 1 );
-			if( parent != m_pathFromFile.end() )
+		auto FindLocalPath = [&]() -> bool {
+			std::string parentPath;
+			if( parentData == nullptr )
 			{
-				parentPath = parent->second;
+				parentPath = rootPath ? rootPath : m_rootPath;
 			}
 			else
 			{
-				parentPath = "";
+				auto parent = m_pathFromFile.find( parentData - 1 );
+				if( parent != m_pathFromFile.end() )
+				{
+					parentPath = parent->second;
+				}
+				else
+				{
+					parentPath = "";
+				}
 			}
-		}
-		if( auto joined = JoinPath( parentPath.c_str(), fileName ) )
+			if( auto joined = JoinPathAndCheckExists( parentPath.c_str(), fileName ) )
+			{
+				fullPath = *joined;
+				return true;
+			}
+			return false;
+		};
+		auto FindSystemPath = [&]() -> bool {
+			for( auto it = m_systemIncludePaths.begin(); it != m_systemIncludePaths.end(); ++it )
+			{
+				if( auto joined = JoinPathAndCheckExists( it->c_str(), fileName ) )
+				{
+					fullPath = *joined;
+					return true;
+				}
+			}
+			return false;
+		};
+		if( includeType == IncludeLocal )
 		{
-			fullPath = *joined;
+			if( !FindLocalPath() && !FindSystemPath() )
+			{
+				return std::nullopt;
+			}
 		}
 		else
 		{
-			return std::nullopt;
+			if( !FindSystemPath() && !FindLocalPath() )
+			{
+				return std::nullopt;
+			}
 		}
 	}
 	else
@@ -221,6 +266,12 @@ std::optional<CachingIncludeHandler::IncludedFile> CachingIncludeHandler::AddPre
 	return info;
 }
 
+void CachingIncludeHandler::AddSystemIncludePath( const char* path )
+{
+	std::lock_guard scope( m_cs );
+	m_systemIncludePaths.push_back( path );
+}
+
 // --------------------------------------------------------------------------------------
 // Description:
 //   Assigns path to the "root", entry point file.

shadercompiler/CachingIncludeHandler.h

@@ -22,12 +22,20 @@ class CachingIncludeHandler
 		time_t modifiedTime;
 	};
 
-	std::optional<IncludedFile> Open( const char* fileName, const char* parentData = nullptr, const char* rootPath = nullptr );
+	enum IncludeType
+	{
+		IncludeLocal,
+		IncludeSystem
+	};
+
+	std::optional<IncludedFile> Open( const char* fileName, IncludeType includeType, const char* parentData = nullptr, const char* rootPath = nullptr );
 
 	void SetRootPath( const char* shaderPath );
 
 	std::optional<IncludedFile> AddPrefix( const char* fileName, const char* prefix );
 
+	void AddSystemIncludePath( const char* path );
+
 private:
 	typedef std::map<const void*, std::string> PathFromFile;
 	typedef std::map<std::string, IncludedFile> FileFromPath;
@@ -38,6 +46,7 @@ class CachingIncludeHandler
 	FileFromPath m_fileFromPath;
 	// Path of the entry point file
 	std::string m_rootPath;
+	std::vector<std::string> m_systemIncludePaths;
 
 	std::mutex m_cs;
 };

shadercompiler/EffectCompilerDX11.cpp

@@ -1789,6 +1789,13 @@ bool EffectCompilerDX11::CompileEffect( const char* source, size_t sourceLength,
 
 				CComPtr<IDxcResult> pCompileResult;
 				HRESULT hrCompilation = compiler->Compile( &sourceBuffer, arguments, argumentsSize, nullptr, IID_PPV_ARGS( &pCompileResult ) );
+				if( SUCCEEDED( hrCompilation ) )
+				{
+					if( FAILED( pCompileResult->GetStatus( &hrCompilation ) ) )
+					{
+						hrCompilation = E_FAIL;
+					}
+				}
 
 				if( FAILED( hrCompilation ) )
 				{

shadercompiler/HLSLScanner.re

@@ -41,16 +41,16 @@ ID = LETTER(LETTER|DECIMAL)*;
 #define	YYMARKER (marker)
 #define	YYCTXMARKER (ctxMarker)
 
-bool GetIncludePath( ParserState &state, InlineString& path )
+bool GetIncludePath( ParserState &state, InlineString& path, CachingIncludeHandler::IncludeType& includeType )
 {
-	bool local;
+	includeType = CachingIncludeHandler::IncludeLocal;
 	if( *YYCURSOR == '"' )
 	{
-		local = true;
+		includeType = CachingIncludeHandler::IncludeLocal;
 	}
 	else if( *YYCURSOR == '<' )
 	{
-		local = false;
+		includeType = CachingIncludeHandler::IncludeSystem;
 	}
 	else
 	{
@@ -61,15 +61,15 @@ bool GetIncludePath( ParserState &state, InlineString& path )
 	{
 		if( *YYCURSOR == '"' )
 		{
-			if( local )
+			if( includeType == CachingIncludeHandler::IncludeLocal )
 			{
 				path.end = ++YYCURSOR;
 				return true;
 			}
 		}
 		else if( *YYCURSOR == '>' )
 		{
-			if( !local )
+			if( includeType == CachingIncludeHandler::IncludeSystem )
 			{
 				path.end = ++YYCURSOR;
 				return true;
@@ -141,14 +141,15 @@ std:
 		{
 			state.GetCurrentLocation().lineNumber++;
 			InlineString path;
-			if( !GetIncludePath( state, path ) )
+			CachingIncludeHandler::IncludeType includeType;
+			if( !GetIncludePath( state, path, includeType ) )
 			{
 				state.ShowMessage( EC_INVALID_INCLUDE_PATH );
 				return PPSR_ERROR;
 			}
 			if( !state.InSkipMode() )
 			{
-				state.IncludeFile( path );
+				state.IncludeFile( path, includeType );
 			}
 			start = YYCURSOR;
 			continue;
@@ -566,7 +567,7 @@ std:
 				++YYCURSOR;
 			}
 
-			if( !state.InSkipMode() )
+			if( !state.InSkipMode() && !state.InDiscoverMode() )
 			{
 				state.ShowMessage( EC_USER_ERROR, std::string( start, YYCURSOR ).c_str() );
 				return PPSR_ERROR;

shadercompiler/MSLInclude.h

@@ -332,6 +332,17 @@ void GetDimensions( texturecube<T> tex, thread W& w, thread H& h )
 	h = H( tex.get_height() );
 }
 
+template <typename T, typename W, typename H, typename M>
+void GetDimensions( texturecube<T> tex, uint mip, thread W& w, thread H& h, thread M& m )
+{
+ 	w = W( tex.get_width( mip ) );
+ 	h = H( tex.get_height( mip ) );
+	m = M( tex.get_num_mip_levels() );
+}
+
+)MSL"
+	R"MSL(
+
 template <typename T, typename W, typename H, typename D>
 void GetDimensions( texture3d<T> tex, thread W& w, thread H& h, thread D& d )
 {

shadercompiler/ModifiedTime.cpp

@@ -47,7 +47,7 @@ struct HashCheckArguments
 std::mutex s_modifiedOutputsCS;
 std::set<std::string> s_modifiedOutputs;
 
-const std::regex s_include( "#[[:space:]]*include[[:space:]]*[<\"]([^>\"]*)" );
+const std::regex s_include( "#[[:space:]]*include[[:space:]]*([<\"])([^>\"]*)" );
 
 bool IsOutputUpToDate( const char* path, const std::string& sourceHash )
 {
@@ -112,22 +112,23 @@ bool CheckHash( const HashCheckArguments& query )
 	return true;
 }
 
-void GetSourceHash( const char* sourcePath, const char* parentData, const char* rootPath, std::set<std::string>& visited, MD5& md5 )
+void GetSourceHash( const char* sourcePath, const char* parentData, const char* rootPath, CachingIncludeHandler::IncludeType includeType, std::set<std::string>& visited, MD5& md5 )
 {
 	if( visited.find( sourcePath ) != end( visited ) )
 	{
 		return;
 	}
 	visited.insert( sourcePath );
-	if( auto opened = s_includeHandler.Open( sourcePath, parentData, rootPath ) )
+	if( auto opened = s_includeHandler.Open( sourcePath, includeType, parentData, rootPath ) )
 	{
 		md5.add( opened->data, opened->size );
 
 		std::cmatch match;
 		auto begin = opened->data;
 		while( std::regex_search( begin, opened->data + opened->size, match, s_include ) )
 		{
-			GetSourceHash( match[1].str().c_str(), opened->data, rootPath, visited, md5 );
+			CachingIncludeHandler::IncludeType it = match[1].str() == "<" ? CachingIncludeHandler::IncludeSystem : CachingIncludeHandler::IncludeLocal;
+			GetSourceHash( match[2].str().c_str(), opened->data, rootPath, it, visited, md5 );
 			begin += match.position() + match.length();
 		}
 	}
@@ -159,7 +160,7 @@ std::string GetSourceHash( const char* sourcePath, const std::vector<Macro>& def
 	md5.add( &g_generatePDB, sizeof( g_generatePDB ) );
 	md5.add( &g_skipOptimization, sizeof( g_skipOptimization ) );
 
-	GetSourceHash( sourcePath, nullptr, sourcePath, visited, md5 );
+	GetSourceHash( sourcePath, nullptr, sourcePath, CachingIncludeHandler::IncludeLocal, visited, md5 );
 	return md5.getHash();
 }
 

shadercompiler/ParserState.cpp

@@ -988,12 +988,12 @@ bool ParserState::InMacro() const
 	return m_fileStack.back().isMacro;
 }
 
-void ParserState::IncludeFile( const InlineString& fileName )
+void ParserState::IncludeFile( const InlineString& fileName, CachingIncludeHandler::IncludeType includeType )
 {
 	extern CachingIncludeHandler g_includeHandler;
 
 	std::string path( fileName.start + 1, fileName.end - 1 );
-	if( auto file = g_includeHandler.Open( path.c_str(), m_fileStack.back().code.start + 1 ) )
+	if( auto file = g_includeHandler.Open( path.c_str(), includeType, m_fileStack.back().code.start + 1 ) )
 	{
 		FileContents fileContents;
 

shadercompiler/ParserState.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "InlineString.h"
+#include "CachingIncludeHandler.h"
 
 class SymbolTable;
 class ASTNode;
@@ -234,7 +235,7 @@ class ParserState
 	bool InDiscoverMode() const;
 	PreprocessorScanResult GetPreprocessorToken( PreprocessorToken& token );
 
-	void IncludeFile( const InlineString& fileName );
+	void IncludeFile( const InlineString& fileName, CachingIncludeHandler::IncludeType includeType );
 	void ParseDefine( const PreprocessorDefine& define, const FileLocation& location, const std::vector<InlineString>& arguments );
 	PreprocessorDefine* FindDefine( const InlineString& name );
 

shadercompiler/ParserUtils.cpp

@@ -905,23 +905,27 @@ int GetNodeOrder( ASTNode* t )
 		{
 			if( child->GetNodeType() == NT_CBUFFER )
 			{
-				return 2;
+				return 3;
 			}
 		}
 		if( auto child = t->GetChildOrNull( 1 ) )
 		{
 			if( child->GetNodeType() == NT_CBUFFER )
 			{
-				return 2;
+				return 3;
 			}
 		}
 		if( GetRegisterType( t->GetType() ) )
 		{
-			return 2;
+			return 3;
 		}
 		else
 		{
-			return 1;
+			if( t->GetType().modifier == OP_CONST && t->GetType().storageClass == OP_STATIC )
+			{
+				return 1;
+			}
+			return 2;
 		}
 	case NT_TECHNIQUE:
 		return 12;
@@ -985,7 +989,7 @@ void CreateGlobalsCB( ParserState& state )
 					continue;
 				}
 			}
-			if( !GetRegisterType( child->GetType() ) )
+			if( !GetRegisterType( child->GetType() ) && !( child->GetType().modifier == OP_CONST && child->GetType().storageClass == OP_STATIC ) )
 			{
 				varStart = std::min( varStart, i );
 				varEnd = std::max( varEnd, i );