internal override ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager)
{
ValidationResult result = base.ValidateSetting(validationTest, pluginManager);
if (result.impact != ValidationResult.Level.OK)
{
return(result);
}
GameObject go = ((GameObject)ActualValue);
if (postProcessingProfile)
{
PostProcessVolume volume = go.GetComponent <PostProcessVolume>();
if (volume == null)
{
return(GetWarningResult(TestName, pluginManager, "Camera does not have a post processing volume.", validationTest.Name, new ResolutionCallback(AddPostProcessing)));
}
if (volume.profile != postProcessingProfile)
{
return(GetWarningResult(TestName, pluginManager, "Camera does not have the correct post processing volume.", validationTest.Name, new ResolutionCallback(AddPostProcessingProfile)));
}
}
return(GetPassResult(TestName, pluginManager, validationTest.Name));
}
internal ValidationResult GetPassResult(string testName, AbstractPluginManager pluginManager, string reportingTest)
{
ValidationResult result = GetResult(testName, pluginManager, "Looks good.", reportingTest);
result.impact = ValidationResult.Level.OK;
return(result);
}
internal override ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager)
{
ValidationResult result = null;
T value;
try
{
value = ActualValue;
}
catch (Exception e)
{
result = GetErrorResult(TestName, pluginManager, "Exception validating " + name + "\n" + e.Message + "\n" + e.StackTrace, validationTest.Name);
result.RemoveCallbacks();
return(result);
}
if (!object.Equals(value, SuggestedValue))
{
result = GetWarningResult(TestName, pluginManager, "The value set is not the same as the suggested value.\n"
+ "Suggested value = " + SuggestedValue + "\n"
+ "Actual Value = " + value + "\n"
+ "This may be OK, in which case click the ignore button.", validationTest.Name);
return(result);
}
return(GetPassResult(TestName, pluginManager, validationTest.Name));
}
private void ValidateChildFields(Type validationTest, AbstractPluginManager pluginManager, IEnumerable <FieldInfo> fields, AbstractSettingSO parentFieldInstance)
{
ValidationResult result;
foreach (FieldInfo field in fields)
{
AbstractSettingSO fieldInstance = field.GetValue(parentFieldInstance) as AbstractSettingSO;
if (fieldInstance == null)
{
AddOrUpdateAsError(field.Name, pluginManager, "Must provide a Setting Scriptable Object");
return;
}
ResultCollection.Remove(field.Name);
if (field.FieldType == typeof(GenericSettingSO <>))
{
ValidateGenericSettingField(field, pluginManager, fieldInstance);
}
Type type = field.FieldType;
// Validate the field according to the SO validation setting.
result = (ValidationResult)type.InvokeMember("Validate",
BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public,
null, fieldInstance, new object[] { validationTest, pluginManager });
ResultCollection.AddOrUpdate(result, validationTest.Name);
IEnumerable <FieldInfo> childFields = field.FieldType.GetFields()
.Where(childField => childField.FieldType.IsSubclassOf(typeof(AbstractSettingSO)));
ValidateChildFields(validationTest, pluginManager, childFields, fieldInstance);
}
}
private void ValidateGenericSettingField(FieldInfo field, AbstractPluginManager pluginManager, AbstractSettingSO fieldInstance)
{
string className = ((GenericSettingSO <T>)fieldInstance).valueClassName;
string accessorName = ((GenericSettingSO <T>)fieldInstance).valueName;
if ((className != null && className.Length > 0) ||
(accessorName != null && accessorName.Length > 0))
{
IEnumerable <Type> propertyTypes = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
from candidate in assembly.GetTypes()
where candidate.Name == className
select candidate);
Type propertyType = propertyTypes.FirstOrDefault();
if (propertyType == null)
{
string msg = "A property accessor is provided but the class identified, `"
+ className + "`, cannot be found in the Assembly.";
AddOrUpdateAsError(field.Name, pluginManager, msg);
}
else
{
PropertyInfo accessorPropertyInfo = propertyType.GetProperty(accessorName);
FieldInfo acessorFieldInfo = propertyType.GetField(accessorName);
if (accessorPropertyInfo == null && acessorFieldInfo == null)
{
string msg = "A property accessor is provided but the accessor identified, `"
+ accessorName + "`, cannot be found in the class specified, `" + className + "`.";
AddOrUpdateAsError(field.Name, pluginManager, msg);
}
}
}
}
/// <summary>
/// Test to see if the setting is valid or not.
/// </summary>
/// <returns>A ValidationResult. This will have an impact of "OK" if the setting is set to an acceptable value.</returns>
public virtual ValidationResult Validate(Type validationTest, AbstractPluginManager pluginManager)
{
ValidationResult result;
if (!Nullable)
{
string testName = "Suggested Value error in " + validationTest.Name.Prettify();
if (SuggestedValue is UnityEngine.Object)
{
if (SuggestedValue as UnityEngine.Object == null)
{
result = GetErrorResult(testName, pluginManager, "Suggested value cannot be null.", validationTest.Name);
return(result);
}
else
{
result = GetPassResult(testName, pluginManager, validationTest.Name);
}
}
else if (SuggestedValue == null)
{
result = GetErrorResult(testName, pluginManager, "Suggested value cannot be null.", validationTest.Name);
return(result);
}
else
{
result = GetPassResult(testName, pluginManager, validationTest.Name);
}
}
return(ValidateSetting(validationTest, pluginManager));
}
internal ValidationResult GetWarningResult(string testName, AbstractPluginManager pluginManager, string message, string reportingTest, ResolutionCallback callback = null)
{
ValidationResult result = GetResult(testName, pluginManager, message, reportingTest, callback);
result.impact = ValidationResult.Level.Warning;
return(result);
}
internal override ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager)
{
ValidationResult result = base.ValidateSetting(validationTest, pluginManager);
if (result.impact != ValidationResult.Level.OK)
{
return(result);
}
GameObject sun = GetFirstInstanceInScene();
#if WEATHER_MAKER_PRESENT
if (sun.GetComponent <WeatherMakerCelestialObjectScript>() == null)
{
ResolutionCallback callback = new ResolutionCallback(ConfigureSunAsCelestialObject);
result = GetErrorResult(TestName, pluginManager, "The sun does not have the celestial object component attached.", validationTest.Name);
List <ResolutionCallback> callbacks = new List <ResolutionCallback>();
callbacks.Add(callback);
result.Callbacks = callbacks;
return(result);
}
#endif
return(GetPassResult(TestName, pluginManager, validationTest.Name));
}
/// <summary>
/// Set the testName conducted by this ValidationTest to an Error.
/// </summary>
/// <param name="testName">Human readable test name.</param>
/// <param name="message">Human readable message describing the test status.</param>
internal void AddOrUpdateAsError(string testName, AbstractPluginManager pluginManager, string message, ResolutionCallback callback = null)
{
string reportingTest = this.GetType().Name;
ValidationResult result = GetResult(testName, pluginManager, message, reportingTest, callback);
result.impact = ValidationResult.Level.Error;
ResultCollection.AddOrUpdate(result, reportingTest);
}
/// <summary>
/// Set the testName conducted by this ValidationTest to a Pass.
/// </summary>
/// <param name="testName">Human readable test name.</param>
/// <param name="message">Human readable message describing the test status.</param>
internal void AddOrUpdateAsPass(string testName, AbstractPluginManager pluginManager, string message)
{
string reportingTest = this.GetType().Name;
ValidationResult result = GetResult(testName, pluginManager, message, reportingTest);
result.impact = ValidationResult.Level.OK;
ResultCollection.AddOrUpdate(result, reportingTest);
}
/// <summary>
/// Create a Validation object.
/// </summary>
/// <param name="name">A human readable message describing the validation state.</param>
/// <param name="impact">The importance of the result from OK to Error.</param>
/// <param name="callbackToFix">A callback method that will allow the result to be corrected if possible.</param>
internal ValidationResult(string name, AbstractPluginManager pluginManager, Level impact, ProfileCallback callbackToFix)
{
this.id = name.GetHashCode();
this.name = name;
this.PluginManager = pluginManager;
this.impact = impact;
if (callbackToFix != null)
{
this.Callbacks.Add(new ResolutionCallback(callbackToFix));
}
}
internal override ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager)
{
ValidationResult result = null;
if (Instance == null)
{
result = GetErrorResult(TestName, pluginManager, SuggestedValue.name + " is required but doesn't currently exist in the scene.", validationTest.Name, new ResolutionCallback(InstantiateScriptableObject));
return(result);
}
return(GetPassResult(TestName, pluginManager, validationTest.Name));
}
/// <summary>
/// Get or create a ValidationResult for a setting and a specific validation test.
/// </summary>
/// <param name="settingTest">The name of the setting test this is a result for.</param>
/// <param name="reportingTest">The name of the ValidationTest that this result is generated for.</param>
/// <returns>An existing ValidationResult if the test has already been run, or a new validation result with an untested state.</returns>
public ValidationResult GetOrCreate(string settingTest, AbstractPluginManager pluginManager, string reportingTest)
{
ValidationResult result;
if (!collection.TryGetValue(settingTest.GetHashCode(), out result))
{
result = new ValidationResult(settingTest, pluginManager);
result.ReportingTest.Add(reportingTest);
AddOrUpdate(result, reportingTest);
}
return(result);
}
public ValidationResultCollection Validate(Type validationTest, AbstractPluginManager pluginManager)
{
ResultCollection = new ValidationResultCollection();
ValidationResult result;
// Is plugin enabled, If not we don't need to test it
if (pluginManager == null)
{
return(ResultCollection);
}
if (!InitialCustomValidations())
{
return(ResultCollection);
}
// Is a plugin profile provided?
if (pluginManager.Profile == null)
{
result = ResultCollection.GetOrCreate(pluginManager.GetType().Name.Prettify() + " - Missing Profile", pluginManager, validationTest.Name);
result.Message = "You need to provide a plugin profile for " + pluginManager.GetType().Name.BreakCamelCase();
result.ReportingTest.Add(validationTest.Name);
result.impact = ValidationResult.Level.Error;
result.RemoveCallbacks();
ResultCollection.AddOrUpdate(result, validationTest.Name);
return(ResultCollection);
}
if (!ProfileType.Name.EndsWith(pluginManager.Profile.GetType().Name))
{
return(ResultCollection);
}
if (!PreFieldCustomValidations(pluginManager))
{
return(ResultCollection);
}
//Validate SettingSO fields
IEnumerable <FieldInfo> fields = pluginManager.Profile.GetType().GetFields()
.Where(field => field.FieldType.IsSubclassOf(typeof(AbstractSettingSO)));
ValidateFields(validationTest, fields, pluginManager);
if (!PostFieldCustomValidations(pluginManager))
{
return(ResultCollection);
}
return(ResultCollection);
}
private ValidationResult GetResult(string testName, AbstractPluginManager pluginManager, string message, string reportingTest, ResolutionCallback callback = null)
{
ValidationResult result = ResultCollection.GetOrCreate(testName, pluginManager, reportingTest);
result.Message = message;
result.impact = ValidationResult.Level.Warning;
result.RemoveCallbacks();
if (callback != null)
{
result.AddCallback(callback);
}
return(result);
}
internal override ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager)
{
if (Target.Instance == null)
{
return(GetErrorResult("Target is required.", pluginManager, Target.name, validationTest.Name, new ResolutionCallback(Target.InstantiatePrefab)));
}
if (ActualValue != null)
{
return(GetPassResult("MonoBehaviour is required", pluginManager, validationTest.Name));
}
else
{
return(GetErrorResult("MonoBehaviour is required", pluginManager, SuggestedValue.name + " is not present " + Target.Instance.name, validationTest.Name));
}
}
internal override bool PostFieldCustomValidations(AbstractPluginManager pluginManager)
{
bool isPass = base.PostFieldCustomValidations(pluginManager);
if (UnityEngine.Terrain.activeTerrain)
{
AddOrUpdateAsPass("Terrain is required.", pluginManager, "There is a terrain in the scene.");
}
else
{
ResolutionCallback callback = new ResolutionCallback(new ProfileCallback(GenerateTerrain));
AddOrUpdateAsError("Terrain is required.", pluginManager, "There is no terrain in the scene.", callback);
isPass = false;
}
return(isPass);
}
private ValidationResult GetResult(string testName, AbstractPluginManager pluginManager, string message, string reportingTest, ResolutionCallback callback = null)
{
ValidationResult result = ValidationCollection.GetOrCreate(SettingName + " - " + testName, pluginManager, reportingTest);
result.Message = message;
result.impact = ValidationResult.Level.Warning;
result.Callbacks = new List <ResolutionCallback>();
if (callback != null)
{
result.AddCallback(callback);
}
else
{
AddDefaultFixCallback(result);
}
return(result);
}
internal override bool InitialCustomValidations()
{
AbstractPluginManager pluginManager = GameObject.FindObjectOfType <Agent_HerdSim_PluginManager>();
bool result = base.InitialCustomValidations();
if (UnityEngine.Terrain.activeTerrain.gameObject.layer == LayerMask.NameToLayer(terrainLayerName))
{
AddOrUpdateAsPass("Terrain Layer", pluginManager, "The terrain is marked as having the layer `Ground`.");
result &= true;
}
else
{
ResolutionCallback callback = new ResolutionCallback(SetTerrainLayer, "Set Terrain Layer");
AddOrUpdateAsError("Terrain Layer", pluginManager, "The terrain must be marked as having the layer `Ground`.", callback);
result = false;
}
return(result);
}
internal override bool InitialCustomValidations()
{
AbstractPluginManager pluginManager = GameObject.FindObjectOfType <DigitalPaintingManager>();
bool isPass = base.InitialCustomValidations();
string path = GetPathToScene();
if (AssetDatabase.IsValidFolder(path + "/" + AssetDatabaseUtility.dataFolderName))
{
AddOrUpdateAsPass("Data Directory Existence", pluginManager, "The Digital Painting Data exists.");
}
else
{
ResolutionCallback callback = new ResolutionCallback(new ProfileCallback(CreateDefaultSettingsData));
AddOrUpdateAsWarning("Data Directory Existence", pluginManager, "The Digital Painting Data folder does not exist.", callback);
return(false);
}
return(isPass);
}
internal override ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager)
{
ValidationResult result = null;
if (Instance == null)
{
if (AddToScene)
{
result = GetErrorResult(TestName, pluginManager, SuggestedValue.name + " is required but doesn't currently exist in the scene", validationTest.Name);
}
else
{
result = GetWarningResult(TestName, pluginManager, SuggestedValue.name + " doesn't currently exist in the scene. It is not required, if you don't want it then click the ignore button.", validationTest.Name);
}
List <ResolutionCallback> callbacks = new List <ResolutionCallback>();
ResolutionCallback callback = new ResolutionCallback(InstantiatePrefab);
callbacks.Add(callback);
result.Callbacks = callbacks;
return(result);
}
return(GetPassResult(TestName, pluginManager, validationTest.Name));
}
/// <summary> /// Test to see if the setting is valid or not. It's not necessary to test for null values here, /// that is done automatically. /// </summary> /// <returns>True or false depending on whether the setting is correctly set (true) or not (false)</returns> internal abstract ValidationResult ValidateSetting(Type validationTest, AbstractPluginManager pluginManager);
/// <summary>
/// If a plugin needs to perform any specific validations that are not expressed in the form of setting scriptable
/// objects it should override this method if these validations are to be done after field validations.
/// Any successes or failures should be added to the `Collection`.
/// </summary>
/// <returns>True if validations passed. False if one ore more warning or error occurs.</returns>
internal virtual bool PostFieldCustomValidations(AbstractPluginManager pluginManager)
{
return(true);
}
/// <summary>
/// Create a Validation object.
/// </summary>
/// <param name="name">A human readable message describing the validation state.</param>
/// <param name="impact">The importance of the result from OK to Error.</param>
internal ValidationResult(string name, AbstractPluginManager pluginManager, Level impact) : this(name, pluginManager, impact, null)
{
}
/// <summary>
/// Create a Validation object in an untested state.
/// </summary>
/// <param name="name">A human readable message describing the validation state.</param>
/// <param name="impact">The importance of the result from OK to Error.</param>
internal ValidationResult(string name, AbstractPluginManager pluginManager) : this(name, pluginManager, Level.Untested, null)
{
}
internal void Pass(string testName, AbstractPluginManager pluginManager, string reportingTest)
{
Remove(testName);
AddOrUpdate(new ValidationResult(testName, pluginManager, ValidationResult.Level.OK), reportingTest);
}
