// Copyright © 2023 CCP ehf.

#include "stdafx.h"

#if _WIN32

#include "EffectCompilerDX11.h"

#include "CompileMessageQueue.h"

#include "StringTable.h"

#include "EffectData.h"

#include "SymbolTable.h"

#include "ASTNode.h"

#include "ParserUtils.h"

#include "HLSLParser.h"

#include "ParserState.h"

#include "FXAnalyzer.h"

#include "TextureFunctionConversionDX11.h"

#include "YamlOutput.h"

#include "Macro.h"

#include "OutputHLSL.h"

#include "DxReflection.h"

#include <WorkQueue.h>

#define DXIL_FOURCC( ch0, ch1, ch2, ch3 ) ( \

(uint32_t)(uint8_t)( ch0 ) | (uint32_t)(uint8_t)( ch1 ) << 8 | \

(uint32_t)(uint8_t)( ch2 ) << 16 | (uint32_t)(uint8_t)( ch3 ) << 24 )

enum DxilFourCC

{

DFCC_Container = DXIL_FOURCC( 'D', 'X', 'B', 'C' ), // for back-compat with tools that look for DXBC containers

DFCC_ResourceDef = DXIL_FOURCC( 'R', 'D', 'E', 'F' ),

DFCC_InputSignature = DXIL_FOURCC( 'I', 'S', 'G', '1' ),

DFCC_OutputSignature = DXIL_FOURCC( 'O', 'S', 'G', '1' ),

DFCC_PatchConstantSignature = DXIL_FOURCC( 'P', 'S', 'G', '1' ),

DFCC_ShaderStatistics = DXIL_FOURCC( 'S', 'T', 'A', 'T' ),

DFCC_ShaderDebugInfoDXIL = DXIL_FOURCC( 'I', 'L', 'D', 'B' ),

DFCC_ShaderDebugName = DXIL_FOURCC( 'I', 'L', 'D', 'N' ),

DFCC_FeatureInfo = DXIL_FOURCC( 'S', 'F', 'I', '0' ),

DFCC_PrivateData = DXIL_FOURCC( 'P', 'R', 'I', 'V' ),

DFCC_RootSignature = DXIL_FOURCC( 'R', 'T', 'S', '0' ),

DFCC_DXIL = DXIL_FOURCC( 'D', 'X', 'I', 'L' ),

DFCC_PipelineStateValidation = DXIL_FOURCC( 'P', 'S', 'V', '0' ),

DFCC_RuntimeData = DXIL_FOURCC( 'R', 'D', 'A', 'T' ),

DFCC_ShaderHash = DXIL_FOURCC( 'H', 'A', 'S', 'H' ),

};

extern CompileMessageQueue g_messages;

extern StringTable g_stringTable;

extern bool g_printWarnings;

extern unsigned g_optimizationLevel;

extern bool g_avoidFlowControl;

extern bool g_generatePDB;

extern bool g_skipOptimization;

static bool FindParameterBySemantics( ASTNode* node, const char** semantics, std::vector<Symbol*>* path, bool outParameter = false )

{

for( unsigned j = 0; j < node->GetChildrenCount(); ++j )

{

Symbol* symbol = node->GetChild( j )->GetSymbol();

if( symbol == nullptr )

{

continue;

}

if( outParameter )

{

if( node->GetChild( j )->GetToken() == 0 || node->GetChild( j )->GetToken()->type == OP_IN )

{

continue;

}

}

for( unsigned k = 0; semantics[k]; ++k )

{

if( _stricmp( ToString( symbol->semantic ).c_str(), semantics[k] ) == 0 )

{

if( path )

{

path->clear();

path->push_back( symbol );

}

return true;

}

}

if( node->GetChild( j )->GetType().symbol && node->GetChild( j )->GetType().symbol->definition )

{

for( unsigned i = 0; i < node->GetChild( j )->GetType().symbol->definition->GetChildrenCount(); ++i )

{

if( FindParameterBySemantics( node->GetChild( j )->GetType().symbol->definition->GetChild( i ), semantics, path ) )

{

if( path )

{

path->insert( path->begin(), symbol );

}

return true;

}

}

}

}

return false;

}

