/// <summary>
/// Function used to override the default animation values defined within XamlFlair
/// </summary>
public static void OverrideDefaultSettings(
AnimationKind kind = DefaultSettings.DEFAULT_KIND,
double duration = DefaultSettings.DEFAULT_DURATION,
double interElementDelay = DefaultSettings.DEFAULT_INTER_ELEMENT_DELAY,
EasingType easing = DefaultSettings.DEFAULT_EASING,
EasingMode mode = DefaultSettings.DEFAULT_EASING_MODE,
#if __WPF__
TransformationType transformOn = DefaultSettings.DEFAULT_TRANSFORM_ON,
#elif __UWP__ && !HAS_UNO
double saturation = DefaultSettings.DEFAULT_SATURATION,
#endif
EventType @event = DefaultSettings.DEFAULT_EVENT)
{
DefaultSettings.Kind = kind;
DefaultSettings.Duration = duration;
DefaultSettings.InterElementDelay = interElementDelay;
DefaultSettings.Easing = easing;
DefaultSettings.Mode = mode;
DefaultSettings.Event = @event;
#if __WPF__
DefaultSettings.TransformOn = transformOn;
#elif __UWP__ && !HAS_UNO
DefaultSettings.Saturation = saturation;
#endif
}
public void Validate(ASafeLog log)
{
if (Types == null)
{
Types = new List <string>();
}
m_oTypes.Clear();
foreach (string sType in Types)
{
if (string.IsNullOrWhiteSpace(sType))
{
throw new OwnException("Transformation type not specified.");
}
TransformationType nType = TransformationType.None;
if (!TransformationType.TryParse(sType.Trim(), true, out nType))
{
throw new OwnException("Unsupported transformation type: {0}", sType);
}
m_oTypes.Add(nType);
} // for each type
} // Validate
public string ShowDialog(EyeshotClient client, TransformationType transformationType)
{
_eyeshotClient = client;
// Locks the popup size
MinimumSize = MaximumSize = Size;
switch (transformationType)
{
case TransformationType.Rotate:
grpTranslate.Enabled = grpScale.Enabled = false;
break;
case TransformationType.Translate:
grpRotate.Enabled = grpScale.Enabled = false;
break;
case TransformationType.Scale:
grpRotate.Enabled = grpTranslate.Enabled = false;
break;
}
if (ShowDialog() != DialogResult.OK)
{
_transformationText = String.Empty;
}
return(_transformationText);
}
public static XmlDocument Transform(TransformationType type, XmlDocument source, string transformXml)
{
var resultXml = Transform(type, source.OuterXml, transformXml);
var result = new XmlDocument();
result.LoadXml(resultXml);
return(result);
}
public TransformationGetDataOperation(
string adminConnectionString, Table srcTable, TransformationType transformationType, int srcTimetableId)
: base(DatabaseUtils.CreateConnectionStringSettings(adminConnectionString))
{
_srcTable = srcTable;
_transformationType = transformationType;
_srcTimetableId = srcTimetableId;
}
internal Transformation(Color startColour, Color endColour, int time1, int time2)
{
Type = TransformationType.Colour;
StartColour = startColour;
EndColour = endColour;
Time1 = time1;
Time2 = time2;
}
internal Transformation(Vector2 startPosition, Vector2 endPosition, int time1, int time2, EasingTypes easing)
{
Type = TransformationType.Movement;
StartVector = startPosition;
EndVector = endPosition;
Easing = easing;
Time1 = time1;
Time2 = time2;
}
public Transformation(Color4 startColour, Color4 endColour, double time1, double time2, EasingTypes easing = EasingTypes.None)
{
Type = TransformationType.Colour;
StartColour = startColour;
EndColour = endColour;
Time1 = time1;
Time2 = time2;
Easing = easing;
}
public Transformation(TransformationType type, Vector2 startVector, Vector2 endVector, double time1, double time2, EasingTypes easing = EasingTypes.None)
{
Type = type;
StartVector = startVector;
EndVector = endVector;
Time1 = time1;
Time2 = time2;
Easing = easing;
}
public Transformation(Vector2 startPosition, Vector2 endPosition, double time1, double time2, EasingTypes easing = EasingTypes.None)
{
Type = TransformationType.Movement;
StartVector = startPosition;
EndVector = endPosition;
Easing = easing;
Time1 = time1;
Time2 = time2;
}
public Transformation(TransformationType type, float startFloat, float endFloat, double time1, double time2, EasingTypes easing = EasingTypes.None)
{
Type = type;
StartFloat = startFloat;
EndFloat = endFloat;
Time1 = time1;
Time2 = time2;
Easing = easing;
}
public Transformation(TransformationType type, Vector2 vector1, Vector2 vector2, int start, int end, EasingTypes easing)
{
Type = type;
StartVector = vector1;
EndVector = vector2;
Time1 = start;
Time2 = end;
Easing = easing;
}
internal Transformation(RectangleF startClipRectangle, RectangleF endClipRectangle, int time1, int time2, EasingTypes easing = EasingTypes.None)
{
Type = TransformationType.ClipRectangle;
StartRectangle = startClipRectangle;
EndRectangle = endClipRectangle;
Time1 = time1;
Time2 = time2;
Easing = easing;
}
internal Transformation(TransformationType type, Vector2 startVector, Vector2 endVector, int time1, int time2, EasingTypes easing = EasingTypes.None)
{
Type = type;
StartVector = startVector;
EndVector = endVector;
Time1 = time1;
Time2 = time2;
Easing = easing;
}
internal Transformation(TransformationType type, float startFloat, float endFloat, int time1, int time2, EasingTypes easing = EasingTypes.None)
{
Type = type;
StartFloat = startFloat;
EndFloat = endFloat;
Time1 = time1;
Time2 = time2;
Easing = easing;
}
internal TransformationV(TransformationType type, Vector2 source, Vector2 destination, int start, int end, EasingTypes easing = EasingTypes.None)
{
Type = type;
StartVector = source;
EndVector = destination;
StartTime = start;
EndTime = end;
Easing = easing;
}
internal TransformationF(TransformationType type, float source, float destination, int start, int end, EasingTypes easing = EasingTypes.None)
{
Type = type;
StartFloat = source;
EndFloat = destination;
StartTime = start;
EndTime = end;
Easing = easing;
}
internal Transformation(TransformationType type, float startValue, float endValue, int time1, int time2, EasingTypes easing)
{
Type = type;
Time1 = time1;
Time2 = time2;
StartFloat = startValue;
EndFloat = endValue;
Easing = easing;
}
public static Transform Rotation(Vector3d axis, double angleRadians)
{
axis.Unitize();
// Check if the axis is parallel to one of the 3 axes
if (axis.IsParallelTo(Vector3d.ZAxis))
{
// Rotate on the Z axis
transformMatrix = new double[4, 4]
{
{ Math.Cos(angleRadians), -Math.Sin(angleRadians), 0, 0 },
{ Math.Sin(angleRadians), Math.Cos(angleRadians), 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 }
};
}
else if (axis.IsParallelTo(Vector3d.YAxis))
{
// rotate on the Y axis
transformMatrix = new double[4, 4]
{
{ Math.Cos(angleRadians), 0, Math.Sin(angleRadians), 0 },
{ 0, 1, 0, 0 },
{ -Math.Sin(angleRadians), 0, Math.Cos(angleRadians), 0 },
{ 0, 0, 0, 1 }
};
}
else if (axis.IsParallelTo(Vector3d.XAxis))
{
// Rotation on the X Axis
transformMatrix = new double[4, 4]
{
{ 1, 0, 0, 0 },
{ 0, Math.Cos(angleRadians), -Math.Sin(angleRadians), 0 },
{ 0, Math.Sin(angleRadians), Math.Cos(angleRadians), 0 },
{ 0, 0, 0, 1 }
};
}
else
{
// Rotation on an arbitrary axis
transformMatrix = new double[4, 4]
{
{ Math.Pow(axis.X, 2) + (1 - Math.Pow(axis.X, 2)) * Math.Cos(angleRadians), axis.X *axis.Y *(1 - Math.Cos(angleRadians)) - axis.Z * Math.Sin(angleRadians), axis.X *axis.Z *(1 - Math.Cos(angleRadians)) + axis.Y * Math.Sin(angleRadians), 0 },
{ axis.X *axis.Y *(1 - Math.Cos(angleRadians)) + axis.Z * Math.Sin(angleRadians), Math.Pow(axis.Y, 2) + (1 - Math.Pow(axis.Y, 2)) * Math.Cos(angleRadians), axis.Y *axis.Z *(1 - Math.Cos(angleRadians)) - axis.X * Math.Sin(angleRadians), 0 },
{ axis.X *axis.Z *(1 - Math.Cos(angleRadians)) - axis.Y * Math.Sin(angleRadians), axis.Y *axis.Z *(1 - Math.Cos(angleRadians)) + axis.X * Math.Sin(angleRadians), Math.Pow(axis.Z, 2) + (1 - Math.Pow(axis.Z, 2)) * Math.Cos(angleRadians), 0 },
{ 0, 0, 0, 1 }
};
}
transType = TransformationType.Rotation;
return(new Transform(transformMatrix));
}
public void TransformImage(Image <Gray, Byte> image, TransformationType type)
{
var kernel = CvInvoke.GetStructuringElement(Emgu.CV.CvEnum.ElementShape.Rectangle, new Size(3, 3), new Point(-1, -1));
switch (type)
{
case TransformationType.ERODE:
CvInvoke.Erode(image, image, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.DILATE:
CvInvoke.Dilate(image, image, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.OPEN:
CvInvoke.MorphologyEx(image, image, Emgu.CV.CvEnum.MorphOp.Open, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.CLOSE:
CvInvoke.MorphologyEx(image, image, Emgu.CV.CvEnum.MorphOp.Close, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.TOPHAT:
CvInvoke.MorphologyEx(image, image, Emgu.CV.CvEnum.MorphOp.Tophat, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.BLACKHAT:
CvInvoke.MorphologyEx(image, image, Emgu.CV.CvEnum.MorphOp.Blackhat, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.GRADIENT:
CvInvoke.MorphologyEx(image, image, Emgu.CV.CvEnum.MorphOp.Gradient, kernel, new Point(-1, -1), 1, Emgu.CV.CvEnum.BorderType.Constant, CvInvoke.MorphologyDefaultBorderValue);
break;
case TransformationType.GAUSSIAN3:
CvInvoke.GaussianBlur(image, image, new Size(3, 3), 0);
break;
case TransformationType.GAUSSIAN5:
CvInvoke.GaussianBlur(image, image, new Size(5, 5), 0);
break;
case TransformationType.LAPLACE3:
CvInvoke.Laplacian(image, image, Emgu.CV.CvEnum.DepthType.Cv8U, 3);
break;
case TransformationType.MEAN3:
CvInvoke.Blur(image, image, new Size(3, 3), new Point(-1, -1));
break;
case TransformationType.MEAN5:
CvInvoke.Blur(image, image, new Size(5, 5), new Point(-1, -1));
break;
}
}
public Transform()
{
transformMatrix = new double[4, 4]
{
{ 1, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 1 }
};
transType = TransformationType.Null;
}
public static Transform Translation(Vector3d translationVector)
{
transformMatrix = new double[4, 4]
{
{ 1, 0, 0, translationVector.X },
{ 0, 1, 0, translationVector.Y },
{ 0, 0, 1, translationVector.Z },
{ 0, 0, 0, 1 }
};
transType = TransformationType.Translation;
return(new Transform(transformMatrix));
}
public void StartTransformation(IEnumerator routine, TransformationType type, System.Action onFinished = null)
{
RoutineActivity transformation = null;
bool isTranslation = type.HasFlag(TransformationType.Translate);
bool isRotation = type.HasFlag(TransformationType.Rotate);
bool isScaling = type.HasFlag(TransformationType.Scale);
// For readability: if need better perf, just move to the branches?
if (isTranslation)
{
StopTranslation();
}
if (isRotation)
{
StopRotation();
}
if (isScaling)
{
StopScaling();
}
if (isTranslation)
{
StopTranslation();
transformation = translation;
if (isRotation)
{
rotation = transformation;
}
if (isScaling)
{
scaling = transformation;
}
}
else if (isRotation)
{
transformation = rotation;
if (isScaling)
{
scaling = transformation;
}
}
else
{
transformation = scaling;
}
StartRoutine(routine, transformation, onFinished);
}
public static string Transform(TransformationType type, string sourceXml, string transformXml)
{
switch (type)
{
case TransformationType.Xdt:
return(TransformXdt(sourceXml, transformXml));
case TransformationType.Xslt:
return(TransformXslt(sourceXml, transformXml));
default:
throw new ArgumentException("The transformation type is unknown: " + type.ToString());
}
}
public TransformationUpdateTargetOperation(
string connectionString,
int timeoutSecs,
PublicTable targetTable,
FixupCaches caches,
DataStoreConfiguration configuration,
TransformationType transformationType)
{
_connectionString = connectionString;
_timeoutSecs = timeoutSecs;
_targetTable = targetTable;
_caches = caches;
_configuration = configuration;
_transformationType = transformationType;
}
public static float[] GetTransformation(TransformationType transformationType, float imageDimensionX, float imageDimensionY, float imageDimensionZ, float dx, float dy, float dz)
{
if (transformationType == TransformationType.Rigid)
throw new NotImplementedException();
if (transformationType == TransformationType.Affine)
{
return new[]
{
imageDimensionX, 0,0, dx,
0,imageDimensionY,0, dy,
0,0,imageDimensionZ, dz,
0,0,0,1
};
}
return null;
}
public void StopTransformation(TransformationType type)
{
bool isTranslation = type.HasFlag(TransformationType.Translate);
bool isRotation = type.HasFlag(TransformationType.Rotate);
bool isScaling = type.HasFlag(TransformationType.Scale);
if (isTranslation)
{
StopTranslation();
}
if (isRotation)
{
StopRotation();
}
if (isScaling)
{
StopScaling();
}
}
public QuandlQuery(string databaseCode, string tableCode, FileType formatCode,
string authToken, DateTime? trimStart, DateTime? trimEnd, SortOrder sortOrder,
bool excludeHeader, bool excludeData, int? rows, int? column,
CollapseType frequency, TransformationType calculation)
{
this.DatabaseCode = databaseCode;
this.TableCode = tableCode;
this.FormatCode = formatCode;
this.AuthToken = authToken;
this.TrimStart = trimStart;
this.TrimEnd = trimEnd;
this.SortOrder = sortOrder;
this.ExcludeHeader = excludeHeader;
this.ExcludeData = excludeData;
this.Rows = rows;
this.Column = column;
this.Frequency = frequency;
this.Calculation = calculation;
}
public static float[] GetTransformation(TransformationType transformationType, float imageDimensionX, float imageDimensionY, float imageDimensionZ, float dx, float dy, float dz)
{
if (transformationType == TransformationType.Rigid)
{
throw new NotImplementedException();
}
if (transformationType == TransformationType.Affine)
{
return(new[]
{
imageDimensionX, 0, 0, dx,
0, imageDimensionY, 0, dy,
0, 0, imageDimensionZ, dz,
0, 0, 0, 1
});
}
return(null);
}
public override void LoadEditorPrefs()
{
if (EditorPrefs.HasKey(TRANSFORMATION_TYPE_KEY))
{
transformationType = (TransformationType)EditorPrefs.GetInt(TRANSFORMATION_TYPE_KEY, 0);
}
if (EditorPrefs.HasKey(FRAME_RATE_INDEX_KEY))
{
selectedFrameRateIndex = EditorPrefs.GetInt(FRAME_RATE_INDEX_KEY, 0);
}
if (EditorPrefs.HasKey(FILENAME_KEY))
{
fileName = EditorPrefs.GetString(FILENAME_KEY, "Animation");
}
if (EditorPrefs.HasKey(SAVE_DESTINATION_KEY))
{
animSaveDestination = EditorPrefs.GetString(SAVE_DESTINATION_KEY, "Assets");
absPath = (Application.dataPath).Replace("Assets", animSaveDestination);
}
}
} // Map
protected ASrcAttribute(string sGroupName, string sNodeName, string sTargetDisplayName, string sMap)
{
GroupName = sGroupName;
NodeName = sNodeName;
TargetDisplayName = sTargetDisplayName;
m_sDisplayPrefix = "\n";
m_bIsCompanyScoreModel = true;
m_nTransformation = TransformationType.None;
if (!string.IsNullOrWhiteSpace(sMap))
{
try {
m_oMap = JsonConvert.DeserializeObject <SortedDictionary <string, string> >(sMap);
}
catch (Exception) {
m_oMap = null;
} // try
}
else
{
m_oMap = null;
}
} // constructor
public TransformationEtlProcess(
Table srcTable,
PublicTable targetTable,
FixupCaches caches,
string connectionString,
int timeoutSecs,
DataStoreConfiguration configuration,
TransformationType transformationType,
int srcTimetableId)
{
if (configuration.Pipelines.PublicTransformation.SingleThreaded)
{
PipelineExecuter = new SingleThreadedPipelineExecuter();
}
_srcTable = srcTable;
_targetTable = targetTable;
_caches = caches;
_connectionString = connectionString;
_timeoutSecs = timeoutSecs;
_configuration = configuration;
_transformationType = transformationType;
_srcTimetableId = srcTimetableId;
}
/// <summary>
/// Draw the Window's contents
/// </summary>
protected void OnGUI()
{
if (workingResolution == null)
{
workingResolution = ResolutionData.FromZigResolution(kinectCaptureResolution);
}
float aspectRatio = workingResolution.Width / workingResolution.Height;
float textureWidth = (base.position.width - (UI_SPACING * 3)) / 2;
float textureHeight = textureWidth * aspectRatio;
float newDesiredTilt = desiredTilt;
if (isNUIOn && ZigEditorInput.Instance.ReaderInited)
{
if (viewerType == NUIViewerType.DepthViewer)
{
GUI.DrawTexture(new Rect(UI_SPACING, UI_SPACING, textureWidth, textureHeight), depthViewer.Texture);
}
else if (viewerType == NUIViewerType.ImageViewer)
{
GUI.DrawTexture(new Rect(UI_SPACING, UI_SPACING, textureWidth, textureHeight), imageViewer.Texture);
}
//else if (viewerType == NUIViewerType.DepthAndImageViewer)
//{
// GUI.DrawTexture(new Rect(UI_SPACING, UI_SPACING, textureWidth, textureHeight), mixedViewer.Texture);
//}
if (captureState == RecordingState.PreRecording)
{
int timeLeft = (int)(((delaySeconds * 1000) - stopwatch.ElapsedMilliseconds)/1000) + 1;
GUIStyle countdownFont = new GUIStyle(EditorStyles.label);
countdownFont.fontSize = (int)(textureHeight/6);
countdownFont.normal.textColor = Color.white;
Vector2 size = countdownFont.CalcSize(new GUIContent(timeLeft.ToString()));
GUI.Label(new Rect(textureWidth - (size.x), textureHeight - size.y, size.x, size.y), timeLeft.ToString(), countdownFont);
}
if (captureState == RecordingState.Recording)
{
GUI.DrawTexture(new Rect((textureWidth) - recordingImage.width, (UI_SPACING + textureHeight) - recordingImage.height, recordingImage.width, recordingImage.height), recordingImage);
}
GUI.DrawTexture(new Rect((UI_SPACING * 2) + textureWidth, UI_SPACING, textureWidth, textureHeight), radarLogo);
usersRadar.Render(ZigEditorInput.Instance, new Rect((UI_SPACING * 2) + textureWidth, UI_SPACING, textureWidth, textureHeight));
}
else if (mocapLogo != null && workingResolution != null)
{
// Draw place holders
GUI.DrawTexture(new Rect(UI_SPACING, UI_SPACING, textureWidth, textureHeight), mocapLogo);
GUI.DrawTexture(new Rect((UI_SPACING * 2) + textureWidth, UI_SPACING, textureWidth, textureHeight), radarLogo);
}
float panelHeight = base.position.height - textureHeight - (UI_SPACING * 3);
if (panelHeight > 5)
{
GUILayout.BeginArea(new Rect(UI_SPACING, textureHeight + (UI_SPACING * 2), textureWidth, panelHeight), string.Empty, "box");
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(new GUIContent(DEVICE_TRACKING));
bool toggleOn = false;
Color temp = GUI.color;
if (isNUIOn)
{
GUI.color = Color.green;
toggleOn = GUILayout.Toggle(isNUIOn, ON, EditorStyles.miniButton);
}
else
{
GUI.color = Color.red;
toggleOn = GUILayout.Toggle(isNUIOn, OFF, EditorStyles.miniButton);
}
GUI.color = temp;
EditorGUILayout.EndHorizontal();
if (toggleOn && !isNUIOn)
{
turnOnNUIDevice();
}
else if (!toggleOn && isNUIOn)
{
turnOffNUIDevice();
}
viewerType = (NUIViewerType)EditorGUILayout.EnumPopup(new GUIContent(VIEWER), viewerType);
List<GUIContent> resolutions = new List<GUIContent>();
foreach(string name in Enum.GetNames(typeof(ZigResolution)))
{
resolutions.Add(new GUIContent(name.Replace('_',' ')));
}
kinectCaptureResolution = (ZigResolution)EditorGUILayout.Popup(new GUIContent(KINECT_RESOLUTION), (int)kinectCaptureResolution, resolutions.ToArray());
SmoothingOptions newSmoothingOptions = (SmoothingOptions)EditorGUILayout.EnumPopup(new GUIContent(SMOOTHING_OPTIONS), smoothingOptions);
if (newSmoothingOptions != smoothingOptions)
{
smoothingOptions = newSmoothingOptions;
if (smoothingOptions == SmoothingOptions.None)
{
settings.KinectSDKSpecific.SmoothingParameters.SetNoSmoothing();
}
else if(smoothingOptions == SmoothingOptions.Light)
{
settings.KinectSDKSpecific.SmoothingParameters.SetLightSmoothing();
}
else if (smoothingOptions == SmoothingOptions.Moderate)
{
settings.KinectSDKSpecific.SmoothingParameters.SetModerateSmoothing();
}
else if (smoothingOptions == SmoothingOptions.Heavy)
{
settings.KinectSDKSpecific.SmoothingParameters.Smoothing = 0.6f;
settings.KinectSDKSpecific.SmoothingParameters.Correction = 0.4f;
settings.KinectSDKSpecific.SmoothingParameters.Prediction = 0.6f;
settings.KinectSDKSpecific.SmoothingParameters.JitterRadius = 0.15f;
settings.KinectSDKSpecific.SmoothingParameters.MaxDeviationRadius = 0.10f;
//settings.KinectSDKSpecific.SmoothingParameters.SetHeavySmoothing();
}
ZigEditorInput.Instance.SetSmoothingParameters((smoothingOptions != SmoothingOptions.None), settings.KinectSDKSpecific.SmoothingParameters);
}
viewNodes = EditorGUILayout.Toggle(JOINT_VIEW, viewNodes);
EditorGUI.BeginDisabledGroup(!isNUIOn);
newDesiredTilt = EditorGUILayout.IntSlider(new GUIContent(DEVICE_TILT), (int)desiredTilt, -27, 27);
EditorGUI.EndDisabledGroup();
workingResolution = ResolutionData.FromZigResolution(kinectCaptureResolution);
}
GUILayout.EndArea();
GUILayout.BeginArea(new Rect((UI_SPACING * 2) + textureWidth, textureHeight + (UI_SPACING * 2), textureWidth, panelHeight), String.Empty, "box");
{
fileName = EditorGUILayout.TextField(new GUIContent("Filename"), fileName);
/*
isFilterFoldout = EditorGUILayout.Foldout(isFilterFoldout, new GUIContent("Filters"));
if (isFilterFoldout)
{
EditorGUI.indentLevel = 1;
EditorGUILayout.Toggle(new GUIContent("Smooth"), false);
EditorGUILayout.Toggle(new GUIContent("Mirror"), false);
EditorGUILayout.Toggle(new GUIContent("Correct Sensor Tilt"), false);
EditorGUILayout.Toggle(new GUIContent("Correct Sensor Offset"), false);
EditorGUI.indentLevel = 0;
}
GUILayout.Space(UI_SPACING);*/
//recordingStart = (RecordingStart)EditorGUILayout.EnumPopup(new GUIContent("Start On"), recordingStart);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(new GUIContent("Model Preview"));
if (GUILayout.Button("Generate"))
{
createModelPreview();
}
EditorGUILayout.EndHorizontal();
delaySelection = EditorGUILayout.Popup(new GUIContent("Start Delay"), delaySelection, delays);
isAdvancedExposed = EditorGUILayout.Foldout(isAdvancedExposed, new GUIContent("Advanced"));
if (isAdvancedExposed)
{
transformationType = (TransformationType)EditorGUILayout.EnumPopup(new GUIContent("Transformation Type"), transformationType);
}
GUILayout.Space(UI_SPACING);
EditorGUI.BeginDisabledGroup(!isNUIOn);
if (GUILayout.Button(captureState == RecordingState.NotRecording ? new GUIContent("Record") : new GUIContent("Stop")))
{
if (captureState == RecordingState.NotRecording)
{
BeginPreRecording();
}
else
{
StopRecording();
}
}
EditorGUI.EndDisabledGroup();
}
GUILayout.EndArea();
}
GUI.skin = null;
if (newDesiredTilt != desiredTilt)
{
desiredTilt = newDesiredTilt;
NuiWrapper.NuiCameraElevationSetAngle((long)desiredTilt);
}
}
/// <summary>
/// Sets the transformation type which should be applied prior to download
/// </summary>
/// <param name="calculation">Transformation type which should be applied</param>
/// <returns>The current builder instance</returns>
public QuandlQueryBuilder SetCalculation(TransformationType calculation)
{
this.Calculation = calculation;
return this;
}
Class746 class = new Class746(TransformationType.VectorScale, new Vector2(1f, 1.4f), new Vector2(1f, 1f), Class115.int_1, Class115.int_1 + 300, Enum70.const_0);
Class746 class = new Class746(TransformationType.MovementX, vector2_3.X + 170f, vector2_3.X + 150f, Class115.int_1, Class115.int_1 + 300, Enum70.const_2);
class = new Class746(TransformationType.Fade, 0f, 1f, int_7 - num, int_7 - (int)((double)num * 0.6), Enum70.const_0);
Class746 class = new Class746(TransformationType.Scale, 1.28f, 1.4f, Class115.int_1, Class115.int_1 + 50, Enum70.const_0);
Class746 class = new Class746(TransformationType.Scale, 1f, Class562.smethod_6(1f, Class341.class606_46 ? 2.1f : 2.8f), num, int_, Enum70.const_0);
Class746 class = new Class746(TransformationType.Scale, 1.2f, 1.3f, Class115.int_1, Class115.int_1 + 1000, Enum70.const_2);
Class746 class = new Class746(TransformationType.Scale, 1f, 1.2f, 0, 100, Enum70.const_0);
Class746 class = new Class746(TransformationType.Rotation, 0f, 6.28318548f, Class115.int_1, Class115.int_1 + 1500, Enum70.const_0);
/// <summary>
/// Converts TransformationType to string
/// </summary>
/// <param name="collapseType">Value to be converted</param>
/// <returns>Converted string</returns>
public static string ToString(TransformationType transformationType)
{
return transformationTypes[transformationType];
}