feat: resolve #include directives

Author: CodyJasonBennett

src/index.d.ts

@@ -13,7 +13,6 @@ type StringFilter<Value = string | RegExp> =
       exclude?: Value | Array<Value>
     }
 
-// TODO: How to support GLSL + WGSL compilation as an API? Filter to allow platform-specific code?
 export interface ViteSlangOptions {
   /**
    * The output {@link SlangCompileTarget} to transform Slang shaders to.

src/index.js

@@ -1,12 +1,8 @@
 import { transformWithEsbuild } from 'vite'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
 import slangModule from './slang-2025.15-wasm/slang-wasm.js'
 
-const SLANG_STAGES = {
-  vertex: 1,
-  fragment: 5,
-  compute: 6,
-}
-
 /**
  * Tests a Vite filter against a file id.
  *
@@ -30,6 +26,14 @@ function testFilter(id, filter) {
   }
 }
 
+const SLANG_STAGES = {
+  vertex: 1,
+  fragment: 5,
+  compute: 6,
+}
+
+const IMPORT_REGEX = /^\s*#include\s+"([^"]+)"/gm
+
 /** @type {Promise<import('./slang-2025.15-wasm/slang-wasm.js').MainModule> | null} */
 let slangPromise = null
 
@@ -82,9 +86,19 @@ function viteSlang(options) {
             throw new Error(`Unable to create Slang session for ${options.target} target. Please file an issue.`)
           }
 
-          // TODO: module stitching and/or non-standard preprocessor unfolding?
           /** @type {import('./slang-2025.15-wasm/slang-wasm.js').Module | null} */
-          const module = session.loadModuleFromSource(code, 'shader', id)
+          const module = session.loadModuleFromSource(
+            // Resolve #include directives
+            code.replaceAll(IMPORT_REGEX, (match, file) => {
+              try {
+                return fs.readFileSync(path.resolve(path.dirname(id), file), { encoding: 'utf8' })
+              } catch {
+                return match
+              }
+            }),
+            'shader',
+            id,
+          )
 
           // Surface compilation errors
           if (!module) {

tests/__snapshots__/index.test.ts.snap

@@ -161,23 +161,195 @@ fn fmain(@builtin(position) position_0 : vec4<f32>) -> pixelOutput_0
 }
 `;
 
+exports[`viteSlang > can resolve #include directives 1`] = `
+{
+  "code": "struct SLANG_ParameterGroup_Globals_std140_0
+{
+    @align(16) time_0 : f32,
+};
+
+@binding(0) @group(0) var<uniform> Globals_0 : SLANG_ParameterGroup_Globals_std140_0;
+struct vertexOutput_0
+{
+    @builtin(position) output_0 : vec4<f32>,
+};
+
+@vertex
+fn vmain(@builtin(vertex_index) vertexIndex_0 : u32) -> vertexOutput_0
+{
+    var _S1 : vertexOutput_0 = vertexOutput_0( vec4<f32>(vec2<f32>(f32((((vertexIndex_0 << (u32(1)))) & (u32(2)))), f32((vertexIndex_0 & (u32(2))))) * vec2<f32>(2.0f) - vec2<f32>(1.0f), 0.0f, 1.0f) );
+    return _S1;
+}
+
+struct pixelOutput_0
+{
+    @location(0) output_1 : vec4<f32>,
+};
+
+@fragment
+fn fmain(@builtin(position) position_0 : vec4<f32>) -> pixelOutput_0
+{
+    var _S2 : pixelOutput_0 = pixelOutput_0( vec4<f32>(vec3<f32>(0.80000001192092896f, 0.69999998807907104f, 1.0f) + vec3<f32>(0.30000001192092896f) * cos(normalize(position_0.xy / vec2<f32>(position_0.w)).xyx + vec3<f32>(Globals_0.time_0)), 1.0f) );
+    return _S2;
+}
+
+",
+  "reflection": {
+    "entryPoints": [
+      {
+        "name": "vmain",
+        "parameters": [
+          {
+            "name": "vertexIndex",
+            "semanticName": "SV_VERTEXID",
+            "type": {
+              "kind": "scalar",
+              "scalarType": "uint32",
+            },
+          },
+        ],
+        "result": {
+          "semanticName": "SV_POSITION",
+          "type": {
+            "elementCount": 4,
+            "elementType": {
+              "kind": "scalar",
+              "scalarType": "float32",
+            },
+            "kind": "vector",
+          },
+        },
+        "stage": "vertex",
+      },
+      {
+        "name": "fmain",
+        "parameters": [
+          {
+            "name": "position",
+            "semanticName": "SV_POSITION",
+            "type": {
+              "elementCount": 4,
+              "elementType": {
+                "kind": "scalar",
+                "scalarType": "float32",
+              },
+              "kind": "vector",
+            },
+          },
+        ],
+        "result": {
+          "binding": {
+            "index": 0,
+            "kind": "varyingOutput",
+          },
+          "semanticName": "SV_TARGET",
+          "stage": "fragment",
+          "type": {
+            "elementCount": 4,
+            "elementType": {
+              "kind": "scalar",
+              "scalarType": "float32",
+            },
+            "kind": "vector",
+          },
+        },
+        "stage": "fragment",
+      },
+    ],
+    "parameters": [
+      {
+        "binding": {
+          "index": 0,
+          "kind": "descriptorTableSlot",
+        },
+        "name": "Globals",
+        "type": {
+          "containerVarLayout": {
+            "binding": {
+              "index": 0,
+              "kind": "descriptorTableSlot",
+            },
+          },
+          "elementType": {
+            "fields": [
+              {
+                "binding": {
+                  "elementStride": 0,
+                  "kind": "uniform",
+                  "offset": 0,
+                  "size": 4,
+                },
+                "name": "time",
+                "type": {
+                  "kind": "scalar",
+                  "scalarType": "float32",
+                },
+              },
+            ],
+            "kind": "struct",
+          },
+          "elementVarLayout": {
+            "binding": {
+              "elementStride": 0,
+              "kind": "uniform",
+              "offset": 0,
+              "size": 16,
+            },
+            "type": {
+              "fields": [
+                {
+                  "binding": {
+                    "elementStride": 0,
+                    "kind": "uniform",
+                    "offset": 0,
+                    "size": 4,
+                  },
+                  "name": "time",
+                  "type": {
+                    "kind": "scalar",
+                    "scalarType": "float32",
+                  },
+                },
+              ],
+              "kind": "struct",
+            },
+          },
+          "kind": "constantBuffer",
+        },
+      },
+    ],
+  },
+}
+`;
+
 exports[`viteSlang > throws if entrypoints are not defined 1`] = `
-[Error: [31m[vite-slang] An entrypoint must be defined with a shader stage attribute! Try adding [shader("fragment")] before your entrypoint method.[39m
-file: [36mshader.slang[39m]
+"[31m[vite-slang] An entrypoint must be defined with a shader stage attribute! Try adding [shader("fragment")] before your entrypoint method.[39m
+"
 `;
 
 exports[`viteSlang > throws on shader compilation error 1`] = `
-[Error: [vite-slang] USER error: shader.slang(5): error 30015: undefined identifier 'error'.
-    error;
-    ^~~~~
+"[vite-slang] USER error: C:/Users/Cody Bennett/Documents/GitHub/vite-slang/tests/shaders/broken.slang(4): error 30015: undefined identifier 'error'.
+  error;
+  ^~~~~
+(0): error 39999: import of module 'shader' failed because of a compilation error
+(0): fatal error 39999: compilation ceased
+abort compilation: (0): fatal error 39999: compilation ceased
+
+"
+`;
+
+exports[`viteSlang > throws on unresolved #include directive 1`] = `
+"[vite-slang] USER error: C:/Users/Cody Bennett/Documents/GitHub/vite-slang/tests/shaders/include-error.slang(4): error 15300: failed to find include file 'include-2.slang'
+#include "include-2.slang"
+         ^~~~~~~~~~~~~~~~~
 (0): error 39999: import of module 'shader' failed because of a compilation error
 (0): fatal error 39999: compilation ceased
 abort compilation: (0): fatal error 39999: compilation ceased
 
-file: [36mshader.slang[39m]
+"
 `;
 
 exports[`viteSlang > throws on unsupported target 1`] = `
-[Error: [31m[vite-slang] Unsupported Slang target: unsupported.[39m
-file: [36mshader.slang[39m]
+"[31m[vite-slang] Unsupported Slang target: unsupported.[39m
+"
 `;

tests/index.test.ts

@@ -1,27 +1,13 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, assert } from 'vitest'
 import { build } from 'vite'
 import viteSlang, { ViteSlangOptions } from '../src/index.js'
 
 async function transform(
-  shader: string,
+  input: string,
   options?: ViteSlangOptions,
 ): Promise<{ code: string; reflection: SlangReflectionJSON }> {
   const compiled = await build({
-    plugins: [
-      {
-        name: 'virtual',
-        enforce: 'pre',
-        resolveId(source) {
-          if (source === 'shader.slang') return 'shader.slang'
-          return null
-        },
-        load(id) {
-          if (id === 'shader.slang') return shader
-          return null
-        },
-      },
-      viteSlang(options),
-    ],
+    plugins: [viteSlang(options)],
     logLevel: 'silent',
     build: {
       target: 'esnext',
@@ -30,10 +16,7 @@ async function transform(
       modulePreload: false,
       rollupOptions: {
         treeshake: false,
-        input: 'shader.slang',
-        output: {
-          entryFileNames: '[name].js',
-        },
+        input: new URL(input, import.meta.url).href,
       },
     },
   })
@@ -42,61 +25,44 @@ async function transform(
   return new Function(`${compiled.output[0].code}\nreturn { reflection, code };`)()
 }
 
-const triangleShader = /* slang */ `
-  cbuffer Globals: register(b0, space0) {
-    float time;
-  };
-
-  [shader("vertex")]
-  float4 vmain(uint vertexIndex: SV_VertexID): SV_Position {
-    float2 uv = float2((vertexIndex << 1) & 2, vertexIndex & 2);
-    return float4(uv * 2.0 - 1.0, 0.0, 1.0);
-  }
-
-  [shader("fragment")]
-  float4 fmain(float4 position: SV_Position): SV_Target {
-    float2 coord = position.xy / position.w;
-    float3 color = float3(0.8, 0.7, 1.0) + 0.3 * cos(normalize(coord).xyx + time);
-    return float4(color, 1.0);
+async function expectError(fn: () => Promise<any>): Promise<void> {
+  try {
+    assert(false, `Promise resolved "${await fn()}" instead of rejecting`)
+  } catch (error) {
+    expect((error as Error).message.replaceAll(/^file:.+$/gm, '')).toMatchSnapshot()
   }
-`
-
-const emptyShader = /* slang */ `
-  void main() {
-    //
-  }
-`
-
-const brokenShader = /* slang */ `
-  [shader("compute")]
-  [numthreads(1, 1, 1)]
-  void main(uint2 dispatchThreadId: SV_DispatchThreadID) {
-    error;
-  }
-`
+}
 
 describe('viteSlang', () => {
   // Ensure ambient types work correctly for IntelliSense
-  import('./stub.slang') satisfies Promise<{
+  import('./shaders/stub.slang') satisfies Promise<{
     default: string
     code: string
     reflection: SlangReflectionJSON
   }>
 
   it('can compile to WGSL by default', async () => {
-    expect(await transform(triangleShader)).toMatchSnapshot()
+    expect(await transform('./shaders/triangle.slang')).toMatchSnapshot()
+  })
+
+  it('can resolve #include directives', async () => {
+    expect(await transform('./shaders/include-0.slang')).toMatchSnapshot()
+  })
+
+  it('throws on unresolved #include directive', async () => {
+    await expectError(() => transform('./shaders/include-error.slang'))
   })
 
   it('throws on unsupported target', async () => {
     // @ts-expect-error
-    await expect(transform(triangleShader, { target: 'unsupported' })).rejects.toThrowErrorMatchingSnapshot()
+    await expectError(() => transform('./shaders/triangle.slang', { target: 'unsupported' }))
   })
 
   it('throws if entrypoints are not defined', async () => {
-    await expect(transform(emptyShader)).rejects.toThrowErrorMatchingSnapshot()
+    await expectError(() => transform('./shaders/empty.slang'))
   })
 
   it('throws on shader compilation error', async () => {
-    await expect(transform(brokenShader)).rejects.toThrowErrorMatchingSnapshot()
+    await expectError(() => transform('./shaders/broken.slang'))
   })
 })

tests/shaders/broken.slang

@@ -0,0 +1,5 @@
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void main(uint2 dispatchThreadId: SV_DispatchThreadID) {
+  error;
+}

tests/shaders/empty.slang

@@ -0,0 +1,3 @@
+void main() {
+  //
+}