bool FindOutputBySemantics( ASTNode* node, const char** semantics, std::vector<Symbol*>* path )

{

// check "out" function arguments

if( FindParameterBySemantics( node, semantics, path, true ) )

{

return true;

}

// check return value if it has semantics

if( node->GetSymbol() && node->GetSymbol()->semantic.start )

{

std::string sematic = ToString( node->GetSymbol()->semantic );

for( unsigned i = 0; semantics[i]; ++i )

{

if( _stricmp( sematic.c_str(), semantics[i] ) == 0 )

{

if( path )

{

path->push_back( nullptr );

}

return true;

}

}

}

// finally check return value as a structure

if( node->GetType().symbol &&

node->GetType().symbol->definition )

{

for( unsigned i = 0; i < node->GetType().symbol->definition->GetChildrenCount(); ++i )

{

if( FindParameterBySemantics( node->GetType().symbol->definition->GetChild( i ), semantics, path ) )

{

if( path )

{

path->insert( path->begin(), nullptr );

}

return true;

}

}

}

return false;

}

void PrintValuePath( std::ostream& os, const std::vector<Symbol*>& path, const char* functionSymbol )

{

bool first = true;

for( auto it = path.begin(); it != path.end(); ++it )

{

if( first )

{

first = false;

}

else

{

os << ".";

}

if( *it )

{

os << ( *it )->name;

}

else

{

os << functionSymbol;

}

}

}

static void PatchSemantics( InputStageType shaderStage, ASTNode* callNode )

{

Symbol* entryPointSymbol = callNode->GetSymbol();

if( !entryPointSymbol )

{

return;

}

ASTNode* functionHeader = entryPointSymbol->definition->GetChildOrNull( 0 );

if( functionHeader == nullptr )

{

return;

}

std::vector<Symbol*> targetPath;

switch( shaderStage )

{

case VERTEX_STAGE: {

const char* semantics[] = { "position", nullptr };

if( FindOutputBySemantics( functionHeader, semantics, &targetPath ) )

{

if( targetPath.back() )

{

targetPath.back()->semantic = MakeInlineString( "SV_Position" );

}

else

{

entryPointSymbol->semantic = MakeInlineString( "SV_Position" );

}

}

break;

}

case PIXEL_STAGE: {

{

const char* semantics[] = { "color", "color0", nullptr };

if( FindOutputBySemantics( functionHeader, semantics, &targetPath ) )

{

if( targetPath.back() )

{

targetPath.back()->semantic = MakeInlineString( "SV_Target0" );

}

else

{

entryPointSymbol->semantic = MakeInlineString( "SV_Target0" );

}

}

}

{

const char* semantics[] = { "color1", nullptr };

if( FindOutputBySemantics( functionHeader, semantics, &targetPath ) )

{

if( targetPath.back() )

{

targetPath.back()->semantic = MakeInlineString( "SV_Target1" );

}

else

{

entryPointSymbol->semantic = MakeInlineString( "SV_Target1" );

}

}

}

break;

}

}

}

static PatchAction PatchShader( InputStageType shaderStage, ASTNode* callNode, ParserState& state, CodeStream& os, std::string& entryPointName )

