Summary

Two small fixes to the shader build path, both surfaced while integrating ShaderLab into the editor on dev/2.0:

1. shader-compiler: route SemanticAnalyzer.reportWarning through Logger.warn so verbose-mode warnings stay disabled by default. Embedders that include the verbose bundle (e.g. the editor's viewport) now control whether to see warnings via Logger.enable() / disable().

2. loader: drop the @builtin placeholder shader path from ShaderLoader — dead code after refactor(shader): migrate GLSL shaders to ShaderLab and clean up shader infrastructure  #2961.

Net: +2 / -13 lines, no behavior change for code that goes through Logger.enable() or that doesn't ship placeholder .shader files.

1. shader-compiler: CompilationWarning → Logger.warn

Why

SemanticAnalyzer.reportWarning wrote directly to console.warn. The verbose shader-compiler bundle is used by the editor viewport to surface diagnostics, but every PBR compile fires several warnings that are false positives in two shapes:

1. Forward references inside #define value expressions

   #define FUNCTION_DIFFUSE_IBL evaluateDiffuseIBL
   // ... later in the translation unit ...
   vec3 evaluateDiffuseIBL(...) { ... }

   Macro RHS is expanded lazily at the call site, so symbols declared later are legitimate references.

2. Runtime-injected macros — RENDERER_JOINTS_NUM, RENDERER_BLENDSHAPE_COUNT, MATERIAL_HAS_*. The engine prepends these #defines before compilation; they don't appear in the static source the compiler analyzes.

AST-only static analysis can't tell either shape apart from a real typo, and real typos get caught at codegen / GLSL-compile time. A single editing session in the editor generated hundreds of these warnings, drowning out genuine errors.

What changed

-    console.warn(new GSError(GSErrorName.CompilationWarn, ...).toString());
+    Logger.warn(new GSError(GSErrorName.CompilationWarn, ...).toString());

What didn't

• reportError keeps writing to console.error directly — errors are always-on, not gated by Logger.
• All warning emit sites are untouched; the diagnostic information is still produced, just gated.

2. loader: drop @builtin placeholder shader path from ShaderLoader

Why

ShaderLoader._getBuiltinShader parsed // @builtin <name> from a .shader file body and called Shader.find(name) instead of compiling. That indirection only mattered when the loader saw placeholder .shader files whose body was just a marker comment — a layout from the pre-ShaderLab era.

After #2961 all builtin shaders ship via _shaderMap and are resolved by Shader.find directly; no path in the engine emits a placeholder .shader for the loader to parse. Verified zero remaining callers: the only references to _builtinRegex / _getBuiltinShader were the loader's own internal use.

What changed

 class ShaderLoader extends Loader<Shader> {
-  private static _builtinRegex = /^\s*\/\/\s*@builtin\s+(\w+)/;
-
   load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<Shader> {
     ...
     return resourceManager._request<string>(url, { ...item, type: "text" }).then((code: string) => {
-      const builtinShader = this._getBuiltinShader(code);
-      if (builtinShader) {
-        return Shader.find(builtinShader);
-      }
-
       return Shader.create(code, undefined, url);
     });
   }
-
-  private _getBuiltinShader(code: string) {
-    const match = code.match(ShaderLoader._builtinRegex);
-    if (match && match[1]) return match[1];
-  }
 }

Test plan

• pnpm --filter @galacean/engine-shader-compiler build — release + verbose bundles produce.
• pnpm --filter @galacean/engine-loader exec tsc --noEmit — typecheck clean.
• In the editor (which uses @galacean/engine-shader-compiler/verbose): with default Logger state, no CompilationWarning flood; after Logger.enable(), warnings reappear.
• Existing scenes / prefabs that reference builtin shaders by builtinShaderName continue to load (path now goes through Shader.find from the resolver, not through a placeholder .shader file).

Summary by CodeRabbit

• Refactor
  • Integrated centralized logging system across shader compiler components for consistent diagnostics and error reporting.
  • Removed automatic detection of built-in shaders from source code; shaders are now always loaded directly from the provided source.