Unity × Claude Code 実践ワークフロー — シェーダー自動生成からCI/CDまで【上級編】

using UnityEditor;
using UnityEngine;
 
[CustomEditor(typeof(AdvancedGameSettings))]
public class AdvancedGameSettingsEditor : Editor
{
    private SerializedProperty[] _performanceProperties;
    private SerializedProperty[] _graphicsProperties;
    private SerializedProperty[] _networkProperties;
 
    private bool _showPerformance = true;
    private bool _showGraphics = true;
    private bool _showNetwork = true;
 
    private PerformanceAnalyzer _analyzer;
 
    private void OnEnable()
    {
        _analyzer = new PerformanceAnalyzer();
 
        _performanceProperties = new[]
        {
            serializedObject.FindProperty("targetFrameRate"),
            serializedObject.FindProperty("enableVSync"),
            serializedObject.FindProperty("maxDrawCalls"),
            serializedObject.FindProperty("enableGPUInstancing")
        };
 
        _graphicsProperties = new[]
        {
            serializedObject.FindProperty("qualityLevel"),
            serializedObject.FindProperty("shadowQuality"),
            serializedObject.FindProperty("antiAliasingMode"),
            serializedObject.FindProperty("lodBias")
        };
 
        _networkProperties = new[]
        {
            serializedObject.FindProperty("networkTickRate"),
            serializedObject.FindProperty("useCompression"),
            serializedObject.FindProperty("maxPacketSize")
        };
    }
 
    public override void OnInspectorGUI()
    {
        serializedObject.Update();
 
        DrawPerformanceSection();
        EditorGUILayout.Space();
 
        DrawGraphicsSection();
        EditorGUILayout.Space();
 
        DrawNetworkSection();
        EditorGUILayout.Space();
 
        DrawAnalysisSection();
 
        serializedObject.ApplyModifiedProperties();
    }
 
    private void DrawPerformanceSection()
    {
        _showPerformance = EditorGUILayout.Foldout(
            _showPerformance,
            "Performance Settings",
            EditorStyles.foldoutHeader
        );
 
        if (_showPerformance)
        {
            EditorGUI.indentLevel++;
 
            foreach (var prop in _performanceProperties)
            {
                EditorGUILayout.PropertyField(prop);
            }
 
            EditorGUI.indentLevel--;
        }
    }
 
    private void DrawGraphicsSection()
    {
        _showGraphics = EditorGUILayout.Foldout(
            _showGraphics,
            "Graphics Settings",
            EditorStyles.foldoutHeader
        );
 
        if (_showGraphics)
        {
            EditorGUI.indentLevel++;
 
            foreach (var prop in _graphicsProperties)
            {
                EditorGUILayout.PropertyField(prop);
            }
 
            EditorGUI.indentLevel--;
        }
    }
 
    private void DrawNetworkSection()
    {
        _showNetwork = EditorGUILayout.Foldout(
            _showNetwork,
            "Network Settings",
            EditorStyles.foldoutHeader
        );
 
        if (_showNetwork)
        {
            EditorGUI.indentLevel++;
 
            foreach (var prop in _networkProperties)
            {
                EditorGUILayout.PropertyField(prop);
            }
 
            EditorGUI.indentLevel--;
        }
    }
 
    private void DrawAnalysisSection()
    {
        EditorGUILayout.LabelField("Performance Analysis", EditorStyles.boldLabel);
 
        var target = (AdvancedGameSettings)serializedObject.targetObject;
        var analysis = _analyzer.Analyze(target);
 
        EditorGUILayout.HelpBox(
            $"Estimated FPS: {analysis.EstimatedFPS:F1}\n" +
            $"Memory Impact: {analysis.MemoryImpactMB}MB\n" +
            $"GPU Load: {analysis.GPULoad:P0}",
            MessageType.Info
        );
    }
}
 
public class PerformanceAnalyzer
{
    public PerformanceAnalysis Analyze(AdvancedGameSettings settings)
    {
        var analysis = new PerformanceAnalysis();
 
        // シンプルな推定ロジック（実装例）
        analysis.EstimatedFPS = 60 / (1 + (int)settings.qualityLevel);
        analysis.MemoryImpactMB = 50 + (int)settings.qualityLevel * 30;
        analysis.GPULoad = 0.3f + (int)settings.qualityLevel * 0.15f;
 
        return analysis;
    }
}
 