{

ZoneScoped;

// 1. wrap uniforms

// 2. fix VPOS

bool wrapUniforms = false;

bool fixVPOS = false;

bool fixVPOSType = false;

Symbol* entryPointSymbol = callNode->GetSymbol();

if( entryPointSymbol == nullptr || entryPointSymbol->definition == nullptr )

{

return PATCH_ERROR;

}

ASTNode* functionHeader = entryPointSymbol->definition->GetChildOrNull( 0 );

if( functionHeader == nullptr )

{

return PATCH_ERROR;

}

std::vector<Symbol*> targetPath;

std::vector<Symbol*> outPositionPath;

std::vector<Symbol*> vfacePath;

if( shaderStage == VERTEX_STAGE )

{

const char* position[] = { "position", "sv_position", nullptr };

FindOutputBySemantics( functionHeader, position, &outPositionPath );

}

// check for uniform parameters

if( callNode->GetChildrenCount() )

{

unsigned count = 0;

for( unsigned i = 0; i < functionHeader->GetChildrenCount(); ++i )

{

if( IsUniformInputArgument( functionHeader->GetChild( i ) ) )

{

++count;

}

}

if( count != callNode->GetChildrenCount() )

{

state.ShowMessage( callNode->GetLocation(), EC_NO_OVERRIDE, ToString( functionHeader->GetToken()->stringValue ).c_str(), "" );

return PATCH_ERROR;

}

wrapUniforms = true;

}

// find VPOS+POSITION parameters

std::vector<Symbol*> positionPath;

std::vector<Symbol*> vposPath;

const char* vpos[] = { "vpos", nullptr };

fixVPOSType = fixVPOS = FindParameterBySemantics( functionHeader, vpos, &vposPath );

if( fixVPOS )

{

const char* position[] = { "position", "sv_position", nullptr };

bool foundPosition = FindParameterBySemantics( functionHeader, position, &positionPath );

fixVPOS &= foundPosition;

}

if( fixVPOSType )

{

if( vposPath.back() )

{

if( vposPath.back()->type.symbol ||

( vposPath.back()->type.builtInType == OP_FLOAT && vposPath.back()->type.width == 4 && vposPath.back()->type.height == 1 ) )

{

fixVPOSType = false;

}

}

}

if( !wrapUniforms && !fixVPOS && !fixVPOSType && ( shaderStage != VERTEX_STAGE || outPositionPath.empty() ) )

{

entryPointName = ToString( entryPointSymbol->name );

return PATCH_USE;

}

if( entryPointSymbol->definition->GetChildOrNull( 2 ) )

{

os << HLSL{ entryPointSymbol->definition->GetChildOrNull( 2 ), nullptr };

}

// return type

os << functionHeader->GetType();

// name

InlineString name = state.AllocateName();

os << ' ' << name << "( ";

bool first = true;

for( size_t i = 0; i < functionHeader->GetChildrenCount(); ++i )

{

if( IsUniformInputArgument( functionHeader->GetChild( i ) ) )

{

continue;

}

Symbol* symbol = functionHeader->GetChild( i )->GetSymbol();

if( symbol == nullptr )

{

return PATCH_ERROR;

}

if( fixVPOS && symbol->semantic.start && _stricmp( ToString( symbol->semantic ).c_str(), "vpos" ) == 0 )

{

continue;

}

if( !first )

{

os << ", ";

}

else

{

first = false;

}

if( fixVPOSType && symbol->semantic.start && _stricmp( ToString( symbol->semantic ).c_str(), "vpos" ) == 0 )

{

os << "float4 " << functionHeader->GetChild( i )->GetSymbol()->name << ": VPOS";

}

else

{

os << HLSL{ functionHeader->GetChild( i ), nullptr };

}

}

os << " )";

// semantics

if( functionHeader->GetSymbol()->semantic.start )

{

os << " : " << functionHeader->GetSymbol()->semantic;

}

os << "\n{\n";

unsigned uniformIndex = 0;

std::map<size_t, InlineString> defaultUniformArguments;

for( size_t i = 0; i < functionHeader->GetChildrenCount(); ++i )

{

if( IsUniformInputArgument( functionHeader->GetChild( i ) ) )

{

if( callNode->GetChildrenCount() <= uniformIndex && functionHeader->GetChild( i )->GetChildOrNull( 1 ) != nullptr )

{

InlineString uniformName = state.AllocateName();

Type type = functionHeader->GetChild( i )->GetType();

type.storageClass = 0;

os << type << ' ' << uniformName << " = " << HLSL{ functionHeader->GetChild( i )->GetChildOrNull( 1 ), nullptr };

os << ";\n";

defaultUniformArguments[i] = uniformName;

}

uniformIndex++;

}

}

if( functionHeader->GetSymbol()->type.symbol || functionHeader->GetSymbol()->type.builtInType != OP_VOID )

{

os << functionHeader->GetType() << " __returnValue = ";

}

// call original function

uniformIndex = 0;

os << entryPointSymbol->name << "(";

for( size_t i = 0; i < functionHeader->GetChildrenCount(); ++i )

{

if( i > 0 )

{

os << ", ";

}

if( IsUniformInputArgument( functionHeader->GetChild( i ) ) )

{

if( callNode->GetChildrenCount() > uniformIndex )

{

os << HLSL{ callNode->GetChild( uniformIndex ), nullptr };

}

else if( functionHeader->GetChild( i )->GetChildOrNull( 1 ) != nullptr )

{

os << defaultUniformArguments[i];

}

uniformIndex++;

}

else

{

Symbol* symbol = functionHeader->GetChild( i )->GetSymbol();

if( symbol == nullptr )

{

return PATCH_ERROR;

}

if( fixVPOS && symbol->semantic.start && _stricmp( ToString( symbol->semantic ).c_str(), "vpos" ) == 0 )

{

// pass VPOS value from POSITION

PrintValuePath( os, positionPath, "" );

if( symbol->type.symbol == nullptr && symbol->type.builtInType == OP_FLOAT && symbol->type.height == 1 &&

positionPath.back()->type.symbol == nullptr && positionPath.back()->type.builtInType == OP_FLOAT &&

positionPath.back()->type.height == 1 && positionPath.back()->type.width != symbol->type.width )

{

const char* swizzle = "xyzw";

os << ".";

for( int k = 0; k < symbol->type.width; ++k )

{

os << swizzle[std::min( k, positionPath.back()->type.width - 1 )];

}

}

}

else if( fixVPOSType && symbol->semantic.start && _stricmp( ToString( symbol->semantic ).c_str(), "vpos" ) == 0 )

{

Type type = symbol->type;

os << type << "( " << symbol->name;

if( type.width != 4 )

{

const char* swizzle = "xyzw";

os << ".";

for( int k = 0; k < symbol->type.width; ++k )

{

os << swizzle[std::min( k, symbol->type.width - 1 )];

}

}

os << " )";

}

else

{

os << symbol->name;

}

}

}

os << ");\n";

if( functionHeader->GetSymbol()->type.symbol || functionHeader->GetSymbol()->type.builtInType != OP_VOID )

{

os << "return __returnValue;\n";

}

os << "}\n";

entryPointName = ToString( name );

return PATCH_USE;

}

