// ------------------------------------------------------------------------------------
// Setting/Getting current baseline set
public void SetCurrentPlatformAPI(string platform, string api)
{
if (_altBaselineSettings == null || platform != _altBaselineSettings.Platform || api != _altBaselineSettings.API)
{
_altBaselineSettings = new AltBaselineSettings(platform, api);
if (platform != GetSystemData().Platform || api != GetSystemData().API)
{
if (_sqlMode == SQLmode.Live)
{
_sqlMode = SQLmode.Disabled;
}
else if (_sqlMode == SQLmode.Staging)
{
_sqlMode = SQLmode.DisabledStaging;
}
}
else
{
{
if (_sqlMode == SQLmode.Disabled)
{
_sqlMode = SQLmode.Live;
}
else if (_sqlMode == SQLmode.DisabledStaging)
{
_sqlMode = SQLmode.Staging;
}
}
}
BroadcastBaselineChange();
}
}
/// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/// Initial checks
/// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Query if specific baseline exists
/// </summary>
/// <returns><c>true</c>, if baseline exists, <c>false</c> if not.</returns>
/// <param name="suiteName">Suite name.</param>
/// <param name="pipeline">Pipeline.</param>
/// <param name="testType">Test type.</param>
/// <param name="sceneName">Scene name.</param>
/// <param name="testName">Test name.</param>
public bool BaselineExists(string suiteName, string pipeline, string testType, string sceneName, string testName)
{
AltBaselineSettings curBaselineData = Master.Instance.GetCurrentPlatformAPI();
//check local file for current platform/api baseline
foreach (SuiteBaselineData SBD in _suiteBaselineData)
{
if (SBD.suiteName == suiteName)
{
//Suite exists
if (SBD.platform == curBaselineData.Platform)
{
//Platform exists
if (SBD.api == curBaselineData.API)
{
//API matches
if (SBD.pipeline == pipeline)
{
//pipeline exists
foreach (SuiteData SD in SBD._suiteData)
{
if (SD.testType == testType && SD.sceneName == sceneName && SD.testName == testName)
{
return(true);
}
}
}
}
}
}
}
return(false);
}
// Update is called once per frame
public void UpdateInformation()
{
sysCommonData = Common.GetCommonResultsData();
foreach (InformationEntry ie in informationEntries)
{
switch (ie.source)
{
case InformationSource.SystemData:
{
PopulateInfo(ie.text, FetchInfo(ie.fields, ie.split, ie.splitIndex));
break;
}
case InformationSource.CommonData:
{
PopulateInfo(ie.text, FetchInfo(ie.fields, ie.split, ie.splitIndex));
break;
}
case InformationSource.AlternativeBaseline:
{
AltBaselineSettings altSettings = Master.Instance.GetCurrentPlatformAPI();
if (ie.fields == CommonFields.Platform)
{
ie.text.text = altSettings.Platform;
if (altSettings.Platform != sysCommonData.Platform)
{
ie.text.color = Color.yellow;
}
else
{
ie.text.color = Color.white;
}
}
else if (ie.fields == CommonFields.API)
{
ie.text.text = altSettings.API;
if (altSettings.API != sysCommonData.API)
{
ie.text.color = Color.yellow;
}
else
{
ie.text.color = Color.white;
}
}
else
{
ie.text.text = "N/A";
ie.text.color = Color.red;
}
break;
}
}
}
}
// Logic for creating results data (mandatory override)
public override IEnumerator ProcessResult()
{
var typedSettings = (FrameComparisonSettings)model.settings; // Set settings to local type
if (!typedSettings.useBackBuffer)
{
typedSettings.captureCamera.targetTexture = temporaryRt; // Set capture cameras target texture to temporary RT (logic specific)
dummyCamera.enabled = true;
}
else
{
ProgressScreen.Instance.progressObject.SetActive(false); // Hide the UI breifly to do the capture
menuCamera.enabled = false;
}
var m_TempData = (FrameComparisonResults)GetResultsStruct(); // Get a results struct (mandatory)
yield return(WaitForTimer()); // Wait for timer
if (typedSettings.useBackBuffer)
{
if (Debug.developerConsoleVisible)
{
Debug.ClearDeveloperConsole(); // Clear the dev console if it's visible before capturing the backbuffer.
}
BackBufferCapture();
}
else
{
doCapture = true; // Perform OnRenderImage logic (logic specific)
}
do
{
yield return(null);
} while (resultsTexture == null); // Wait for OnRenderImage logic to complete (logic specific)
m_TempData.resultFrame = Common.ConvertTextureToString(resultsTexture, typedSettings.imageQuality); // Convert results texture to Base64 String and save to results data
if (baselineExists) // Comparison (mandatory)
{
AltBaselineSettings altBaselineSettings = Master.Instance.GetCurrentPlatformAPI(); // current chosen API/plafrom
ResultsDataCommon m_BaselineData = m_TempData.common.SwitchPlatformAPI(altBaselineSettings.Platform, altBaselineSettings.API); // makes new ResultsDataCommon to grab baseline
FrameComparisonResults referenceData = (FrameComparisonResults)DeserializeResults(ResultsIO.Instance.RetrieveEntry(suiteName, testTypeName, m_BaselineData, true, true)); // Deserialize baseline data (mandatory)
m_TempData.common.PassFail = GetComparisonResult(m_TempData, referenceData); // Get comparison results
}
if (typedSettings.useBackBuffer)
{
ProgressScreen.Instance.progressObject.SetActive(true); // Show progress screen again
menuCamera.enabled = true;
}
else
{
dummyCamera.enabled = false;
}
Cleanup(); // Cleanup (logic specific)
BuildResultsStruct(m_TempData); // Submit (mandatory)
}
// Update is called once per frame
void UpdateData()
{
_altBaseline = Master.Instance.GetCurrentPlatformAPI();
_altBaselineSets = Master.GetAltBaselines();
int platIndex = UpdatePlatformDropdown();
_platformDropdown.value = platIndex;
int apiIndex = UpdateAPIDropdown(_altBaseline.Platform);
_apiDropdown.value = apiIndex;
}
// ------------------------------------------------------------------------------------
// Comparison Methods
// Get comparison data
public object ProcessComparison(ResultsBase resultsData)
{
AltBaselineSettings altBaselineSettings = Master.Instance.GetCurrentPlatformAPI(); // current chosen API/plafrom
ResultsDataCommon m_BaselineData = resultsData.common.SwitchPlatformAPI(altBaselineSettings.Platform, altBaselineSettings.API); // makes new ResultsDataCommon to grab baseline
ResultsIOData baselineFetch = ResultsIO.Instance.RetrieveEntry(suiteName, testTypeName, m_BaselineData, true, true); // Get baseline data
if (baselineFetch != null) // If successful
{
ResultsBase baselineData = (ResultsBase)DeserializeResults(baselineFetch); // Convert to results class
return(ProcessComparison(baselineData, resultsData)); // Process comparison
}
else
{
return(null); // Return fail
}
}
// Logic for creating results data
public override IEnumerator ProcessResult()
{
var m_TempData = (ExampleResults)GetResultsStruct(); // Must get results struct and cast to this logics results type (mandatory)
yield return(WaitForTimer()); // Wait for timer
var typedSettings = (ExampleSettings)model.settings; // Set settings to local type (mandatory)
m_TempData = GetDummyData(m_TempData.common); // Just get some dummy data for the example (logic specific)
if (baselineExists) // Comparison (mandatory)
{
AltBaselineSettings altBaselineSettings = Master.Instance.GetCurrentPlatformAPI(); // current chosen API/plafrom
ResultsDataCommon m_BaselineData = m_TempData.common.SwitchPlatformAPI(altBaselineSettings.Platform, altBaselineSettings.API); // makes new ResultsDataCommon to grab baseline
ExampleResults referenceData = (ExampleResults)DeserializeResults(ResultsIO.Instance.RetrieveEntry(suiteName, testTypeName, m_TempData.common, true, true)); // Deserialize baseline data (mandatory)
m_TempData.common.PassFail = GetComparisonResult(m_TempData, referenceData); // Get comparison results
}
BuildResultsStruct(m_TempData); // Submit (mandatory)
}
// ------------------------------------------------------------------------------------
// Execution Overrides
// Logic for creating results data (mandatory override)
public override IEnumerator ProcessResult()
{
var m_TempData = (AverageFrameTimeResults)GetResultsStruct(); // Get a results struct (mandatory)
var typedSettings = (AverageFrameTimeSettings)model.settings; // Set settings to local type
yield return(WaitForTimer()); // Wait for timer
Timestamp(false); // Perform a timestamp (logic specific)
for (int i = 0; i < typedSettings.sampleFrames; i++) // Wait for requested sample frame count (logic specific)
{
yield return(new WaitForEndOfFrame());
}
m_TempData.avgFrameTime = Timestamp(true); // Perform a timestamp (logic specific)
if (baselineExists) // Comparison (mandatory)
{
AltBaselineSettings altBaselineSettings = Master.Instance.GetCurrentPlatformAPI(); // current chosen API/plafrom
ResultsDataCommon m_BaselineData = m_TempData.common.SwitchPlatformAPI(altBaselineSettings.Platform, altBaselineSettings.API); // makes new ResultsDataCommon to grab baseline
AverageFrameTimeResults referenceData = (AverageFrameTimeResults)DeserializeResults(ResultsIO.Instance.RetrieveEntry(suiteName, testTypeName, m_BaselineData, true, true)); // Deserialize baseline data (mandatory)
m_TempData.common.PassFail = GetComparisonResult(m_TempData, referenceData); // Get comparison result
}
BuildResultsStruct(m_TempData); // Submit (mandatory)
}