public class PerformanceAnalysis
{
    public float EstimatedFPS { get; set; }
    public int MemoryImpactMB { get; set; }
    public float GPULoad { get; set; }
}

name: Unity Build & Test Pipeline
 
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@v3
      with:
        fetch-depth: 0
        lfs: true
 
    - name: Activate Unity License
      uses: game-ci/unity-request-activation-file@v2
 
    - name: Build Unity Project
      uses: game-ci/unity-builder@v3
      env:
        UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
        UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
      with:
        unityVersion: ${{ matrix.unityVersion }}
        targetPlatform: ${{ matrix.buildTarget }}
        buildsPath: builds
        buildMethod: BuildPipeline.BuildStandalone
        customImage: unityci/editor:ubuntu-2022.3.0f1-windows-mono-0
 
    - name: Run Unit Tests
      uses: game-ci/unity-test-runner@v3
      with:
        unityVersion: ${{ matrix.unityVersion }}
        githubToken: ${{ secrets.GITHUB_TOKEN }}
        testMode: all
 
    - name: Performance Profiling
      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 }}-${{ matrix.unityVersion }}
        path: builds/${{ matrix.buildTarget }}
 
    - name: Report Results to Dashboard
      if: always()
      run: |
        python scripts/report_metrics.py \
          --build-id ${{ github.run_id }} \
          --commit-hash ${{ github.sha }} \
          --results-file profiling-results.json

using UnityEngine;
using UnityEditor;
using UnityEditor.SceneManagement;
using System.Collections.Generic;
using System.IO;
using System;
 
public static class BuildPipeline
{
    public static void BuildStandalone()
    {
        var buildPath = "builds/StandaloneWindows64/game.exe";
        var scenes = GetScenes();
        var options = GetBuildOptions();
 
        var report = EditorBuildSettings.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 List<string>();
 
        foreach (var guid in sceneGuids)
        {
            scenes.Add(AssetDatabase.GUIDToAssetPath(guid));
        }
 
        return scenes.ToArray();
    }
 
    private static BuildOptions GetBuildOptions()
    {
        var options = BuildOptions.None;
 
        // CI 環境での設定
        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 Complete: {buildPath}");
        Debug.Log($"Build Time: {summary.totalBuildTime.TotalSeconds:F2}s");
        Debug.Log($"Output Size: {summary.totalSize / (1024.0f * 1024.0f):F2} MB");
        Debug.Log($"Result: {summary.result}");
 
        // JSON にエクスポート
        var metrics = new BuildMetrics
        {
            BuildTime = summary.totalBuildTime.TotalSeconds,
            OutputSize = summary.totalSize,
            Timestamp = System.DateTime.UtcNow.ToString("O"),
            Target = summary.platformGroup.ToString(),
            Result = summary.result.ToString()
        };
 
        ExportMetricsJson(metrics, "build-metrics.json");
    }
 
    private static void RunPerformanceProfiler(string buildPath)
    {
        // ビルド後のパフォーマンスプロファイリング
        Debug.Log($"Running performance profiler on: {buildPath}");
 
        // スタンドアロン実行ファイルを起動してプロファイリング
        var processInfo = new System.Diagnostics.ProcessStartInfo
        {
            FileName = buildPath,
            Arguments = "-logFile - -nographics",
            UseShellExecute = false,
            RedirectStandardOutput = true,
            CreateNoWindow = true
        };
 
        var process = System.Diagnostics.Process.Start(processInfo);
        if (process != null)
        {
            process.WaitForExit(30000); // 30 秒でタイムアウト
        }
    }
 
    private static void ExportMetricsJson(BuildMetrics metrics, string path)
    {
        var json = JsonUtility.ToJson(metrics, true);
        File.WriteAllText(path, json);
        Debug.Log($"Metrics exported to: {path}");
    }
 
    [System.Serializable]
    public class BuildMetrics
    {
        public double BuildTime;
        public long OutputSize;
        public string Timestamp;
        public string Target;
        public string Result;
    }
}