bool EffectCompilerDX11::Create()

{

ZoneScoped;

return SUCCEEDED( ::DxcCreateInstance( CLSID_DxcUtils, IID_PPV_ARGS( &m_dxilUtils ) ) );

}

bool MatchShaderInputOutput( ID3D11ShaderReflection* output, ID3D11ShaderReflection* input )

{

D3D11_SHADER_DESC vsReflDesc;

if( FAILED( output->GetDesc( &vsReflDesc ) ) )

{

g_messages.AddMessage( "\\memory(0): error X0000: Could not get shader reflection description" );

return false;

}

D3D11_SHADER_DESC psReflDesc;

if( FAILED( input->GetDesc( &psReflDesc ) ) )

{

g_messages.AddMessage( "\\memory(0): error X0000: Could not get shader reflection description" );

return false;

}

for( unsigned k = 0; k < psReflDesc.InputParameters; ++k )

{

D3D11_SIGNATURE_PARAMETER_DESC psDesc;

if( FAILED( input->GetInputParameterDesc( k, &psDesc ) ) )

{

g_messages.AddMessage( "\\memory(0): error X0000: Could not get shader input parameter description" );

return false;

}

if( psDesc.SystemValueType != D3D10_NAME_UNDEFINED )

{

continue;

}

bool found = false;

for( unsigned n = 0; n < vsReflDesc.OutputParameters; ++n )

{

D3D11_SIGNATURE_PARAMETER_DESC vsDesc;

if( FAILED( output->GetOutputParameterDesc( n, &vsDesc ) ) )

{

g_messages.AddMessage( "\\memory(0): error X0000: Could not get shader output parameter description" );

return false;

}

if( vsDesc.Register == psDesc.Register && ( ( ~vsDesc.Mask & psDesc.Mask ) == 0 ) )

{

if( _stricmp( vsDesc.SemanticName, psDesc.SemanticName ) || vsDesc.SemanticIndex != psDesc.SemanticIndex )

{

g_messages.AddMessage( "\\memory(0): error X0000: Vertex/pixel shader signature mismatch" );

return false;

}

found = true;

break;

}

}

if( !found )

{

g_messages.AddMessage( "\\memory(0): error X0000: Vertex/pixel shader signature mismatch" );

return false;

}

}

return true;

}

