public GUIAction(GUIActionKind kind, ShaderBuildReport report, ShaderBuildReport reportReference, string assetGUID)
     : this(kind)
 {
     this.report          = report;
     this.reportReference = reportReference;
     this.assetGUID       = assetGUID;
 }
        static void SetAsReference(BuildTarget buildTarget, string assetGUID, ShaderBuildReport report)
        {
            var metadatas = ShaderAnalysisUtils.LoadAssetMetadatasFor(buildTarget, referenceFolder);

            metadatas.SetReport(assetGUID, report);
            ShaderAnalysisUtils.SaveAssetMetadata(metadatas, referenceFolder);
        }
 public GUIAction(GUIActionKind kind)
 {
     this.kind       = kind;
     jobBuilder      = null;
     asset           = null;
     report          = null;
     reportReference = null;
     assetGUID       = null;
 }
 static void DefaultOnGUI_UnitToolbar(
     Object asset,
     ShaderBuildReport r,
     ShaderBuildReport.GPUProgram po,
     ShaderBuildReport.CompileUnit cu,
     ShaderBuildReport.PerformanceUnit pu,
     ShaderBuildReport.ProgramPerformanceMetrics p,
     ShaderBuildReport reference,
     string assetGUID)
 {
 }
Example #5
0
 public void SetReport(string guid, ShaderBuildReport report)
 {
     int index;
     if (m_GUIDIndex.TryGetValue(guid, out index))
         m_Entries[index].report = report;
     else
     {
         m_Entries.Add(new ReportEntry { report = report, guid = guid });
         m_GUIDIndex[guid] = m_Entries.Count - 1;
     }
 }
 static void DefaultOnGUI_ProgramToolbar(
     Object asset,
     ShaderBuildReport report,
     ShaderBuildReport.GPUProgram program,
     ShaderBuildReport reference,
     string assetGUID)
 {
     if (!string.IsNullOrEmpty(program.sourceCode) && GUILayout.Button("Open", EditorStyles.toolbarButton))
     {
         program.OpenSourceCode();
     }
 }
Example #7
0
        public static ShaderBuildReportDiff DiffReports(ShaderBuildReport source, ShaderBuildReport reference)
        {
            var diff = new ShaderBuildReportDiff
            {
                source    = source,
                reference = reference
            };

            var spos = source.programs;

            for (var i = 0; i < spos.Count; i++)
            {
                var spo = spos[i];
                var rpo = reference.GetProgramByName(spo.name);

                if (rpo == null)
                {
                    continue;
                }

                foreach (var scu in spo.compileUnits)
                {
                    var rcu = rpo.GetCompileUnitByDefines(scu.defines);
                    if (rcu == null)
                    {
                        continue;
                    }

                    var spu = scu.performanceUnit;
                    var rpu = rcu.performanceUnit;

                    if (spu == null || rpu == null)
                    {
                        continue;
                    }

                    var perfdiff = new ShaderBuildReportDiff.PerfDiff
                    {
                        programName             = spo.name,
                        defines                 = scu.defines,
                        multicompiles           = scu.multicompileDefines,
                        metrics                 = ShaderBuildReport.ProgramPerformanceMetrics.Diff(spu.parsedReport, rpu.parsedReport),
                        sourceMultiCompileIndex = scu.multicompileIndex,
                        sourceProgramIndex      = scu.programIndex,
                        refMultiCompileIndex    = rcu.multicompileIndex,
                        refProgramIndex         = rcu.programIndex
                    };
                    diff.perfDiffs.Add(perfdiff);
                }
            }

            return(diff);
        }
        void OnBuildReportJobComplete(IAsyncJob obj)
        {
            var asset = m_JobAssets[obj];

            m_JobAssets.Remove(obj);

            var job = obj as AsyncBuildReportJob;

            Assert.IsNotNull(job);

            ShaderBuildReport report = null;

            if (job.IsComplete() &&
                job.hasReport &&
                (report = job.builtReport) != null)
            {
                var metadata  = ShaderAnalysisUtils.LoadAssetMetadatasFor(job.target);
                var assetGUID = ShaderAnalysisUtils.CalculateGUIDFor(asset);
                metadata.SetReport(assetGUID, report);
                ShaderAnalysisUtils.SaveAssetMetadata(metadata);
            }
        }
Example #9
0
        public void Export(ShaderBuildReport report, string filePath)
        {
            var targetFile = new FileInfo(filePath);

            var dir = targetFile.Directory;

            if (!dir.Exists)
            {
                dir.Create();
            }

            if (targetFile.Exists)
            {
                targetFile.Delete();
            }

            using (var stream = new FileStream(targetFile.FullName, FileMode.Create, FileAccess.ReadWrite))
                using (var writer = new StreamWriter(stream))
                {
                    // Write header

                    for (var i = 0; i < ExportFormat.Columns.Length; ++i)
                    {
                        writer.Write('"');
                        writer.Write(ExportFormat.Columns[i].name);
                        writer.Write('"');
                        writer.Write(';');
                    }
                    writer.WriteLine();

                    for (var i = 0; i < report.programs.Count; i++)
                    {
                        var po = report.programs[i];
                        foreach (var cu in po.compileUnits)
                        {
                            var pu = cu.performanceUnit;
                            if (pu == null)
                            {
                                continue;
                            }

                            var p = pu.parsedReport;

                            for (var k = 0; k < ExportFormat.Columns.Length; k++)
                            {
                                var escape = ExportFormat.Columns[k].type == typeof(string);

                                if (escape)
                                {
                                    writer.Write('"');
                                }
                                writer.Write(ExportFormat.Columns[k].getter(report, po, cu, pu, p));
                                if (escape)
                                {
                                    writer.Write('"');
                                }
                                writer.Write(';');
                            }
                            writer.WriteLine();
                        }
                    }
                }
        }
 public GUIAction(GUIActionKind kind, string assetGUID, ShaderBuildReport report)
     : this(kind)
 {
     this.report    = report;
     this.assetGUID = assetGUID;
 }