using UnityEngine;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System;
 
public class PerformanceProfiler : MonoBehaviour
{
    [SerializeField] private int _frameSamplesToCollect = 300;
    [SerializeField] private string _outputPath = "profile-results.json";
 
    private List<FrameSample> _frameSamples = new List<FrameSample>();
    private Stopwatch _stopwatch = new Stopwatch();
    private int _frameCount = 0;
    private bool _isProfileing = false;
 
    private void Start()
    {
        StartProfiling();
    }
 
    private void Update()
    {
        if (_isProfileing && _frameCount < _frameSamplesToCollect)
        {
            CollectFrameSample();
            _frameCount++;
        }
        else if (_frameCount >= _frameSamplesToCollect)
        {
            StopProfiling();
        }
    }
 
    private void StartProfiling()
    {
        _stopwatch.Start();
        _isProfileing = true;
        UnityEngine.Profiling.Profiler.logFile = "profiler-log.raw";
        UnityEngine.Profiling.Profiler.enableBinaryLog = true;
    }
 
    private void CollectFrameSample()
    {
        var sample = new FrameSample
        {
            FrameIndex = Time.frameCount,
            DeltaTime = Time.deltaTime,
            FPS = 1f / Time.deltaTime,
            MemoryUsageMB = System.GC.GetTotalMemory(false) / (1024f * 1024f),
            TotalMemoryMB = SystemInfo.systemMemorySize,
            GCAllocPerFrame = UnityEngine.Profiling.Profiler.GetTotalAllocatedMemoryLong() / (1024f * 1024f),
            RenderingThreadTime = GetRenderingThreadTime()
        };
 
        _frameSamples.Add(sample);
    }
 
    private void StopProfiling()
    {
        _stopwatch.Stop();
        _isProfileing = false;
        UnityEngine.Profiling.Profiler.enableBinaryLog = false;
 
        ExportResults();
    }
 
    private void ExportResults()
    {
        var report = GenerateReport();
        var json = JsonUtility.ToJson(report, true);
        File.WriteAllText(_outputPath, json);
 
        UnityEngine.Debug.Log($"Profiling results saved to: {_outputPath}");
    }
 
    private PerformanceReport GenerateReport()
    {
        var avgFps = CalculateAverageFPS();
        var minFps = GetMinFPS();
        var maxFps = GetMaxFPS();
        var avgMemory = CalculateAverageMemory();
        var peakMemory = GetPeakMemory();
 
        return new PerformanceReport
        {
            TotalFrames = _frameCount,
            DurationSeconds = _stopwatch.Elapsed.TotalSeconds,
            AverageFPS = avgFps,
            MinFPS = minFps,
            MaxFPS = maxFps,
            AverageMemoryMB = avgMemory,
            PeakMemoryMB = peakMemory,
            FrameTimeMs = _stopwatch.Elapsed.TotalMilliseconds / _frameCount,
            GCAllocations = _frameSamples.Count
        };
    }
 
    private float CalculateAverageFPS()
    {
        if (_frameSamples.Count == 0) return 0;
        float sum = 0;
        foreach (var sample in _frameSamples)
        {
            sum += sample.FPS;
        }
        return sum / _frameSamples.Count;
    }
 
    private float GetMinFPS()
    {
        if (_frameSamples.Count == 0) return 0;
        float min = float.MaxValue;
        foreach (var sample in _frameSamples)
        {
            if (sample.FPS < min) min = sample.FPS;
        }
        return min;
    }
 
    private float GetMaxFPS()
    {
        if (_frameSamples.Count == 0) return 0;
        float max = float.MinValue;
        foreach (var sample in _frameSamples)
        {
            if (sample.FPS > max) max = sample.FPS;
        }
        return max;
    }
 
    private float CalculateAverageMemory()
    {
        if (_frameSamples.Count == 0) return 0;
        float sum = 0;
        foreach (var sample in _frameSamples)
        {
            sum += sample.MemoryUsageMB;
        }
        return sum / _frameSamples.Count;
    }
 