std::string PrintPrettyCode( const char* code, const char* indent )

{

std::stringstream os;

while( *code )

{

const char* end = code;

while( *end && *end != '\n' )

{

++end;

}

if( strncmp( code, "#line", 5 ) && code != end )

{

os << indent;

os.write( code, end - code );

os << std::endl;

}

code = end + 1;

if( *end == 0 )

{

break;

}

}

return os.str();

}

void PrintShaderOutListing( YamlOutput& listing, ID3DBlob* effectData, ID3D11ShaderReflection* reflection )

{

ZoneScoped;

if( !listing.enabled() )

{

return;

}

CComPtr<ID3DBlob> disassembly;

if( SUCCEEDED( D3DDisassemble( effectData->GetBufferPointer(), effectData->GetBufferSize(), D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS, nullptr, &disassembly ) ) )

{

listing.literal( "asm" ).literal( reinterpret_cast<const char*>( disassembly->GetBufferPointer() ) );

}

D3D11_SHADER_DESC desc;

if( reflection && SUCCEEDED( reflection->GetDesc( &desc ) ) )

{

listing.literal( "stats" ).dict().literal( "Resources" ).dict().literal( "constantBuffers" ).literal( desc.ConstantBuffers ).literal( "boundResources" ).literal( desc.BoundResources ).literal( "inputParameters" ).literal( desc.InputParameters ).literal( "outputParameters" ).literal( desc.OutputParameters ).literal( "tempRegisterCount" ).literal( desc.TempRegisterCount ).literal( "tempArrayCount" ).literal( desc.TempArrayCount ).end().literal( "Instructions" ).dict().literal( "instructionCount" ).literal( desc.InstructionCount ).literal( "defCount" ).literal( desc.DefCount ).literal( "textureNormalInstructions" ).literal( desc.TextureNormalInstructions ).literal( "textureLoadInstructions" ).literal( desc.TextureLoadInstructions ).literal( "textureCompInstructions" ).literal( desc.TextureCompInstructions ).literal( "textureBiasInstructions" ).literal( desc.TextureBiasInstructions ).literal( "textureGradientInstructions" ).literal( desc.TextureGradientInstructions ).literal( "floatInstructionCount" ).literal( desc.FloatInstructionCount ).literal( "intInstructionCount" ).literal( desc.IntInstructionCount ).literal( "uintInstructionCount" ).literal( desc.UintInstructionCount ).literal( "staticFlowControlCount" ).literal( desc.StaticFlowControlCount ).literal( "dynamicFlowControlCount" ).literal( desc.DynamicFlowControlCount ).literal( "macroInstructionCount" ).literal( desc.MacroInstructionCount ).literal( "arrayInstructionCount" ).literal( desc.ArrayInstructionCount ).literal( "cutInstructionCount" ).literal( desc.CutInstructionCount ).literal( "emitInstructionCount" ).literal( desc.EmitInstructionCount ).literal( "cBarrierInstructions" ).literal( desc.cBarrierInstructions ).literal( "cInterlockedInstructions" ).literal( desc.cInterlockedInstructions ).literal( "cTextureStoreInstructions" ).literal( desc.cTextureStoreInstructions ).end().literal( "Misc" ).dict().literal( "GSOutputTopology" ).literal( desc.GSOutputTopology ).literal( "inputPrimitive" ).literal( desc.InputPrimitive ).literal( "GSMaxOutputVertexCount" ).literal( desc.GSMaxOutputVertexCount ).literal( "patchConstantParameters" ).literal( desc.PatchConstantParameters ).literal( "cGSInstanceCount" ).literal( desc.cGSInstanceCount ).literal( "HSOutputPrimitive" ).literal( desc.HSOutputPrimitive ).literal( "HSPartitioning" ).literal( desc.HSPartitioning ).literal( "tessellatorDomain" ).literal( desc.TessellatorDomain ).end().end();

}

}

void PrintAnnotations( YamlOutput& listing, const std::map<StringReference, Annotation>& annotations )

