mirror of
https://github.com/Eragon-Brisingr/UShaderLab.git
synced 2026-09-15 06:44:35 +00:00
Support UMaterial all property settings, enhance VSCode code-snippets
This commit is contained in:
Eragon-Brisingr
@@ -45,6 +45,8 @@ float2 UE_DecalDerivativeDDY() { return (float2)0; }
|
||||
float UE_DecalLifetimeOpacity() { return (float)0; }
|
||||
float UE_DeltaTime() { return (float)0; }
|
||||
float UE_DistanceCullFade() { return (float)0; }
|
||||
float3 UE_DistanceFieldGradient() { return (float3)0; }
|
||||
float UE_DistanceToNearestSurface() { return (float)0; }
|
||||
float UE_EyeAdaptation() { return (float)0; }
|
||||
float UE_IsFirstPerson() { return (float)0; }
|
||||
float UE_IsOrthographic() { return (float)0; }
|
||||
|
||||
@@ -679,8 +679,9 @@ namespace
|
||||
}
|
||||
else
|
||||
{
|
||||
// Long-tail setting: stored verbatim. Allowlist + type validation happens in
|
||||
// FShaderLabSettingsApplier at build time (the parser is Engine-reflection-free).
|
||||
// Long-tail setting: stored verbatim (dotted struct keys like `Struct.Field` included).
|
||||
// Reflection resolution + type validation happens in FShaderLabSettingsApplier at build
|
||||
// time (the parser is Engine-reflection-free).
|
||||
Model.RawSettings.Emplace(Key, Value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,107 +4,123 @@
|
||||
|
||||
#include "Materials/Material.h"
|
||||
#include "Materials/MaterialInterface.h"
|
||||
#include "Misc/StringOutputDevice.h"
|
||||
#include "UObject/Class.h"
|
||||
#include "UObject/EnumProperty.h"
|
||||
#include "UObject/UnrealType.h"
|
||||
|
||||
namespace ShaderLabSettings_Private
|
||||
{
|
||||
// UMaterial properties a `.usl` Settings block may set by reflection. Names only — adding a
|
||||
// setting is a one-line edit here. Every entry must be a non-editor-only property so the cooked
|
||||
// runtime shell can apply the identical value.
|
||||
const TSet<FName>& AllowedSettingNames()
|
||||
// Resolve a (possibly dotted) key such as "DisplacementScaling.Magnitude" to the leaf property + the
|
||||
// address of its value. OutTop is the top-level UMaterial property (used for the deny/editable checks).
|
||||
// bOutNotFound = a segment does not exist (a typo at cook, or an editor-only member stripped from the
|
||||
// cooked class at runtime) — distinguished from a structural error (dotting into a non-struct).
|
||||
bool ResolveKeyPath(UMaterial& Material, const FString& Key,
|
||||
FProperty*& OutTop, FProperty*& OutLeaf, void*& OutValuePtr, bool& bOutNotFound, FString& OutReason)
|
||||
{
|
||||
static const TSet<FName> Names = {
|
||||
FName(TEXT("OpacityMaskClipValue")),
|
||||
FName(TEXT("TranslucencyLightingMode")),
|
||||
FName(TEXT("TranslucencyPass")),
|
||||
FName(TEXT("bCastDynamicShadowAsMasked")),
|
||||
FName(TEXT("bEnableResponsiveAA")),
|
||||
FName(TEXT("bScreenSpaceReflections")),
|
||||
FName(TEXT("bContactShadows")),
|
||||
FName(TEXT("bIsThinSurface")),
|
||||
FName(TEXT("DitheredLODTransition")),
|
||||
FName(TEXT("RefractionMethod")),
|
||||
FName(TEXT("NumCustomizedUVs")), // caps how many CustomizedUV<i> vertex outputs the material compiles
|
||||
};
|
||||
return Names;
|
||||
}
|
||||
bOutNotFound = false;
|
||||
OutTop = OutLeaf = nullptr;
|
||||
OutValuePtr = nullptr;
|
||||
|
||||
bool ParseBool(const FString& In, bool& Out)
|
||||
{
|
||||
const FString V = In.TrimStartAndEnd();
|
||||
if (V == TEXT("true") || V == TEXT("1")) { Out = true; return true; }
|
||||
if (V == TEXT("false") || V == TEXT("0")) { Out = false; return true; }
|
||||
return false;
|
||||
}
|
||||
TArray<FString> Segments;
|
||||
Key.ParseIntoArray(Segments, TEXT("."));
|
||||
if (Segments.Num() == 0)
|
||||
{
|
||||
OutReason = TEXT("empty setting key");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Coerce `Value` to `Prop`'s type and write it into `Material`. Returns false with a reason on
|
||||
// type mismatch / unresolved enum token.
|
||||
bool CoerceAndSet(UMaterial& Material, FProperty* Prop, const FString& Value, FString& OutReason)
|
||||
{
|
||||
FProperty* Prop = UMaterial::StaticClass()->FindPropertyByName(FName(*Segments[0]));
|
||||
if (!Prop)
|
||||
{
|
||||
bOutNotFound = true;
|
||||
return false;
|
||||
}
|
||||
OutTop = Prop;
|
||||
void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(&Material);
|
||||
|
||||
if (FBoolProperty* BoolProp = CastField<FBoolProperty>(Prop))
|
||||
for (int32 i = 1; i < Segments.Num(); ++i)
|
||||
{
|
||||
bool bVal = false;
|
||||
if (!ParseBool(Value, bVal))
|
||||
FStructProperty* StructProp = CastField<FStructProperty>(Prop);
|
||||
if (!StructProp)
|
||||
{
|
||||
OutReason = TEXT("expected true/false");
|
||||
OutReason = FString::Printf(TEXT("'%s' is not a struct; cannot access sub-field '%s'"), *Segments[i - 1], *Segments[i]);
|
||||
return false;
|
||||
}
|
||||
BoolProp->SetPropertyValue_InContainer(&Material, bVal);
|
||||
return true;
|
||||
}
|
||||
if (FFloatProperty* FloatProp = CastField<FFloatProperty>(Prop))
|
||||
{
|
||||
FloatProp->SetPropertyValue(ValuePtr, FCString::Atof(*Value));
|
||||
return true;
|
||||
}
|
||||
if (FDoubleProperty* DoubleProp = CastField<FDoubleProperty>(Prop))
|
||||
{
|
||||
DoubleProp->SetPropertyValue(ValuePtr, FCString::Atod(*Value));
|
||||
return true;
|
||||
}
|
||||
if (FIntProperty* IntProp = CastField<FIntProperty>(Prop))
|
||||
{
|
||||
IntProp->SetPropertyValue(ValuePtr, FCString::Atoi(*Value));
|
||||
return true;
|
||||
}
|
||||
// TEnumAsByte<EFoo> reflects as FByteProperty with ->Enum set; resolve the bare token by name.
|
||||
if (FByteProperty* ByteProp = CastField<FByteProperty>(Prop))
|
||||
{
|
||||
if (UEnum* Enum = ByteProp->Enum)
|
||||
FProperty* Sub = StructProp->Struct->FindPropertyByName(FName(*Segments[i]));
|
||||
if (!Sub)
|
||||
{
|
||||
const int64 EnumVal = Enum->GetValueByNameString(Value);
|
||||
if (EnumVal == INDEX_NONE)
|
||||
{
|
||||
OutReason = FString::Printf(TEXT("unknown enum value '%s' for %s"), *Value, *Enum->GetName());
|
||||
return false;
|
||||
}
|
||||
ByteProp->SetPropertyValue(ValuePtr, static_cast<uint8>(EnumVal));
|
||||
return true;
|
||||
}
|
||||
ByteProp->SetPropertyValue(ValuePtr, static_cast<uint8>(FCString::Atoi(*Value)));
|
||||
return true;
|
||||
}
|
||||
// enum class reflects as FEnumProperty.
|
||||
if (FEnumProperty* EnumProp = CastField<FEnumProperty>(Prop))
|
||||
{
|
||||
UEnum* Enum = EnumProp->GetEnum();
|
||||
const int64 EnumVal = Enum ? Enum->GetValueByNameString(Value) : INDEX_NONE;
|
||||
if (EnumVal == INDEX_NONE)
|
||||
{
|
||||
OutReason = FString::Printf(TEXT("unknown enum value '%s'"), *Value);
|
||||
bOutNotFound = true; // unknown sub-field (typo) or editor-only member stripped at runtime
|
||||
return false;
|
||||
}
|
||||
EnumProp->GetUnderlyingProperty()->SetIntPropertyValue(ValuePtr, EnumVal);
|
||||
return true;
|
||||
ValuePtr = Sub->ContainerPtrToValuePtr<void>(ValuePtr);
|
||||
Prop = Sub;
|
||||
}
|
||||
|
||||
OutReason = FString::Printf(TEXT("unsupported property type '%s'"), *Prop->GetClass()->GetName());
|
||||
return false;
|
||||
OutLeaf = Prop;
|
||||
OutValuePtr = ValuePtr;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Accept only user-facing material configuration: the property must be editable in the material editor
|
||||
// (CPF_Edit) and not read-only/deprecated. This is what "all the settings a UMaterial exposes" means,
|
||||
// while filtering out transient/derived/internal members.
|
||||
bool IsAcceptableTopProperty(const FProperty* Top, FString& OutReason)
|
||||
{
|
||||
if (!Top->HasAnyPropertyFlags(CPF_Edit))
|
||||
{
|
||||
OutReason = TEXT("not an editable material property");
|
||||
return false;
|
||||
}
|
||||
if (Top->HasAnyPropertyFlags(CPF_EditConst | CPF_Deprecated))
|
||||
{
|
||||
OutReason = TEXT("read-only or deprecated property");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Coerce `Value` into the leaf property via the engine's own text importer, which handles every leaf
|
||||
// type uniformly (bool / numeric / enum-by-name / FName / FString / object reference by asset path /
|
||||
// struct literal), matching the format UE uses in .ini and copy/paste. Arrays are rejected explicitly
|
||||
// (SL_SETTINGS splits on commas, so a list value cannot be expressed).
|
||||
bool CoerceLeaf(UMaterial& Material, FProperty* Leaf, void* ValuePtr, const FString& Value, FString& OutReason)
|
||||
{
|
||||
if (CastField<FArrayProperty>(Leaf))
|
||||
{
|
||||
OutReason = TEXT("array properties are not settable via SL_SETTINGS");
|
||||
return false;
|
||||
}
|
||||
|
||||
FStringOutputDevice ImportErrors;
|
||||
const TCHAR* Consumed = Leaf->ImportText_Direct(*Value, ValuePtr, &Material, PPF_None, &ImportErrors);
|
||||
if (Consumed == nullptr)
|
||||
{
|
||||
const FString Detail = ImportErrors.TrimStartAndEnd();
|
||||
OutReason = Detail.IsEmpty()
|
||||
? FString::Printf(TEXT("cannot parse '%s' as %s"), *Value, *Leaf->GetClass()->GetName())
|
||||
: Detail;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
const TCHAR* FShaderLabSettingsApplier::GetControlledSettingReason(const FString& TopName)
|
||||
{
|
||||
// Properties ShaderLab controls itself, or that are not "material configuration" — NOT settable via
|
||||
// SL_SETTINGS. (Domain/BlendMode/TwoSided are consumed as first-class keys and never reach here.)
|
||||
// Everything else that is an editable UMaterial property is accepted by reflection, so the DSL tracks
|
||||
// the engine's material settings automatically without a hand-maintained allowlist.
|
||||
if (TopName == TEXT("MaterialDomain")) { return TEXT("use the first-class `Domain` key"); }
|
||||
if (TopName == TEXT("BlendMode")) { return TEXT("use the first-class `BlendMode` key"); }
|
||||
if (TopName == TEXT("TwoSided")) { return TEXT("use the first-class `TwoSided` key"); }
|
||||
if (TopName == TEXT("ShadingModel") ||
|
||||
TopName == TEXT("ShadingModels")) { return TEXT("the shading model is derived from the material's entry (SL_SURFACE / SL_UNLIT / SL_SLAB BSDF)"); }
|
||||
if (TopName == TEXT("bUseMaterialAttributes")) { return TEXT("ShaderLab wires individual material pins, not a MaterialAttributes struct"); }
|
||||
if (TopName == TEXT("bEnableNewHLSLGenerator") ||
|
||||
TopName == TEXT("bEnableExecWire")) { return TEXT("experimental translator toggle not supported by ShaderLab"); }
|
||||
if (TopName.StartsWith(TEXT("bUsedWith"))) { return TEXT("material usage is per-instance; set it via CheckMaterialUsage on the instance, not on the base"); }
|
||||
return nullptr; // not controlled — settable by reflection
|
||||
}
|
||||
|
||||
bool FShaderLabSettingsApplier::ApplyReflectedSettings(
|
||||
@@ -117,27 +133,61 @@ bool FShaderLabSettingsApplier::ApplyReflectedSettings(
|
||||
bool bOk = true;
|
||||
for (const TPair<FString, FString>& Pair : RawSettings)
|
||||
{
|
||||
const FName Key(*Pair.Key);
|
||||
if (!AllowedSettingNames().Contains(Key))
|
||||
const FString& Key = Pair.Key;
|
||||
const FString& Value = Pair.Value;
|
||||
|
||||
// Top-level name (before any '.') for the deny check.
|
||||
FString TopName = Key;
|
||||
int32 DotIdx = INDEX_NONE;
|
||||
if (Key.FindChar(TEXT('.'), DotIdx))
|
||||
{
|
||||
OutErrors.Add(FString::Printf(TEXT("Setting '%s' is not in the ShaderLab allowlist"), *Pair.Key));
|
||||
bOk = false;
|
||||
continue;
|
||||
}
|
||||
FProperty* Prop = UMaterial::StaticClass()->FindPropertyByName(Key);
|
||||
if (!Prop)
|
||||
{
|
||||
OutErrors.Add(FString::Printf(TEXT("UMaterial has no property '%s'"), *Pair.Key));
|
||||
TopName = Key.Left(DotIdx);
|
||||
}
|
||||
|
||||
if (const TCHAR* DenyReason = FShaderLabSettingsApplier::GetControlledSettingReason(TopName))
|
||||
{
|
||||
OutErrors.Add(FString::Printf(TEXT("Setting '%s' is controlled by ShaderLab and cannot be set here: %s"), *Key, DenyReason));
|
||||
bOk = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
FProperty* Top = nullptr;
|
||||
FProperty* Leaf = nullptr;
|
||||
void* ValuePtr = nullptr;
|
||||
bool bNotFound = false;
|
||||
FString Reason;
|
||||
if (!CoerceAndSet(Material, Prop, Pair.Value, Reason))
|
||||
if (!ResolveKeyPath(Material, Key, Top, Leaf, ValuePtr, bNotFound, Reason))
|
||||
{
|
||||
OutErrors.Add(FString::Printf(TEXT("Setting '%s': %s"), *Pair.Key, *Reason));
|
||||
if (bNotFound)
|
||||
{
|
||||
#if WITH_EDITOR
|
||||
// At cook / in the editor the full property set is present, so an unknown key is an authoring
|
||||
// error (typo, or a setting that does not exist on this engine version).
|
||||
OutErrors.Add(FString::Printf(TEXT("UMaterial has no setting '%s'"), *Key));
|
||||
bOk = false;
|
||||
#endif
|
||||
// Cooked runtime: an editor-only property is stripped from the class, so "not found" is expected —
|
||||
// its value was already baked into the instance's shader map at cook. Skip silently. (Genuine
|
||||
// typos were already rejected at cook, above.)
|
||||
continue;
|
||||
}
|
||||
OutErrors.Add(FString::Printf(TEXT("Setting '%s': %s"), *Key, *Reason));
|
||||
bOk = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!IsAcceptableTopProperty(Top, Reason))
|
||||
{
|
||||
OutErrors.Add(FString::Printf(TEXT("Setting '%s': %s"), *Key, *Reason));
|
||||
bOk = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!CoerceLeaf(Material, Leaf, ValuePtr, Value, Reason))
|
||||
{
|
||||
OutErrors.Add(FString::Printf(TEXT("Setting '%s': %s"), *Key, *Reason));
|
||||
bOk = false;
|
||||
}
|
||||
}
|
||||
return bOk;
|
||||
}
|
||||
|
||||
|
||||
@@ -361,8 +361,9 @@ struct USHADERLAB_API FShaderLabModel
|
||||
/**
|
||||
* Long-tail material settings applied via reflection onto UMaterial by name (the typed
|
||||
* Domain/BlendMode/TwoSided above stay first-class because the graph builder branches on them).
|
||||
* Stored as raw key/value strings to keep this model Core-only; the allowlist check and value
|
||||
* coercion happen in FShaderLabSettingsApplier at build/runtime, where errors are surfaced.
|
||||
* Stored as raw key/value strings to keep this model Core-only; reflection resolution (any editable
|
||||
* UMaterial property, incl. dotted `Struct.Field` keys) and value coercion happen in
|
||||
* FShaderLabSettingsApplier at build/runtime, where errors are surfaced.
|
||||
*/
|
||||
TArray<TPair<FString, FString>> RawSettings;
|
||||
|
||||
|
||||
@@ -11,16 +11,22 @@ class UMaterial;
|
||||
* builder and the cooked runtime shell builder so the same flags drive shader compilation
|
||||
* everywhere.
|
||||
*
|
||||
* Reflected settings: arbitrary `Key = Value` pairs resolved against an allowlist of UMaterial
|
||||
* properties and coerced by reflection (float/int/bool-bitfield/enum-by-name).
|
||||
* Reflected settings: arbitrary `Key = Value` pairs resolved by reflection against ANY editable
|
||||
* (CPF_Edit) UMaterial property and coerced via the engine's own text importer (FProperty::ImportText —
|
||||
* bool / numeric / enum-by-name / FName / FString / object-ref-by-asset-path / struct literal). This
|
||||
* means the DSL tracks the full set of material settings automatically, with no hand-maintained
|
||||
* allowlist. Struct settings use dotted sub-field keys, e.g. `DisplacementScaling.Magnitude = 2.0`.
|
||||
*
|
||||
* A small deny set covers properties ShaderLab controls itself (MaterialDomain — use the first-class
|
||||
* `Domain` key; ShadingModel(s) — from the entry; bUseMaterialAttributes; bUsedWith* — per-instance
|
||||
* usage) and non-config internals. Arrays are not settable (SL_SETTINGS splits on commas).
|
||||
*
|
||||
* (Material usage is intentionally NOT a ShaderLab concern: base materials are templates with no
|
||||
* usage flags. Usage is established per-instance on the UShaderLabMaterialInstanceConstant — the
|
||||
* editor auto-sets it on mesh assignment, or the author ticks it in the instance's Usage Flag
|
||||
* Overrides — so only the vertex-factory permutations actually used get compiled.)
|
||||
* usage flags. Usage is established per-instance on the UShaderLabMaterialInstanceConstant.)
|
||||
*
|
||||
* Contract: an unknown/disallowed key or an unresolvable value is collected into OutErrors (a hard
|
||||
* build failure / cook abort) — never silently skipped.
|
||||
* Contract: at cook / in the editor an unknown key, a denied key, or an unresolvable value is collected
|
||||
* into OutErrors (a hard build failure / cook abort). At cooked runtime a "not found" key is an
|
||||
* editor-only property already baked into the shader map at cook, so it is skipped silently.
|
||||
*/
|
||||
struct USHADERLAB_API FShaderLabSettingsApplier
|
||||
{
|
||||
@@ -29,4 +35,11 @@ struct USHADERLAB_API FShaderLabSettingsApplier
|
||||
UMaterial& Material,
|
||||
const TArray<TPair<FString, FString>>& RawSettings,
|
||||
TArray<FString>& OutErrors);
|
||||
|
||||
/**
|
||||
* If the given top-level UMaterial property name is one ShaderLab controls itself (and so cannot be set
|
||||
* via SL_SETTINGS), returns a human-readable reason; otherwise nullptr. Shared single source of truth for
|
||||
* both the apply path and IDE completion generation (so "what completes" == "what is accepted").
|
||||
*/
|
||||
static const TCHAR* GetControlledSettingReason(const FString& TopLevelName);
|
||||
};
|
||||
|
||||
@@ -5,10 +5,12 @@
|
||||
#include "Interfaces/IPluginManager.h"
|
||||
#include "MaterialShared.h"
|
||||
#include "Materials/Material.h"
|
||||
#include "Misc/CoreDelegates.h"
|
||||
#include "Misc/Paths.h"
|
||||
#include "Modules/ModuleManager.h"
|
||||
#include "ShaderCore.h"
|
||||
#include "ShaderLabGraphBuilder.h"
|
||||
#include "ShaderLabIDEPrepare.h"
|
||||
#include "ShaderLabMaterialInstanceConstant.h"
|
||||
#include "ShaderLabMaterialRegistry.h"
|
||||
#include "ShaderLabModel.h"
|
||||
@@ -148,6 +150,12 @@ public:
|
||||
// module loaded for all uncooked runs) is the fix for invisible materials under `-game`.
|
||||
BuildHandle = FShaderLabMaterialRegistry::Get().OnBuildMaterial().AddStatic(&BuildAndCompile);
|
||||
|
||||
// First-launch convenience: auto-generate the .usl IDE authoring assets if the project is missing them
|
||||
// (a fresh clone lacks .vscode — it is git-ignored). Deferred to post-engine-init so shader-source
|
||||
// mappings (added above) and UMaterial reflection are ready; the callback self-gates to an interactive
|
||||
// editor session (no cook / -game / commandlet / unattended).
|
||||
PostEngineInitHandle = FCoreDelegates::GetOnPostEngineInit().AddStatic(&ShaderLabIDE_EnsureGeneratedIfMissing);
|
||||
|
||||
UE_LOG(LogShaderLabBuilder, Log, TEXT("ShaderLabBuilder module started."));
|
||||
}
|
||||
|
||||
@@ -158,10 +166,16 @@ public:
|
||||
FShaderLabMaterialRegistry::Get().OnBuildMaterial().Remove(BuildHandle);
|
||||
BuildHandle.Reset();
|
||||
}
|
||||
if (PostEngineInitHandle.IsValid())
|
||||
{
|
||||
FCoreDelegates::GetOnPostEngineInit().Remove(PostEngineInitHandle);
|
||||
PostEngineInitHandle.Reset();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
FDelegateHandle BuildHandle;
|
||||
FDelegateHandle PostEngineInitHandle;
|
||||
};
|
||||
|
||||
IMPLEMENT_MODULE(FShaderLabBuilderModule, UShaderLabBuilder)
|
||||
|
||||
@@ -12,21 +12,33 @@
|
||||
// (*.usl/*.uslfunc/*.usf/*.ush -> hlsl) and shader-validator.pathRemapping
|
||||
// (virtual shader roots -> disk, from AllShaderSourceDirectoryMappings).
|
||||
// pathRemapping is machine-specific; the command regenerates it.
|
||||
// 4. <Project>/.vscode/shaderlab.code-snippets — completion for the whole `.usl` DSL: macro scaffolds
|
||||
// (full signature + body), specifier fills with enum value choices,
|
||||
// SL_FRONTMATERIAL topology operators, and every settable SL_SETTINGS
|
||||
// key (reflected from editable UMaterial properties minus the
|
||||
// ShaderLab-controlled set). Substrate-only constructs are omitted at
|
||||
// r.Substrate=0. Regenerated per engine version + project mode.
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
|
||||
#include "Dom/JsonObject.h"
|
||||
#include "HAL/IConsoleManager.h"
|
||||
#include "Materials/Material.h"
|
||||
#include "UObject/Class.h"
|
||||
#include "UObject/UnrealType.h"
|
||||
#include "Interfaces/IPluginManager.h"
|
||||
#include "HAL/FileManager.h"
|
||||
#include "Misc/App.h"
|
||||
#include "Misc/FileHelper.h"
|
||||
#include "Misc/Paths.h"
|
||||
#include "ShaderLabIDEPrepare.h"
|
||||
#include "Serialization/JsonReader.h"
|
||||
#include "Serialization/JsonSerializer.h"
|
||||
#include "Serialization/JsonWriter.h"
|
||||
#include "RenderUtils.h" // Substrate::IsSubstrateEnabled()
|
||||
#include "ShaderCore.h"
|
||||
#include "ShaderLabIntrinsicRegistry.h"
|
||||
#include "ShaderLabSettingsApplier.h"
|
||||
|
||||
DEFINE_LOG_CATEGORY_STATIC(LogShaderLabIDE, Log, All);
|
||||
|
||||
@@ -428,6 +440,211 @@ namespace ShaderLabIDEPrepare_Private
|
||||
WriteIfChanged(SettingsPath, SerializeObject(Settings.ToSharedRef()));
|
||||
}
|
||||
|
||||
// The VSCode snippet value placeholder (tabstop) for a leaf property: enums/bools become a choice list,
|
||||
// everything else a typed placeholder.
|
||||
static FString SnippetValueForLeaf(const FProperty* Leaf, int32 Tab)
|
||||
{
|
||||
auto EnumChoice = [Tab](const UEnum* Enum) -> FString
|
||||
{
|
||||
TArray<FString> Tokens;
|
||||
for (int32 i = 0; i < Enum->NumEnums(); ++i)
|
||||
{
|
||||
const FString T = Enum->GetNameStringByIndex(i);
|
||||
if (!T.IsEmpty() && !T.EndsWith(TEXT("_MAX"))) { Tokens.Add(T); }
|
||||
}
|
||||
return Tokens.Num() > 0
|
||||
? FString::Printf(TEXT("${%d|%s|}"), Tab, *FString::Join(Tokens, TEXT(",")))
|
||||
: FString::Printf(TEXT("${%d:}"), Tab);
|
||||
};
|
||||
|
||||
if (CastField<FBoolProperty>(Leaf)) { return FString::Printf(TEXT("${%d|true,false|}"), Tab); }
|
||||
if (const FByteProperty* B = CastField<FByteProperty>(Leaf)) { return B->Enum ? EnumChoice(B->Enum) : FString::Printf(TEXT("${%d:0}"), Tab); }
|
||||
if (const FEnumProperty* E = CastField<FEnumProperty>(Leaf)) { return E->GetEnum() ? EnumChoice(E->GetEnum()) : FString::Printf(TEXT("${%d:0}"), Tab); }
|
||||
if (CastField<FNumericProperty>(Leaf)) { return FString::Printf(TEXT("${%d:0}"), Tab); }
|
||||
if (CastField<FObjectPropertyBase>(Leaf)) { return FString::Printf(TEXT("${%d:/Game/Path/Asset.Asset}"), Tab); }
|
||||
return FString::Printf(TEXT("${%d:}"), Tab); // FName / FString / other leaf
|
||||
}
|
||||
|
||||
// Add a completion snippet for a property. Struct properties expand one level into dotted
|
||||
// `Prefix.SubField` keys (the material config structs are shallow); arrays are skipped (not settable).
|
||||
static void EmitSettingSnippets(const TSharedRef<FJsonObject>& Out, const FString& Prefix, FProperty* Prop, int32 Depth)
|
||||
{
|
||||
if (CastField<FArrayProperty>(Prop)) { return; }
|
||||
|
||||
if (const FStructProperty* StructProp = CastField<FStructProperty>(Prop))
|
||||
{
|
||||
if (Depth < 2 && StructProp->Struct)
|
||||
{
|
||||
bool bAny = false;
|
||||
for (TFieldIterator<FProperty> It(StructProp->Struct); It; ++It)
|
||||
{
|
||||
EmitSettingSnippets(Out, Prefix + TEXT(".") + It->GetName(), *It, Depth + 1);
|
||||
bAny = true;
|
||||
}
|
||||
if (bAny) { return; } // expanded into sub-fields
|
||||
}
|
||||
// no reflected fields / too deep: fall through to a single literal placeholder
|
||||
}
|
||||
|
||||
TArray<TSharedPtr<FJsonValue>> Body;
|
||||
Body.Add(MakeShared<FJsonValueString>(FString::Printf(TEXT("%s = %s"), *Prefix, *SnippetValueForLeaf(Prop, 1))));
|
||||
|
||||
const TSharedRef<FJsonObject> Entry = MakeShared<FJsonObject>();
|
||||
Entry->SetStringField(TEXT("prefix"), Prefix);
|
||||
Entry->SetArrayField(TEXT("body"), Body);
|
||||
Entry->SetStringField(TEXT("description"), FString::Printf(TEXT("ShaderLab material setting (%s)"), *Prop->GetCPPType()));
|
||||
Entry->SetStringField(TEXT("scope"), TEXT("hlsl"));
|
||||
Out->SetObjectField(FString::Printf(TEXT("SL_SETTINGS %s"), *Prefix), Entry);
|
||||
}
|
||||
|
||||
// One hand-authored DSL snippet. `Body` is '\n'-separated (each line -> a VSCode snippet body line)
|
||||
// with $0/${n:default}/${n|a,b,c|} tabstops. bSubstrateOnly entries are emitted only when the project
|
||||
// runs with r.Substrate=1 (legacy rejects those constructs at build).
|
||||
struct FDslSnippet { const TCHAR* Prefix; const TCHAR* Body; const TCHAR* Desc; bool bSubstrateOnly; };
|
||||
|
||||
static void AddSnippet(const TSharedRef<FJsonObject>& Out, const FString& Key, const FString& Prefix, const FString& Body, const FString& Desc)
|
||||
{
|
||||
TArray<FString> Lines;
|
||||
Body.ParseIntoArray(Lines, TEXT("\n"), /*CullEmpty*/ false);
|
||||
TArray<TSharedPtr<FJsonValue>> BodyArr;
|
||||
for (const FString& L : Lines) { BodyArr.Add(MakeShared<FJsonValueString>(L)); }
|
||||
|
||||
const TSharedRef<FJsonObject> Entry = MakeShared<FJsonObject>();
|
||||
Entry->SetStringField(TEXT("prefix"), Prefix);
|
||||
Entry->SetArrayField(TEXT("body"), BodyArr);
|
||||
Entry->SetStringField(TEXT("description"), Desc);
|
||||
Entry->SetStringField(TEXT("scope"), TEXT("hlsl"));
|
||||
Out->SetObjectField(Key, Entry);
|
||||
}
|
||||
|
||||
// Macro scaffolds: entry/BSDF/block macros expand the FULL declaration they annotate (function signature +
|
||||
// body braces), so a single trigger drops in a compilable construct. Value tokens mirror the parser's
|
||||
// accepted sets one-for-one (see ShaderLabParser.cpp). Struct FIELDS and HLSL types are intentionally NOT
|
||||
// snippets — those come from the HLSL language server against the generated mode-specific Surface_*.ush.
|
||||
static const FDslSnippet* MacroTemplates(int32& OutNum)
|
||||
{
|
||||
static const FDslSnippet T[] = {
|
||||
// --- both modes ---
|
||||
{ TEXT("SL_SETTINGS"), TEXT("SL_SETTINGS(Domain = ${1|Surface,PostProcess,UI,Decal,Volume,LightFunction|}, BlendMode = ${2|Opaque,Masked,Translucent,Additive,Modulate,AlphaComposite,AlphaHoldout|})"), TEXT("ShaderLab: material settings"), false },
|
||||
{ TEXT("SL_PROPERTY"), TEXT("SL_PROPERTY(Category = \"${1:Surface}\")\n${2:float3} ${3:Name} = ${4:0};"), TEXT("ShaderLab: material parameter (float->Scalar, float3->Color, float4->Vector, Texture2D->texture)"), false },
|
||||
{ TEXT("SL_SURFACE"), TEXT("SL_SURFACE()\nvoid Surface(inout FShaderLabSurface S)\n{\n\t$0\n}"), TEXT("ShaderLab: single-entry surface (DefaultLit in legacy)"), false },
|
||||
{ TEXT("SL_POSTPROCESS"), TEXT("SL_POSTPROCESS()\nvoid PostProcess(inout FShaderLabPostProcess O)\n{\n\t$0\n}"), TEXT("ShaderLab: post-process entry (Domain = PostProcess)"), false },
|
||||
{ TEXT("SL_UI"), TEXT("SL_UI()\nvoid UI(inout FShaderLabUI O)\n{\n\t$0\n}"), TEXT("ShaderLab: UI entry (Domain = UI)"), false },
|
||||
{ TEXT("SL_VERTEX"), TEXT("SL_VERTEX()\nvoid Vertex(inout FShaderLabVertex V)\n{\n\t$0\n}"), TEXT("ShaderLab: vertex stage (WorldPositionOffset / CustomizedUV)"), false },
|
||||
{ TEXT("SL_UNLIT"), TEXT("SL_UNLIT()\nvoid Unlit(inout FShaderLabUnlit U)\n{\n\t$0\n}"), TEXT("ShaderLab: unlit BSDF (emissive/transmittance only)"), false },
|
||||
{ TEXT("SL_VALUE"), TEXT("SL_VALUE()\nfloat ${1:Name}()\n{\n\treturn ${2:0};\n}"), TEXT("ShaderLab: named float/float2 value block (mix factor / UV)"), false },
|
||||
{ TEXT("SL_INTERPOLATOR"), TEXT("SL_INTERPOLATOR()\nfloat3 ${1:Name}()\n{\n\treturn ${2:0};\n}"), TEXT("ShaderLab: per-vertex interpolator (read with UE_Interpolator)"), false },
|
||||
{ TEXT("SL_COLLECTION"), TEXT("SL_COLLECTION(Path = \"${1:/Game/MPC/MPC_Name}\")\n${2:float3} ${3:Name};"), TEXT("ShaderLab: Material Parameter Collection read"), false },
|
||||
{ TEXT("SL_VTSAMPLE"), TEXT("SL_VTSAMPLE(DefaultTexture = \"${1:/Game/VT/T_Name}\", SamplerType = ${2|VirtualColor,VirtualNormal,VirtualGrayscale,VirtualAlpha,VirtualMasks,VirtualLinearColor,VirtualLinearGrayscale|}, UV = ${3:TexCoord0})\nfloat4 ${4:Name};"), TEXT("ShaderLab: streaming Virtual Texture read"), false },
|
||||
{ TEXT("SL_RVTSAMPLE"), TEXT("SL_RVTSAMPLE(VirtualTexture = \"${1:/Game/RVT/RVT_Name}\", MaterialType = ${2|BaseColor_Normal_Roughness,BaseColor_Normal_Specular,BaseColor_Normal_Specular_YCoCg,BaseColor_Normal_Specular_Mask_YCoCg,BaseColor,Mask4,WorldHeight,Displacement|}, UV = ${3|World,TexCoord0|})\nFShaderLabRVT ${4:Terrain};"), TEXT("ShaderLab: Runtime Virtual Texture read"), false },
|
||||
{ TEXT("SL_RVTOUTPUT"), TEXT("SL_RVTOUTPUT()\nvoid RVTOutput(inout FShaderLabRVTOutput O)\n{\n\t$0\n}"), TEXT("ShaderLab: Runtime Virtual Texture write block"), false },
|
||||
{ TEXT("SL_IMPORT"), TEXT("SL_IMPORT(Namespace = \"${1:Detail}\")\n#include \"${2:/Project/Lib/Lib.uslfunc}\""), TEXT("ShaderLab: function-library import with namespace"), false },
|
||||
{ TEXT("SL_FUNCTION"), TEXT("SL_FUNCTION()\n${1:float3} ${2:Name}(${3:float2 uv})\n{\n\treturn ${4:0};\n}"), TEXT("ShaderLab: library function (.uslfunc files only)"), false },
|
||||
// --- Substrate only ---
|
||||
{ TEXT("SL_SLAB"), TEXT("SL_SLAB()\nvoid ${1:Name}(inout FShaderLabSlab S)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate slab BSDF block"), true },
|
||||
{ TEXT("SL_MATERIAL"), TEXT("SL_MATERIAL()\nvoid Material(inout FShaderLabMaterialOutput O)\n{\n\t$0\n}"), TEXT("ShaderLab: whole-material outputs for multi-slab (Substrate)"), true },
|
||||
{ TEXT("SL_HAIR"), TEXT("SL_HAIR()\nvoid ${1:Name}(inout FShaderLabHair H)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate hair BSDF"), true },
|
||||
{ TEXT("SL_EYE"), TEXT("SL_EYE()\nvoid ${1:Name}(inout FShaderLabEye E)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate eye BSDF"), true },
|
||||
{ TEXT("SL_WATER"), TEXT("SL_WATER()\nvoid ${1:Name}(inout FShaderLabWater W)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate water BSDF"), true },
|
||||
{ TEXT("SL_CLEARCOAT"), TEXT("SL_CLEARCOAT()\nvoid ${1:Name}(inout FShaderLabClearCoat C)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate clear-coat BSDF"), true },
|
||||
{ TEXT("SL_TOON"), TEXT("SL_TOON()\nvoid ${1:Name}(inout FShaderLabToon T)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate toon BSDF"), true },
|
||||
{ TEXT("SL_VOLUME"), TEXT("SL_VOLUME()\nvoid ${1:Name}(inout FShaderLabVolume V)\n{\n\t$0\n}"), TEXT("ShaderLab: Substrate volume BSDF (Domain = Volume)"), true },
|
||||
{ TEXT("SL_LIGHTFUNCTION"), TEXT("SL_LIGHTFUNCTION()\nvoid ${1:Name}(inout FShaderLabLightFunction L)\n{\n\t$0\n}"), TEXT("ShaderLab: light-function BSDF (Domain = LightFunction)"), true },
|
||||
{ TEXT("SL_FRONTMATERIAL"), TEXT("SL_FRONTMATERIAL(${1:VerticalLayer(Top, Base, 0.5)})"), TEXT("ShaderLab: compose slabs into the front material (Substrate)"), true },
|
||||
};
|
||||
OutNum = UE_ARRAY_COUNT(T);
|
||||
return T;
|
||||
}
|
||||
|
||||
// Standalone specifier fills (Key = value), with enum value choices where the parser enumerates them.
|
||||
static const FDslSnippet* SpecifierSnippets(int32& OutNum)
|
||||
{
|
||||
static const FDslSnippet S[] = {
|
||||
// SL_SETTINGS first-class
|
||||
{ TEXT("Domain"), TEXT("Domain = ${1|Surface,PostProcess,UI,Decal,Volume,LightFunction|}"), TEXT("SL_SETTINGS: material domain"), false },
|
||||
{ TEXT("BlendMode"), TEXT("BlendMode = ${1|Opaque,Masked,Translucent,Additive,Modulate,AlphaComposite,AlphaHoldout|}"), TEXT("SL_SETTINGS: blend mode"), false },
|
||||
{ TEXT("TwoSided"), TEXT("TwoSided = ${1|true,false|}"), TEXT("SL_SETTINGS: two-sided"), false },
|
||||
// SL_PROPERTY
|
||||
{ TEXT("Category"), TEXT("Category = \"${1:Surface}\""), TEXT("SL_PROPERTY: editor group"), false },
|
||||
{ TEXT("SortPriority"), TEXT("SortPriority = ${1:0}"), TEXT("SL_PROPERTY: sort order in group"), false },
|
||||
{ TEXT("DefaultTexture"), TEXT("DefaultTexture = \"${1:white}\""), TEXT("SL_PROPERTY/SL_VTSAMPLE: default texture (white/black/grey/normal token or asset path)"), false },
|
||||
{ TEXT("ClampMin"), TEXT("ClampMin = ${1:0}"), TEXT("SL_PROPERTY: scalar slider min"), false },
|
||||
{ TEXT("ClampMax"), TEXT("ClampMax = ${1:1}"), TEXT("SL_PROPERTY: scalar slider max"), false },
|
||||
{ TEXT("CustomPrimitiveData"), TEXT("CustomPrimitiveData = ${1:0}"), TEXT("SL_PROPERTY: per-instance Custom Primitive Data index (Scalar/Vector)"), false },
|
||||
{ TEXT("SamplerType"), TEXT("SamplerType = ${1|Color,LinearColor,Grayscale,LinearGrayscale,Alpha,Normal,Masks,DistanceFieldFont,Data|}"), TEXT("SL_PROPERTY: texture sampler type"), false },
|
||||
// SL_COLLECTION / SL_IMPORT / SL_RVTSAMPLE
|
||||
{ TEXT("Path"), TEXT("Path = \"${1:/Game/MPC/MPC_Name}\""), TEXT("SL_COLLECTION: parameter collection asset"), false },
|
||||
{ TEXT("Parameter"), TEXT("Parameter = \"${1:ParamName}\""), TEXT("SL_COLLECTION: in-collection parameter name"), false },
|
||||
{ TEXT("Namespace"), TEXT("Namespace = \"${1:Detail}\""), TEXT("SL_IMPORT: promoted-parameter namespace prefix"), false },
|
||||
{ TEXT("VirtualTexture"), TEXT("VirtualTexture = \"${1:/Game/RVT/RVT_Name}\""), TEXT("SL_RVTSAMPLE: runtime virtual texture asset"), false },
|
||||
{ TEXT("MaterialType"), TEXT("MaterialType = ${1|BaseColor_Normal_Roughness,BaseColor_Normal_Specular,BaseColor_Normal_Specular_YCoCg,BaseColor_Normal_Specular_Mask_YCoCg,BaseColor,Mask4,WorldHeight,Displacement|}"), TEXT("SL_RVTSAMPLE: RVT layout"), false },
|
||||
{ TEXT("UV"), TEXT("UV = ${1|TexCoord0,World|}"), TEXT("SL_VTSAMPLE/SL_RVTSAMPLE: UV source (TexCoord<N> / World / SL_VALUE block name)"), false },
|
||||
// BSDF modifiers (Substrate only)
|
||||
{ TEXT("SubsurfaceProfile"), TEXT("SubsurfaceProfile = \"${1:/Game/Profiles/PP_SSS}\""), TEXT("Slab/Eye modifier (Substrate)"), true },
|
||||
{ TEXT("SpecularProfile"), TEXT("SpecularProfile = \"${1:/Game/Profiles/PP_Spec}\""), TEXT("Slab modifier (Substrate)"), true },
|
||||
{ TEXT("ToonProfile"), TEXT("ToonProfile = \"${1:/Game/Profiles/PP_Toon}\""), TEXT("Toon modifier (Substrate)"), true },
|
||||
{ TEXT("SubSurfaceType"), TEXT("SubSurfaceType = ${1:Wrap}"), TEXT("Slab modifier (Substrate)"), true },
|
||||
};
|
||||
OutNum = UE_ARRAY_COUNT(S);
|
||||
return S;
|
||||
}
|
||||
|
||||
// SL_FRONTMATERIAL topology operators (Substrate only).
|
||||
static const FDslSnippet* TopologySnippets(int32& OutNum)
|
||||
{
|
||||
static const FDslSnippet T[] = {
|
||||
{ TEXT("VerticalLayer"), TEXT("VerticalLayer(${1:Top}, ${2:Base}, ${3:0.5})"), TEXT("SL_FRONTMATERIAL: layer Top over Base by factor"), true },
|
||||
{ TEXT("HorizontalMix"), TEXT("HorizontalMix(${1:A}, ${2:B}, ${3:0.5})"), TEXT("SL_FRONTMATERIAL: blend A and B by factor"), true },
|
||||
{ TEXT("Add"), TEXT("Add(${1:A}, ${2:B})"), TEXT("SL_FRONTMATERIAL: add A and B"), true },
|
||||
{ TEXT("Weight"), TEXT("Weight(${1:A}, ${2:0.5})"), TEXT("SL_FRONTMATERIAL: scale coverage of A"), true },
|
||||
{ TEXT("Select"), TEXT("Select(${1:A}, ${2:B}, ${3:0.5})"), TEXT("SL_FRONTMATERIAL: pick A or B by threshold"), true },
|
||||
};
|
||||
OutNum = UE_ARRAY_COUNT(T);
|
||||
return T;
|
||||
}
|
||||
|
||||
// Generates <Project>/.vscode/shaderlab.code-snippets — completion for the whole `.usl` DSL:
|
||||
// * macro scaffolds (full function signature + body), specifier fills (with enum value choices), and
|
||||
// SL_FRONTMATERIAL topology operators — hand-authored, mirroring the parser's grammar/value tokens;
|
||||
// * every settable SL_SETTINGS key — reflected from editable UMaterial properties minus the
|
||||
// ShaderLab-controlled set (FShaderLabSettingsApplier::GetControlledSettingReason), enums/bools as
|
||||
// value choices, struct settings as dotted `Struct.Field` keys.
|
||||
// Substrate-only constructs are omitted when the project runs with r.Substrate=0. Struct fields, HLSL
|
||||
// types and variables are deliberately left to the HLSL language server (generated Surface_*.ush switched
|
||||
// by the SHADERLAB_SUBSTRATE define). Regenerated per engine version + project mode.
|
||||
static void GenerateSnippets(const FString& ProjectDir)
|
||||
{
|
||||
const bool bSubstrate = Substrate::IsSubstrateEnabled();
|
||||
const TSharedRef<FJsonObject> Root = MakeShared<FJsonObject>();
|
||||
|
||||
int32 Num = 0;
|
||||
const FDslSnippet* Macros = MacroTemplates(Num);
|
||||
for (int32 i = 0; i < Num; ++i) { if (!Macros[i].bSubstrateOnly || bSubstrate) { AddSnippet(Root, FString::Printf(TEXT("SL macro %s"), Macros[i].Prefix), Macros[i].Prefix, Macros[i].Body, Macros[i].Desc); } }
|
||||
|
||||
const FDslSnippet* Specs = SpecifierSnippets(Num);
|
||||
for (int32 i = 0; i < Num; ++i) { if (!Specs[i].bSubstrateOnly || bSubstrate) { AddSnippet(Root, FString::Printf(TEXT("SL spec %s"), Specs[i].Prefix), Specs[i].Prefix, Specs[i].Body, Specs[i].Desc); } }
|
||||
|
||||
if (bSubstrate)
|
||||
{
|
||||
const FDslSnippet* Topo = TopologySnippets(Num);
|
||||
for (int32 i = 0; i < Num; ++i) { AddSnippet(Root, FString::Printf(TEXT("SL topo %s"), Topo[i].Prefix), Topo[i].Prefix, Topo[i].Body, Topo[i].Desc); }
|
||||
}
|
||||
|
||||
// Reflected SL_SETTINGS material keys (every editable, non-controlled UMaterial property).
|
||||
for (TFieldIterator<FProperty> It(UMaterial::StaticClass()); It; ++It)
|
||||
{
|
||||
FProperty* Prop = *It;
|
||||
if (!Prop->HasAnyPropertyFlags(CPF_Edit) || Prop->HasAnyPropertyFlags(CPF_EditConst | CPF_Deprecated)) { continue; }
|
||||
if (CastField<FArrayProperty>(Prop)) { continue; }
|
||||
if (FShaderLabSettingsApplier::GetControlledSettingReason(Prop->GetName()) != nullptr) { continue; }
|
||||
EmitSettingSnippets(Root, Prop->GetName(), Prop, 0);
|
||||
}
|
||||
|
||||
// Retire the earlier settings-only file (superseded by the combined DSL snippet file).
|
||||
IFileManager::Get().Delete(*FPaths::Combine(ProjectDir, TEXT(".vscode"), TEXT("shaderlab-settings.code-snippets")), /*RequireExists*/ false, /*EvenReadOnly*/ false, /*Quiet*/ true);
|
||||
WriteIfChanged(FPaths::Combine(ProjectDir, TEXT(".vscode"), TEXT("shaderlab.code-snippets")), SerializeObject(Root));
|
||||
}
|
||||
|
||||
static void Run(const TArray<FString>& /*Args*/)
|
||||
{
|
||||
const TSharedPtr<IPlugin> Plugin = IPluginManager::Get().FindPlugin(TEXT("UShaderLab"));
|
||||
@@ -441,11 +658,39 @@ namespace ShaderLabIDEPrepare_Private
|
||||
GenerateVectorTransforms(PluginShaderDir);
|
||||
GeneratePositionTransforms(PluginShaderDir);
|
||||
MergeVSCodeSettings(ProjectDir);
|
||||
GenerateSnippets(ProjectDir);
|
||||
UE_LOG(LogShaderLabIDE, Log, TEXT("ShaderLab.IDE.Prepare: done."));
|
||||
}
|
||||
|
||||
static TAutoConsoleVariable<bool> CVarAutoPrepare(
|
||||
TEXT("ShaderLab.IDE.AutoPrepare"), true,
|
||||
TEXT("On editor startup, auto-generate the .usl IDE assets (.vscode snippets/settings + stubs) if the ")
|
||||
TEXT("project's .vscode/shaderlab.code-snippets is missing. Set 0 to disable."),
|
||||
ECVF_Default);
|
||||
|
||||
static void EnsureGeneratedIfMissing()
|
||||
{
|
||||
// Interactive editor only — never during cook / -game (GIsEditor false) / commandlet / headless
|
||||
// automation. Generating VSCode authoring assets makes no sense in those, and they must not write files.
|
||||
if (!GIsEditor || IsRunningCommandlet() || FApp::IsUnattended()) { return; }
|
||||
if (!CVarAutoPrepare.GetValueOnGameThread()) { return; }
|
||||
|
||||
// Our exclusive marker file. .vscode is git-ignored, so a fresh clone lacks it -> first-launch setup.
|
||||
const FString ProjectDir = FPaths::ConvertRelativePathToFull(FPaths::ProjectDir());
|
||||
const FString Marker = FPaths::Combine(ProjectDir, TEXT(".vscode"), TEXT("shaderlab.code-snippets"));
|
||||
if (FPaths::FileExists(Marker)) { return; } // already set up — don't churn on every launch
|
||||
|
||||
UE_LOG(LogShaderLabIDE, Display,
|
||||
TEXT("ShaderLab: IDE assets missing (%s) — auto-generating .vscode + stubs. Re-run `ShaderLab.IDE.Prepare` to refresh after an engine upgrade."),
|
||||
*Marker);
|
||||
Run(TArray<FString>());
|
||||
}
|
||||
}
|
||||
|
||||
void ShaderLabIDE_RunPrepare() { ShaderLabIDEPrepare_Private::Run(TArray<FString>()); }
|
||||
void ShaderLabIDE_EnsureGeneratedIfMissing() { ShaderLabIDEPrepare_Private::EnsureGeneratedIfMissing(); }
|
||||
|
||||
static FAutoConsoleCommand GShaderLabIDEPrepareCommand(
|
||||
TEXT("ShaderLab.IDE.Prepare"),
|
||||
TEXT("Generate IDE completion assets for .usl: Private/ShaderLabUENode.ush, Private/UEFunctions/Transform.ush + TransformPosition.ush, and .vscode/settings.json."),
|
||||
TEXT("Generate IDE completion assets for .usl: Private/ShaderLabUENode.ush, Private/UEFunctions/Transform.ush + TransformPosition.ush, .vscode/settings.json, and .vscode/shaderlab.code-snippets (full DSL)."),
|
||||
FConsoleCommandWithArgsDelegate::CreateStatic(&ShaderLabIDEPrepare_Private::Run));
|
||||
|
||||
14
Source/UShaderLabBuilder/Private/ShaderLabIDEPrepare.h
Normal file
14
Source/UShaderLabBuilder/Private/ShaderLabIDEPrepare.h
Normal file
@@ -0,0 +1,14 @@
|
||||
// Copyright UShaderLab. All Rights Reserved.
|
||||
|
||||
#pragma once
|
||||
|
||||
// Regenerate all `.usl` IDE authoring assets (same as the `ShaderLab.IDE.Prepare` console command): the
|
||||
// generated UE_-intrinsic / transform stubs, the merged .vscode/settings.json, and the full-DSL
|
||||
// .vscode/shaderlab.code-snippets.
|
||||
void ShaderLabIDE_RunPrepare();
|
||||
|
||||
// In an interactive editor session, generate the IDE assets if they are missing (a fresh clone lacks them
|
||||
// because .vscode is git-ignored). No-op in cook / -game / commandlet / unattended runs, when the assets
|
||||
// already exist, or when `ShaderLab.IDE.AutoPrepare 0` disables it. Registered on OnPostEngineInit by the
|
||||
// module so shader-source mappings + reflection are ready.
|
||||
void ShaderLabIDE_EnsureGeneratedIfMissing();
|
||||
Reference in New Issue
Block a user