void Update()
{
if (value < 0)
{
this.textElement.color = this.colorIfNegative;
}
else
{
this.textElement.color = this.defaultColor;
}
if (this.isBool)
{
if (value < 0)
{
this.textElement.text = this.prefix + "False";
}
else
{
this.textElement.text = this.prefix + "True";
}
}
else
{
this.textElement.text = prefix + MyRoutines.Round(value, this.decimalPlaces).ToString();
}
}
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
SerializedProperty color = prop.FindPropertyRelative("color");
SerializedProperty rotation = prop.FindPropertyRelative("rotation");
SerializedProperty intensity = prop.FindPropertyRelative("intensity");
float lineHeight = MyRoutines.GetEditorGUIStandardLineHeight();
float yPos = pos.y;
//color
EditorGUI.PropertyField(new Rect(pos.x, yPos, pos.width, lineHeight), color, new GUIContent(color.displayName, color.tooltip));
//intensity
yPos = MyRoutines.GetEditorGUINextControlYPos(yPos);
EditorGUI.PropertyField(new Rect(pos.x, yPos, pos.width, lineHeight), intensity, new GUIContent(intensity.displayName, intensity.tooltip));
//rotation
yPos = MyRoutines.GetEditorGUINextControlYPos(yPos);
EditorGUI.PropertyField(new Rect(pos.x, yPos, pos.width, lineHeight), rotation, new GUIContent(rotation.displayName, rotation.tooltip));
yPos = MyRoutines.GetEditorGUINextControlYPos(yPos);
if (EditorGUIUtility.wideMode == false)
{
yPos = MyRoutines.GetEditorGUINextControlYPos(yPos);
}
GUIContent buttonGUIContent = new GUIContent("Same As Existing Directional Light", "Copies the settings of the scenes's main directional light.");
if (GUI.Button(new Rect(pos.x, yPos, pos.width, lineHeight), buttonGUIContent))
{
Light light = GameObject.FindGameObjectWithTag(TagManager.DirectionalLight).GetComponent <Light> ();
color.colorValue = light.color;
rotation.vector3Value = light.transform.localEulerAngles;
//rotation.vector3Value = light.transform.rotation.eulerAngles;
intensity.floatValue = light.intensity;
}
}
internal virtual void CheckRecorderValidity()
{
//implement validation checks
//the output path should not be null
this.isValid = true;
if (string.IsNullOrEmpty(this.outputDetails.outputPath))
{
Debug.LogError("Output path not specified.");
this.isValid = false;
}
if (this.outputDetails.isFile)
{
//if this is a file, the extension of the file in outputpath should match the file extension in outputdetails
if (System.IO.Path.GetExtension(this.outputDetails.outputPath) != ("." + this.outputDetails.fileExtension))
{
Debug.LogError("File extension is invalid or no output file was specified.");
this.isValid = false;
}
}
//if we are storing data to a folder then create the target directory
if (this.outputDetails.isFile == false)
{
if (MyRoutines.CreateDirectory(this.outputDetails.outputPath, false) == false)
{
Debug.LogError("The directory could not be created.");
this.isValid = false;
}
}
}
internal override void CaptureData()
{
this.dataList.Clear();
//capture data is only called from inspector
this.CheckRecorderValidity();
if (this.isValid == false)
{
Debug.LogError("Curve recorder configuration is invalid. Could not extract curve data.");
return;
}
AnimationCurve anim = null;
switch (this.transferFunction)
{
case TransferFunctionType.Visual:
anim = vehicle.visualProcessingFunction.curve;
break;
case TransferFunctionType.Motor:
anim = vehicle.visuoMotorFunction.curve;
break;
case TransferFunctionType.Rotation:
anim = vehicle.rotationFunction.curve;
break;
case TransferFunctionType.Drag:
anim = vehicle.vehicleDragFunction.curve;
break;
}
//convert the rate to an interval that can be used to increment the x value
float interval = MyRoutines.ConvertRateToInterval(this.outputDetails.dataCaptureRate);
if (anim == null)
{
Debug.LogError("Could not resolve curve.");
return;
}
if (anim.length == 0)
{
Debug.LogError("The curve does not contain any keyframes.");
return;
}
float maxX = MyRoutines.AnimationCurveMaximumXValue(anim);
float x = 0f;
while (x < maxX)
{
this.dataList.Add(x, anim.Evaluate(x));
x += interval;
}
//add in value for last x value
this.dataList.Add(maxX, anim.Evaluate(maxX));
//now save the data
this.recording = true;
this.SaveData();
this.recording = false;
Debug.Log("Saved data to " + this.outputDetails.outputPath);
}
public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
{
SerializedProperty outputPath = prop.FindPropertyRelative("outputPath");
int lines = 3;
if (string.IsNullOrEmpty(outputPath.stringValue) == false)
{
lines += 2;
}
return(MyRoutines.GetGUIPropertyHeight(lines));
}
private bool RecordEyeTestData()
{
//only record eye data if:
//1. the eye test is enabled
//2. there was no error while initializing the eyetest
//3. the appropriate amount of time has lapsed since the last data serialization
//4. the stop time has not been reached
return((this.eyeTest.enabled == true) && (this.eyeTest.initializationError == false) &&
(Time.time >= (MyRoutines.ConvertRateToInterval(this.eyeTest.rate) + this.lastEyeTestTime) &&
(Time.time <= this.eyeTest.stopTime)));
}
//private int activatedTriggerHash;
// Use this for initialization
void Start()
{
//get a reference to the animator component of the target light
anim = GetComponent <Animator>();
//this.activatedTriggerHash = Animator.StringToHash("VehicleActivated");
if (vehicle == null)
{
//get a reference to the vehicle
this.vehicle = MyRoutines.GetPrimaryVehicle();
}
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
int lines = 0;
if (EditorGUIUtility.wideMode == false)
{
lines = 5;
}
else
{
lines = 4;
}
return(MyRoutines.GetGUIPropertyHeight(lines));
}
// Use this for initialization
internal override void Start()
{
base.Start();
this.isActivated = false;
//disable the vehicle motor
this.vehicle.disableMotor = true;
//initialize the vehicle's eye memory
eyeMemoryLeft = new Queue <ColorInformation[, ]> (this.eyeMemoryCapacity);
eyeMemoryRight = new Queue <ColorInformation[, ]> (this.eyeMemoryCapacity);
//initialize the vehicle's eyes
this.InitEye(this.leftEye);
this.InitEye(this.rightEye);
this.InvokeRepeating("ProcessScene", 0, MyRoutines.ConvertRateToInterval(this.lookRate));
}
private static void GetLightSettings()
{
string output = "";
string newLine = System.Environment.NewLine;
output += MyRoutines.GetObjectPropertyString("Ambient Light", RenderSettings.ambientLight);
output += MyRoutines.GetObjectPropertyString("Ambient Intensity", RenderSettings.ambientIntensity);
output += MyRoutines.GetObjectPropertyString("Ambient Mode", RenderSettings.ambientMode);
output += MyRoutines.GetObjectPropertyString("Fog", RenderSettings.fog);
output += MyRoutines.GetObjectPropertyString("Fog Color", RenderSettings.fogColor);
output += MyRoutines.GetObjectPropertyString("Fog Mode", RenderSettings.fogMode);
output += MyRoutines.GetObjectPropertyString("Fog Start", RenderSettings.fogStartDistance);
output += MyRoutines.GetObjectPropertyString("Fog End", RenderSettings.fogEndDistance);
output += MyRoutines.GetObjectPropertyString("Fog Skybox", RenderSettings.skybox);
output += MyRoutines.GetObjectPropertyString("Sun ", RenderSettings.sun);
Debug.Log(output);
}
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
SerializedProperty enabled = prop.FindPropertyRelative("enabled");
SerializedProperty outputFolder = prop.FindPropertyRelative("outputFolder");
SerializedProperty rate = prop.FindPropertyRelative("rate");
SerializedProperty captureProcessedImage = prop.FindPropertyRelative("captureProcessedImage");
SerializedProperty stopTime = prop.FindPropertyRelative("stopTime");
float lineHeight = MyRoutines.GetEditorGUIStandardLineHeight();
EditorGUI.PropertyField(new Rect(pos.x, pos.y, pos.width, lineHeight), enabled, new GUIContent("Eye Test", enabled.tooltip));
if (enabled.boolValue)
{
EditorGUI.indentLevel++;
string tooltip = MyRoutines.GetTooltip(typeof(EyeTest), "outputFolder");
float ypos = MyRoutines.GetEditorGUINextControlYPos(pos.y);
EditorGUI.PropertyField(new Rect(pos.x, ypos, pos.width, lineHeight), captureProcessedImage);
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos);
Rect controlRect = new Rect(pos.x, ypos, pos.width, lineHeight); //lineheight
//MyRoutines.CreateScreenRecordingControl (outputFolder.displayName, tooltip, controlRect, outputFolder, rate, "EyeTestData");
MyRoutines.CreateOutputPathControl(outputFolder.displayName, tooltip, controlRect, outputFolder, false, string.Empty, string.Empty);
if (string.IsNullOrEmpty(outputFolder.stringValue) == false)
{
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos);
controlRect = new Rect(pos.x, ypos, pos.width, lineHeight * 2);
EditorGUI.HelpBox(controlRect, "The contents of the selected folder will be overwritten.", MessageType.Warning);
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos) + lineHeight;
}
else
{
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos);
}
EditorGUI.PropertyField(new Rect(pos.x, ypos, pos.width, lineHeight), rate);
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos);
EditorGUI.PropertyField(new Rect(pos.x, ypos, pos.width, lineHeight), stopTime);
if (stopTime.floatValue <= 0)
{
stopTime.floatValue = Mathf.Infinity;
}
EditorGUI.indentLevel--;
}
}
// public static void CreateScreenRecordingControl(string displayName, string tooltip, Rect pos, SerializedProperty outputFolder, SerializedProperty rate, string defaultFolderName)
// {
//
// float labelWidth = MyRoutines.GetEditorGUILabelWidth();
// float padding = MyRoutines.GetEditorGUIControlSpacing();
// float lineHeight = MyRoutines.GetEditorGUIStandardLineHeight ();
// int folderButtonWidth = 25;
//
// //create the label field
// EditorGUI.LabelField (new Rect (pos.x, pos.y, labelWidth, lineHeight), new GUIContent (displayName, tooltip));
// //reset the indent level
// int indentLevel = EditorGUI.indentLevel;
// EditorGUI.indentLevel = 0;
// //disable the GUI
// GUI.enabled = false;
// if (string.IsNullOrEmpty(outputFolder.stringValue))
// outputFolder.stringValue = System.IO.Path.Combine(Application.dataPath, defaultFolderName);
// float outputFolderWidth = pos.width - labelWidth - folderButtonWidth - padding;
// //create the outputfolder field
// EditorGUI.TextField (new Rect (pos.x + labelWidth, pos.y, outputFolderWidth, lineHeight), outputFolder.stringValue);
// //renable the GUI
// GUI.enabled = true;
// float buttonXPos = pos.x + labelWidth + outputFolderWidth + padding;
// if (GUI.Button(new Rect(buttonXPos, pos.y, folderButtonWidth, lineHeight), "...")) {
// string value = EditorUtility.OpenFolderPanel ("Select Output Folder", "", "");
// if (string.IsNullOrEmpty (value) == false)
// outputFolder.stringValue = value;
// }
// EditorGUI.indentLevel = indentLevel;
// //get the vertical position of the next control
// float ypos = MyRoutines.GetEditorGUINextControlYPos(pos.y);
// EditorGUI.PropertyField(new Rect(pos.x, ypos, pos.width, lineHeight), rate);
// }
public static void CreateOutputPathControl(string displayName, string tooltip, Rect pos, SerializedProperty outputPath, bool isFile, string fileExtension, string defaultFileName)
{
float labelWidth = MyRoutines.GetEditorGUILabelWidth();
float padding = MyRoutines.GetEditorGUIControlSpacing();
float lineHeight = MyRoutines.GetEditorGUIStandardLineHeight();
int folderButtonWidth = 25;
//create the label field
EditorGUI.LabelField(new Rect(pos.x, pos.y, labelWidth, lineHeight), new GUIContent(displayName, tooltip));
//reset the indent level
int indentLevel = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
//disable the GUI
GUI.enabled = false;
// if (string.IsNullOrEmpty(outputPath.stringValue))
// outputPath.stringValue = Application.dataPath;
float outputFolderWidth = pos.width - labelWidth - folderButtonWidth - padding;
//create the outputfolder field
EditorGUI.TextField(new Rect(pos.x + labelWidth, pos.y, outputFolderWidth, lineHeight), outputPath.stringValue);
//renable the GUI
GUI.enabled = true;
float buttonXPos = pos.x + labelWidth + outputFolderWidth + padding;
if (GUI.Button(new Rect(buttonXPos, pos.y, folderButtonWidth, lineHeight), "..."))
{
string value = string.Empty;
if (isFile == false)
{
//folder
value = EditorUtility.OpenFolderPanel("Select Output Folder", outputPath.stringValue, "");
}
else
{
//file
value = EditorUtility.SaveFilePanel("Save File", outputPath.stringValue, defaultFileName + "." + fileExtension, fileExtension);
}
if (string.IsNullOrEmpty(value) == false)
{
outputPath.stringValue = value;
}
}
EditorGUI.indentLevel = indentLevel;
}
// Use this for initialization
void Start()
{
if (useRate)
{
InvokeRepeating("DepositMarker", 0, MyRoutines.ConvertRateToInterval(rate));
}
else
{
//use a list of times
//sort the times in increasing order
List <float> t = new List <float>(this.times);
t.Sort();
foreach (float f in t)
{
Debug.Log(f.ToString());
}
q = new Queue <float> (t);
}
}
public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
{
SerializedProperty enabled = prop.FindPropertyRelative("enabled");
SerializedProperty outputFolder = prop.FindPropertyRelative("outputFolder");
int lines = 0;
if (enabled.boolValue == false)
{
lines = 1;
}
else
{
lines = 5;
}
if (string.IsNullOrEmpty(outputFolder.stringValue) == false && enabled.boolValue == true)
{
lines += 2;
}
return(MyRoutines.GetGUIPropertyHeight(lines));
}
internal override void OnStart()
{
if (record)
{
//set data capture rate to zero to ensure that data capture is invoked from update
int tempDataCaptureRate = this.outputDetails.dataCaptureRate;
this.outputDetails.dataCaptureRate = 0;
base.OnStart();
if (this.isValid)
{
Time.captureFramerate = this.outputDetails.dataCaptureRate;
}
this.outputDetails.dataCaptureRate = tempDataCaptureRate;
this.captureInterval = MyRoutines.ConvertRateToInterval(this.outputDetails.dataCaptureRate);
}
else
{
this.recording = false;
}
}
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
SerializedProperty outputPath = prop.FindPropertyRelative("outputPath");
SerializedProperty dataCaptureRate = prop.FindPropertyRelative("dataCaptureRate");
SerializedProperty stopTime = prop.FindPropertyRelative("stopTime");
float lineHeight = MyRoutines.GetEditorGUIStandardLineHeight();
DataOutputDetails outputDetails = fieldInfo.GetValue(prop.serializedObject.targetObject) as DataOutputDetails;
bool isFile = outputDetails.isFile;
string fileExtension = outputDetails.fileExtension;
string defaultFileName = outputDetails.defaultFileName;
string tooltip = MyRoutines.GetTooltip(typeof(DataOutputDetails), "outputPath");
//create the output path control
MyRoutines.CreateOutputPathControl(outputPath.displayName, tooltip, pos, outputPath, isFile, fileExtension, defaultFileName);
float ypos;
if (string.IsNullOrEmpty(outputPath.stringValue) == false)
{
ypos = MyRoutines.GetEditorGUINextControlYPos(pos.y);
Rect controlRect = new Rect(pos.x, ypos, pos.width, lineHeight * 2);
EditorGUI.HelpBox(controlRect, "The contents of the selected folder will be overwritten.", MessageType.Warning);
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos) + lineHeight;
}
else
{
ypos = MyRoutines.GetEditorGUINextControlYPos(pos.y);
}
//create the datacapture rate field
tooltip = MyRoutines.GetTooltip(typeof(DataOutputDetails), "dataCaptureRate");
string rateDisplayName = outputDetails.rateFieldLabel;
EditorGUI.PropertyField(new Rect(pos.x, ypos, pos.width, lineHeight), dataCaptureRate, new GUIContent(rateDisplayName, tooltip));
//create the stopTime field
ypos = MyRoutines.GetEditorGUINextControlYPos(ypos);
EditorGUI.PropertyField(new Rect(pos.x, ypos, pos.width, lineHeight), stopTime);
if (stopTime.floatValue <= 0)
{
stopTime.floatValue = Mathf.Infinity;
}
}
internal virtual void OnStart()
{
this.dataList.Clear();
recording = false;
this.CheckRecorderValidity();
if (this.isValid == false)
{
return;
}
//if datacapture rate is greater than zero then call CaptureData routine with relevant interval
if (this.outputDetails.dataCaptureRate > 0)
{
this.InvokeRepeating("CaptureData", 0, MyRoutines.ConvertRateToInterval(this.outputDetails.dataCaptureRate));
this.runInUpdate = false;
}
else
{
runInUpdate = true;
}
//set recording to true
recording = true;
}
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
SerializedProperty showScale = prop.FindPropertyRelative("showScale");
SerializedProperty curveColor = prop.FindPropertyRelative("curveColor");
SerializedProperty yScale = prop.FindPropertyRelative("yScale");
SerializedProperty xScale = prop.FindPropertyRelative("xScale");
SerializedProperty yMaxScale = prop.FindPropertyRelative("yMaxScale");
SerializedProperty xMaxScale = prop.FindPropertyRelative("xMaxScale");
SerializedProperty curve = prop.FindPropertyRelative("curve");
SerializedProperty curveType = prop.FindPropertyRelative("curveType");
float padding = MyRoutines.GetEditorGUIControlSpacing();
float lineHeight = MyRoutines.GetEditorGUIStandardLineHeight();
float yPos = pos.y;
float curveWidth = pos.width;
string tooltip = MyRoutines.GetTooltip(prop.serializedObject.targetObject.GetType(), prop.name);
GUIContent gContent = new GUIContent(label.text, tooltip); //prop.tooltip doesn't work
//draw the slider if required
if (showScale.boolValue)
{
curveWidth = 75;
EditorGUI.IntSlider(new Rect(pos.x, yPos, pos.width - curveWidth, lineHeight), yScale, 0, yMaxScale.intValue, gContent);
}
//draw curve
if (showScale.boolValue)
{
int indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
EditorGUI.CurveField(new Rect(pos.x + (pos.width - curveWidth) + padding, yPos, curveWidth - padding, lineHeight), curve, curveColor.colorValue, new Rect(0, 0, xScale.intValue, yScale.intValue), GUIContent.none);
EditorGUI.indentLevel = indent;
}
else
{
EditorGUI.CurveField(new Rect(pos.x, yPos, curveWidth - padding, lineHeight), curve, curveColor.colorValue, new Rect(0, 0, xMaxScale.intValue, yScale.intValue), gContent);
}
//buttons
yPos = MyRoutines.GetEditorGUINextControlYPos(yPos);
float buttonWidth = (pos.width / 3) - padding;
GUIContent buttonGUIContent = new GUIContent("Reset", "Reset the curve to its default setting.");
if (GUI.Button(new Rect(pos.x, yPos, buttonWidth, lineHeight), buttonGUIContent))
{
//reset the animation curve
//get a reference to the curve
ScaledCurve c = (ScaledCurve)fieldInfo.GetValue(prop.serializedObject.targetObject);
//reset the curve
curve.animationCurveValue = c.ResetCurve();
}
buttonGUIContent = new GUIContent("Save", "Saves curve data to an asset file.");
if (GUI.Button(new Rect(pos.x + buttonWidth + padding, yPos, buttonWidth, lineHeight), buttonGUIContent))
{
string path = EditorUtility.SaveFilePanelInProject("Save Curve", "CurveData", "asset", "Please enter a file name to save the curve data to.");
if (string.IsNullOrEmpty(path) == false)
{
//save curve data as scriptable object instance
SerializedCurve asset = ScriptableObject.CreateInstance <SerializedCurve> ();
asset.curve = new SerializableCurve(curve.animationCurveValue);
asset.curveType = curveType.stringValue;
AssetDatabase.CreateAsset(asset, path);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
buttonGUIContent = new GUIContent("Load", "Loads curve data from an asset file.");
if (GUI.Button(new Rect(pos.x + ((buttonWidth + padding) * 2), yPos, buttonWidth, lineHeight), buttonGUIContent))
{
string path = EditorUtility.OpenFilePanel("Load Curve", Application.dataPath, "asset");
if (string.IsNullOrEmpty(path) == false)
{
//load curve data from scriptable object
path = path.Replace(Application.dataPath, "Assets");
SerializedCurve asset = AssetDatabase.LoadAssetAtPath <SerializedCurve>(path);
if (asset.curveType == curveType.stringValue)
{
//correct type - replace curve with serialized curve data
curve.animationCurveValue = asset.curve.ToAnimationCurve();
}
else
{
EditorUtility.DisplayDialog("Error", "Saved curve data is of the wrong type.", "OK");
}
}
}
}
public static float GetGUIPropertyHeight(int lines)
{
return((MyRoutines.GetEditorGUIStandardLineHeight() * lines) + (MyRoutines.GetEditorGUIStandardVerticalSpacing() * (lines - 1)));
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
return(MyRoutines.GetGUIPropertyHeight(2));
}
public static float GetEditorGUINextControlYPos(float yPos)
{
return(yPos + MyRoutines.GetEditorGUIStandardLineHeight() + MyRoutines.GetEditorGUIStandardVerticalSpacing());
}