{

if( !listing.enabled() )

{

return;

}

listing.literal( "annotations" ).list();

for( auto a = annotations.begin(); a != annotations.end(); ++a )

{

listing.dict()

.literal( "name" )

.literal( g_stringTable.GetString( a->first ) )

.literal( "annotationType" );

switch( a->second.type )

{

case ANNOTATION_TYPE_BOOL:

listing

.literal( "bool" )

.literal( "value" )

.literal( a->second.intValue != 0 );

break;

case ANNOTATION_TYPE_INT:

listing

.literal( "int" )

.literal( "value" )

.literal( a->second.intValue );

break;

case ANNOTATION_TYPE_FLOAT:

listing

.literal( "float" )

.literal( "value" )

.literal( a->second.floatValue );

break;

default:

listing

.literal( "string" )

.literal( "value" )

.literal( g_stringTable.GetString( a->second.stringValue ) );

break;

}

listing.end();

}

listing.end();

}

YamlOutput& YamlTextureType( YamlOutput& listing, TextureType type )

{

switch( type )

{

case TEX_TYPE_1D:

listing.literal( "1D texture" );

return listing;

case TEX_TYPE_2D:

listing.literal( "2D texture" );

return listing;

case TEX_TYPE_3D:

listing.literal( "3D texture" );

return listing;

case TEX_TYPE_CUBE:

listing.literal( "CUBE texture" );

return listing;

case TEX_TYPE_TYPELESS:

listing.literal( "typeless texture" );

return listing;

case TEX_TYPE_BUFFER:

listing.literal( "buffer" );

return listing;

case TEX_TYPE_STRUCTURED_BUFFER:

listing.literal( "structured buffer" );

return listing;

case TEX_TYPE_TBUFFER:

listing.literal( "TBuffer" );

return listing;

case TEX_TYPE_BYTEADDRESS_BUFFER:

listing.literal( "byte address buffer" );

return listing;

case TEX_TYPE_UAV_RWTYPED:

listing.literal( "UAV typed" );

return listing;

case TEX_TYPE_UAV_RWSTRUCTURED:

listing.literal( "UAV structured" );

return listing;

case TEX_TYPE_UAV_RWBYTEADDRESS:

listing.literal( "UAV RW byte address" );

return listing;

case TEX_TYPE_UAV_APPEND_STRUCTURED:

listing.literal( "UAV append structured" );

return listing;

case TEX_TYPE_UAV_CONSUME_STRUCTURED:

listing.literal( "UAV consume structured" );

return listing;

case TEX_TYPE_UAV_RWSTRUCTURED_WITH_COUNTER:

listing.literal( "UAV structured with counter" );

return listing;

default:

listing.literal( "other" );

return listing;

}

}

void PrintStageInfo( YamlOutput& listing, const StageData& stage, const EffectData& result )