    private float GetPeakMemory()
    {
        if (_frameSamples.Count == 0) return 0;
        float max = 0;
        foreach (var sample in _frameSamples)
        {
            if (sample.MemoryUsageMB > max) max = sample.MemoryUsageMB;
        }
        return max;
    }
 
    private float GetRenderingThreadTime()
    {
        // Note: 実装は Unity のバージョンや環境による
        return Time.deltaTime * 1000f;
    }
 
    [System.Serializable]
    public class FrameSample
    {
        public int FrameIndex;
        public float DeltaTime;
        public float FPS;
        public float MemoryUsageMB;
        public int TotalMemoryMB;
        public float GCAllocPerFrame;
        public float RenderingThreadTime;
    }
 
    [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;
        public double FrameTimeMs;
        public int GCAllocations;
    }
}

// 新機能開発から本番デプロイまでの自動化フロー
 
[MenuItem("Tools/Full Pipeline/Build and Deploy")]
public static void FullBuildAndDeployPipeline()
{
    // 1. ディープコード解析
    AnalyzeCodeQuality();
 
    // 2. シェーダー自動生成（必要な場合）
    if (NeedsShaderGeneration())
    {
        GenerateRequiredShaders();
    }
 
    // 3. エディタツール更新
    RefreshEditorTools();
 
    // 4. ビルド実行
    var buildReport = PerformBuild();
 
    // 5. パフォーマンス測定
    if (buildReport.IsSuccessful)
    {
        MeasurePerformance(buildReport.BuildPath);
    }
 
    // 6. デプロイ
    if (PassedAllChecks())
    {
        Deploy(buildReport.BuildPath);
    }
}
 
private static void AnalyzeCodeQuality()
{
    Debug.Log("Analyzing code quality with Claude Code...");
    // Claude API 呼び出しでコード解析
}
 
private static bool NeedsShaderGeneration()
{
    // マテリアル設定から自動判定
    return false; // 実装例
}
 
private static void GenerateRequiredShaders()
{
    Debug.Log("Generating shaders automatically...");
}
 
private static void RefreshEditorTools()
{
    AssetDatabase.Refresh();
    EditorBuildSettings.scenes = GetValidScenes();
}
 
private static BuildReport PerformBuild()
{
    return new BuildReport
    {
        IsSuccessful = true,
        BuildPath = "builds/game.exe"
    };
}
 
private static void MeasurePerformance(string buildPath)
{
    var profiler = new GameObject("Profiler").AddComponent<PerformanceProfiler>();
    profiler._outputPath = "performance-results.json";
}
 
private static bool PassedAllChecks()
{
    return true; // チェックロジック
}
 
private static void Deploy(string buildPath)
{
    Debug.Log($"Deploying build from: {buildPath}");
}
 
private static SceneHierarchyHooks.SceneHierarchy[] GetValidScenes()
{
    return EditorBuildSettings.scenes;
}
 
public class BuildReport
{
    public bool IsSuccessful { get; set; }
    public string BuildPath { get; set; }
}

// 生成直後のシェーダーが SRP Batcher 互換かを静的に判定する
static bool IsSrpBatcherCompatible(string shaderSource)
{
    // 1) UnityPerMaterial cbuffer にプロパティが集約されているか
    if (!shaderSource.Contains("CBUFFER_START(UnityPerMaterial)"))
        return false;
 
    // 2) TEXTURE2D 宣言が cbuffer の「外」にあるか（中にあると非互換）
    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");
}

// レスポンスの stop_reason を見て、打ち切られていたら続きを要求する
if (response.StopReason == "max_tokens")
{
    Debug.LogWarning("出力が max_tokens で打ち切られました。max_tokens を引き上げて再生成します。");
    request.MaxTokens = 8192; // 実用シェーダーは 6,000〜7,000 トークン前後に収まることが多い
    // messages に「続きを出力してください」を足して継続生成する手もあります
}

# Unity の Library フォルダをキャッシュしてインポートを再利用する
- name: Cache Library
  uses: actions/cache@v4
  with:
    path: Library
    key: Library-${{ runner.os }}-${{ hashFiles('Assets/**', 'Packages/**', 'ProjectSettings/**') }}
    restore-keys: |
      Library-${{ runner.os }}-