Unity × Claude Code Advanced Workflow — Shader Generation, CI/CD & Performance Optimization

name: Unity Build & Test
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]
 
jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        unityVersion: ['2022.3.0f1', '2023.2.0f1']
        buildTarget: ['StandaloneWindows64', 'StandaloneOSX', 'Android']
 
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0
        lfs: true
 
    - name: Build Unity Project
      uses: game-ci/unity-builder@v3
      env:
        UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
      with:
        unityVersion: ${{ matrix.unityVersion }}
        targetPlatform: ${{ matrix.buildTarget }}
 
    - name: Run Tests
      uses: game-ci/unity-test-runner@v3
      with:
        unityVersion: ${{ matrix.unityVersion }}
        testMode: all
 
    - name: Performance Profile
      run: |
        python scripts/profile_build.py \
          --build-path builds/${{ matrix.buildTarget }} \
          --output-json profiling-results.json
 
    - name: Upload Artifacts
      uses: actions/upload-artifact@v3
      with:
        name: build-${{ matrix.buildTarget }}
        path: builds/${{ matrix.buildTarget }}

public static class BuildPipeline {
    public static void BuildStandalone() {
        var buildPath = "builds/StandaloneWindows64/game.exe";
        var scenes = GetScenes();
        var options = GetBuildOptions();
 
        var report = UnityEditor.BuildPipeline.BuildPlayer(
            scenes, buildPath, BuildTarget.StandaloneWindows64, options);
 
        LogBuildReport(report, buildPath);
 
        if (report.summary.result == UnityEditor.Build.Reporting.BuildResult.Succeeded) {
            RunPerformanceProfiler(buildPath);
        }
    }
 
    private static string[] GetScenes() {
        var sceneGuids = AssetDatabase.FindAssets("t:Scene", new[] { "Assets/Scenes" });
        var scenes = new System.Collections.Generic.List<string>();
 
        foreach (var guid in sceneGuids) {
            scenes.Add(AssetDatabase.GUIDToAssetPath(guid));
        }
 
        return scenes.ToArray();
    }
 
    private static BuildOptions GetBuildOptions() {
        var options = BuildOptions.None;
 
        if (System.Environment.GetEnvironmentVariable("CI") == "true") {
            options |= BuildOptions.Development;
            options |= BuildOptions.EnableCodeCoverage;
        }
 
        return options;
    }
 
    private static void LogBuildReport(UnityEditor.Build.Reporting.BuildReport report, string buildPath) {
        var summary = report.summary;
        Debug.Log($"Build: {buildPath}");
        Debug.Log($"Time: {summary.totalBuildTime.TotalSeconds:F2}s");
        Debug.Log($"Size: {summary.totalSize / (1024f * 1024f):F2} MB");
        Debug.Log($"Result: {summary.result}");
 
        ExportMetricsJson(new BuildMetrics {
            BuildTime = summary.totalBuildTime.TotalSeconds,
            OutputSize = summary.totalSize,
            Timestamp = System.DateTime.UtcNow.ToString("O"),
            Target = summary.platformGroup.ToString(),
            Result = summary.result.ToString()
        }, "build-metrics.json");
    }
 
    [System.Serializable]
    public class BuildMetrics {
        public double BuildTime;
        public long OutputSize;
        public string Timestamp;
        public string Target;
        public string Result;
    }
}

public class PerformanceProfiler : MonoBehaviour {
    [SerializeField] private int _frameSamples = 300;
    [SerializeField] private string _outputPath = "profile-results.json";
 
    private System.Collections.Generic.List<FrameSample> _samples =
        new System.Collections.Generic.List<FrameSample>();
    private System.Diagnostics.Stopwatch _stopwatch =
        new System.Diagnostics.Stopwatch();
    private int _frameCount = 0;
 
    private void Start() {
        _stopwatch.Start();
        UnityEngine.Profiling.Profiler.logFile = "profiler-log.raw";
        UnityEngine.Profiling.Profiler.enableBinaryLog = true;
    }
 