{

if( !listing.enabled() )

{

return;

}

if( !stage.constants.empty() )

{

listing.literal( "constants" ).list();

for( auto it = stage.constants.begin(); it != stage.constants.end(); ++it )

{

listing.dict()

.literal( "name" )

.literal( g_stringTable.GetString( it->name ) )

.literal( "constantType" )

.literal( ToString( it->type ) )

.literal( "dimension" )

.literal( it->dimension )

.literal( "arrayElements" )

.literal( it->elements )

.literal( "autoregister" )

.literal( it->isAutoregister )

.literal( "sRGB" )

.literal( it->isSRGB );

auto annotations = result.annotations.find( it->name );

if( annotations != result.annotations.end() )

{

PrintAnnotations( listing, annotations->second.annotations );

}

listing.end();

}

listing.end();

}

if( !stage.samplers.empty() )

{

listing.literal( "samplers" ).list();

for( auto it = stage.samplers.begin(); it != stage.samplers.end(); ++it )

{

listing.dict()

.literal( "register" )

.literal( it->first )

.literal( "name" )

.literal( g_stringTable.GetString( it->second.name ) )

.literal( "filter" )

.literal( int( it->second.filter ) )

.literal( "comparison" )

.literal( int( it->second.comparison ) )

.literal( "minFilter" )

.literal( int( it->second.minFilter ) )

.literal( "magFilter" )

.literal( int( it->second.magFilter ) )

.literal( "mipFilter" )

.literal( int( it->second.mipFilter ) )

.literal( "addressU" )

.literal( int( it->second.addressU ) )

.literal( "addressV" )

.literal( int( it->second.addressV ) )

.literal( "addressW" )

.literal( int( it->second.addressW ) )

.literal( "mipLODBias" )

.literal( it->second.mipLODBias )

.literal( "maxAnisotropy" )

.literal( int( it->second.maxAnisotropy ) )

.literal( "comparisonFunc" )

.literal( int( it->second.comparisonFunc ) )

.literal( "borderColor" )

.list()

.literal( it->second.borderColor.x )

.literal( it->second.borderColor.y )

.literal( it->second.borderColor.z )

.literal( it->second.borderColor.w )

.end()

.literal( "minLOD" )

.literal( it->second.minLOD )

.literal( "maxLOD" )

.literal( it->second.maxLOD )

.literal( "srgbTexture" )

.literal( it->second.srgbTexture != 0 )

.literal( "isDynamic" )

.literal( it->second.isDynamic != 0 );

auto annotations = result.annotations.find( it->second.name );

if( annotations != result.annotations.end() )

{

PrintAnnotations( listing, annotations->second.annotations );

}

listing.end();

}

listing.end();

}

if( !stage.textures.empty() )

{

listing.literal( "textures" ).list();

for( auto it = stage.textures.begin(); it != stage.textures.end(); ++it )

{

listing.dict()

.literal( "register" )

.literal( it->first )

.literal( "name" )

.literal( g_stringTable.GetString( it->second.name ) )

.literal( "textureType" )

.literal( it->second.type )

.literal( "autoregister" )

.literal( it->second.isAutoregister )

.literal( "sRGB" )

.literal( it->second.isSRGB );

auto annotations = result.annotations.find( it->second.name );

if( annotations != result.annotations.end() )

{

PrintAnnotations( listing, annotations->second.annotations );

}

listing.end();

}

listing.end();

}

if( !stage.uavs.empty() )

{

listing.literal( "uavs" ).list();

for( auto it = stage.uavs.begin(); it != stage.uavs.end(); ++it )

{

listing.dict()

.literal( "register" )

.literal( it->first )

.literal( "name" )

.literal( g_stringTable.GetString( it->second.name ) )

.literal( "resourceType" )

.literal( it->second.type )

.literal( "autoregister" )

.literal( it->second.isAutoregister );

auto annotations = result.annotations.find( it->second.name );

if( annotations != result.annotations.end() )

{

PrintAnnotations( listing, annotations->second.annotations );

}

listing.end();

}

listing.end();

}

if( !stage.registerInputs.empty() )

{

listing.literal( "registers" ).list();

for( auto it = stage.registerInputs.begin(); it != stage.registerInputs.end(); ++it )

{

listing.dict()

.literal( "registerType" )

.literal( it->registerType )

.literal( "register" )

.literal( it->registerIndex )

.end();

}

listing.end();

}

}

void PrintStageInfo( YamlOutput& listing, const StageInput& stage, const EffectData& result )

{

PrintStageInfo( listing, static_cast<const StageData&>( stage ), result );

if( !stage.pipelineInputs.empty() )

{

listing.literal( "inputs" ).list();

for( auto it = stage.pipelineInputs.begin(); it != stage.pipelineInputs.end(); ++it )

{

listing.dict()

.literal( "register" )

.literal( it->registerIndex )

.literal( "name" )

.literal( it->name )

.literal( "index" )

.literal( it->index )

.literal( "usedMask" )

.literal( it->usedMask )

.end();

}

listing.end(); // inputs

}

if( !stage.staticSamplers.empty() )

{

listing.literal( "staticSamplers" ).list();

for( auto& it : stage.staticSamplers )

{

listing.dict()

.literal( "register" )

.literal( it.registerIndex )

.literal( "space" )

.literal( it.registerSpace )

.literal( "comparison" )

.literal( int( it.comparison ) )

.literal( "minFilter" )

.literal( int( it.minFilter ) )

.literal( "magFilter" )

.literal( int( it.magFilter ) )

.literal( "mipFilter" )

.literal( int( it.mipFilter ) )

.literal( "addressU" )

.literal( int( it.addressU ) )

.literal( "addressV" )

.literal( int( it.addressV ) )

.literal( "addressW" )

.literal( int( it.addressW ) )

.literal( "mipLODBias" )

.literal( it.mipLODBias )

.literal( "maxAnisotropy" )

.literal( int( it.maxAnisotropy ) )

.literal( "comparisonFunc" )

.literal( int( it.comparisonFunc ) )

.literal( "borderColor" )

.literal( it.borderColor )

.literal( "minLOD" )

.literal( it.minLOD )

.literal( "maxLOD" )

.literal( it.maxLOD )

.end();

}

listing.end(); //staticSamplers

}

}

std::string SanitizeCode( const std::string& src )

{

ZoneScoped;

std::regex line( "#line[^\\n]*\\n?\\n" );

return std::regex_replace( src, line, std::string( "" ) );

}

bool ParseShaderName( const InlineString& name, InputStageType& type )

{

if( _stricmp( ToString( name ).c_str(), "vertexshader" ) == 0 )

{

type = VERTEX_STAGE;

}

else if( _stricmp( ToString( name ).c_str(), "pixelshader" ) == 0 )

{

type = PIXEL_STAGE;

}

else if( _stricmp( ToString( name ).c_str(), "computeshader" ) == 0 )

{

type = COMPUTE_STAGE;

}

else if( _stricmp( ToString( name ).c_str(), "geometryshader" ) == 0 )

{

type = GEOMETRY_STAGE;

}

else if( _stricmp( ToString( name ).c_str(), "hullshader" ) == 0 )

{

type = HULL_STAGE;

}

else if( _stricmp( ToString( name ).c_str(), "domainshader" ) == 0 )

{

type = DOMAIN_STAGE;

}

else

{

return false;

}

return true;

}

bool EffectCompilerDX11::CompileEffect( const char* source, size_t sourceLength, const std::vector<Macro>& defines, EffectData& result, IWorkQueue* workQueue )

{

return CompileEffect( source, sourceLength, defines, result, { nullptr, false }, workQueue );

}

DWORD GetOptimizationLevel()

{

switch( g_optimizationLevel )

{

case 0:

return D3DCOMPILE_OPTIMIZATION_LEVEL0;

case 1:

return D3DCOMPILE_OPTIMIZATION_LEVEL1;

case 2:

return D3DCOMPILE_OPTIMIZATION_LEVEL2;

default:

return D3DCOMPILE_OPTIMIZATION_LEVEL3;

}

}

RegisterInputDescription GetRegisterInputDescription( const Type& type, const RegisterSpecifier& reg )

{

RegisterInputDescription desc;

switch( type.builtInType )

{

case OP_BUFFER:

case OP_RAYTRACING_ACCELERATION_STRUCTURE:

desc.registerType = RT_SRV_BUFFER;

break;

case OP_STRUCTUREDBUFFER:

desc.registerType = RT_SRV_STRUCTURED_BUFFER;

break;

case OP_TEXTURE1D:

desc.registerType = RT_SRV_TEXTURE1D;

break;

case OP_TEXTURE1DARRAY:

desc.registerType = RT_SRV_TEXTURE1DARRAY;

break;

case OP_TEXTURE:

case OP_TEXTURE2D:

desc.registerType = RT_SRV_TEXTURE2D;

break;

case OP_TEXTURE2DARRAY:

desc.registerType = RT_SRV_TEXTURE2DARRAY;

break;

case OP_TEXTURE2DMS:

desc.registerType = RT_SRV_TEXTURE2DMS;

break;

case OP_TEXTURE2DMSARRAY:

desc.registerType = RT_SRV_TEXTURE2DMSARRAY;

break;

case OP_TEXTURE3D:

desc.registerType = RT_SRV_TEXTURE3D;

break;

case OP_TEXTURECUBE:

desc.registerType = RT_SRV_TEXTURECUBE;

break;

case OP_TEXTURECUBEARRAY:

desc.registerType = RT_SRV_TEXTURECUBEARRAY;

break;

case OP_RWBUFFER:

desc.registerType = RT_UAV_BUFFER;