    private void Update() {
        if (_frameCount < _frameSamples) {
            CollectFrameSample();
            _frameCount++;
        } else {
            StopProfiling();
        }
    }
 
    private void CollectFrameSample() {
        _samples.Add(new FrameSample {
            FrameIndex = Time.frameCount,
            DeltaTime = Time.deltaTime,
            FPS = 1f / Time.deltaTime,
            MemoryUsageMB = System.GC.GetTotalMemory(false) / (1024f * 1024f),
            GCAllocPerFrame = UnityEngine.Profiling.Profiler.GetTotalAllocatedMemoryLong() / (1024f * 1024f),
        });
    }
 
    private void StopProfiling() {
        _stopwatch.Stop();
        UnityEngine.Profiling.Profiler.enableBinaryLog = false;
 
        var report = new PerformanceReport {
            TotalFrames = _frameCount,
            DurationSeconds = _stopwatch.Elapsed.TotalSeconds,
            AverageFPS = CalculateAverageFPS(),
            MinFPS = GetMinFPS(),
            MaxFPS = GetMaxFPS(),
            AverageMemoryMB = CalculateAverageMemory(),
            PeakMemoryMB = GetPeakMemory(),
        };
 
        var json = JsonUtility.ToJson(report, true);
        System.IO.File.WriteAllText(_outputPath, json);
        Debug.Log($"Profile saved: {_outputPath}");
    }
 
    private float CalculateAverageFPS() {
        if (_samples.Count == 0) return 0;
        float sum = 0;
        foreach (var s in _samples) sum += s.FPS;
        return sum / _samples.Count;
    }
 
    private float GetMinFPS() {
        if (_samples.Count == 0) return 0;
        float min = float.MaxValue;
        foreach (var s in _samples) if (s.FPS < min) min = s.FPS;
        return min;
    }
 
    private float GetMaxFPS() {
        if (_samples.Count == 0) return 0;
        float max = float.MinValue;
        foreach (var s in _samples) if (s.FPS > max) max = s.FPS;
        return max;
    }
 
    [System.Serializable]
    public class FrameSample {
        public int FrameIndex;
        public float DeltaTime;
        public float FPS;
        public float MemoryUsageMB;
        public float GCAllocPerFrame;
    }
 
    [System.Serializable]
    public class PerformanceReport {
        public int TotalFrames;
        public double DurationSeconds;
        public float AverageFPS;
        public float MinFPS;
        public float MaxFPS;
        public float AverageMemoryMB;
        public float PeakMemoryMB;
    }
}

// Statically decide whether a freshly generated shader is SRP Batcher compatible.
static bool IsSrpBatcherCompatible(string shaderSource)
{
    // 1) Properties must be grouped in the UnityPerMaterial cbuffer
    if (!shaderSource.Contains("CBUFFER_START(UnityPerMaterial)"))
        return false;
 
    // 2) TEXTURE2D declarations must live OUTSIDE the cbuffer (inside = incompatible)
    int start = shaderSource.IndexOf("CBUFFER_START(UnityPerMaterial)");
    int end   = shaderSource.IndexOf("CBUFFER_END", start);
    if (start < 0 || end < 0) return false;
    string cbufferBody = shaderSource.Substring(start, end - start);
    return !cbufferBody.Contains("TEXTURE2D");
}

// If generation was truncated by the token limit, raise it and regenerate.
if (response.StopReason == "max_tokens")
{
    Debug.LogWarning("Output truncated by max_tokens. Raising the limit and regenerating.");
    request.MaxTokens = 8192; // Practical shaders usually land around 6,000-7,000 tokens
}

# Cache Unity's Library folder to reuse asset imports across runs
- name: Cache Library
  uses: actions/cache@v4
  with:
    path: Library
    key: Library-${{ runner.os }}-${{ hashFiles('Assets/**', 'Packages/**', 'ProjectSettings/**') }}
    restore-keys: |
      Library-${{ runner.os }}-