protected override async Task LoadContent()
{
material = new Material();
string vsSource = @"
attribute vec4 aPosition;
attribute vec2 aTexture;
attribute vec4 aColor;
attribute float aSamplerIndex;
uniform mat4 uProjectionMatrix;
varying mediump vec4 vColor;
varying highp vec2 vTextureCoord;
varying mediump float vSamplerIndex;
void main(void) {
gl_Position = uProjectionMatrix * aPosition;
vTextureCoord = aTexture;
vColor = aColor;
vSamplerIndex = aSamplerIndex;
}";
string fsSource = @"
varying highp vec2 vTextureCoord;
varying mediump vec4 vColor;
varying mediump float vSamplerIndex;
uniform sampler2D uSampler0;
uniform sampler2D uSampler1;
uniform sampler2D uSampler2;
uniform sampler2D uSampler3;
uniform sampler2D uSampler4;
uniform sampler2D uSampler5;
uniform sampler2D uSampler6;
uniform sampler2D uSampler7;
uniform sampler2D uSampler8;
uniform sampler2D uSampler9;
void main(void) {
mediump vec4 color;
if(vSamplerIndex > -0.5 && vSamplerIndex < 0.5)
{
color = texture2D(uSampler0, vTextureCoord);
}
if(vSamplerIndex > 0.5 && vSamplerIndex < 1.5)
{
color = texture2D(uSampler1, vTextureCoord);
}
if(vSamplerIndex > 1.5 && vSamplerIndex < 2.5)
{
color = texture2D(uSampler2, vTextureCoord);
}
if(vSamplerIndex > 2.5 && vSamplerIndex < 3.5)
{
color = texture2D(uSampler3, vTextureCoord);
}
if(vSamplerIndex > 3.5 && vSamplerIndex < 4.5)
{
color = texture2D(uSampler4, vTextureCoord);
}
if(vSamplerIndex > 4.5 && vSamplerIndex < 5.5)
{
color = texture2D(uSampler5, vTextureCoord);
}
if(vSamplerIndex > 5.5 && vSamplerIndex < 6.5)
{
color = texture2D(uSampler6, vTextureCoord);
}
if(vSamplerIndex > 6.5 && vSamplerIndex < 7.5)
{
color = texture2D(uSampler7, vTextureCoord);
}
if(vSamplerIndex > 7.5 && vSamplerIndex < 8.5)
{
color = texture2D(uSampler8, vTextureCoord);
}
if(vSamplerIndex > 8.5 && vSamplerIndex < 9.5)
{
color = texture2D(uSampler9, vTextureCoord);
}
gl_FragColor = color * vColor;
}";
var vertexShader = Context.CompileShader(ShaderType.VERTEX_SHADER, vsSource);
var fragmentShader = Context.CompileShader(ShaderType.FRAGMENT_SHADER, fsSource);
material.Program = Context.CreateShaderProgram();
material.Program.Attach(vertexShader);
material.Program.Attach(fragmentShader);
material.Program.Link();
Texture1 = await Context.LoadTextureAsync("res/birb.jpg");
Texture2 = await Context.LoadTextureAsync("res/nyan.png");
material.Textures = new[] { Texture1 };
// material.Int32Uniforms = new Dictionary<string,int>()
// {
// { "uSampler0", 0 },
// { "uSampler1", 1 },
// { "uSampler2", 2 },
// { "uSampler3", 3 },
// { "uSampler4", 4 },
// { "uSampler5", 5 },
// { "uSampler6", 6 },
// { "uSampler7", 7 },
// { "uSampler8", 8 },
// { "uSampler9", 9 }
// };
material.Matrix4Uniforms = new Dictionary <string, Matrix4>()
{
{
"uProjectionMatrix",
Matrix4.Orthogonal(-Context.Width * 0.5f, -Context.Height * 0.5f,
Context.Width * 0.5f, Context.Height * 0.5f, -1, 1)
}
};
drawables = new SpriteDrawable[benchmarkElementCount];
Random random = new Random();
for (int i = 0; i < benchmarkElementCount; i++)
{
drawables[i] = new SpriteDrawable()
{
Color = new Color(1, 1, 1, 1),
Size = new Vector2(100, 100),
SourceRectangle = null,
Texture = Texture1,
Transform = TransformUtils.MakeTransform(
Vector3.Zero,
new Vector3(
(float)random.NextDouble() * Context.Width - Context.Width * 0.5f,
(float)random.NextDouble() * Context.Height - Context.Height * 0.5f,
0
),
new Vector3(0, 0, (float)(random.NextDouble() * Math.PI)),
Vector3.One
)
};
}
SpriteManager = new SpriteManager();
}
public virtual void UpdateTransform()
{
Matrix4F xform = TransformUtils.CalcTransform(this);
SetAttribute(Schema.gameObjectType.transformAttribute, xform.ToArray());
}
private void RenderProperties(IEnumerable <object> objects, bool renderCaption, bool renderBound, bool renderPivot)
{
bool renderAny = renderCaption || renderBound || renderPivot;
if (renderAny == false)
{
return;
}
Util3D.RenderFlag = BasicRendererFlags.WireFrame;
Matrix4F vp = Camera.ViewMatrix * Camera.ProjectionMatrix;
foreach (object obj in objects)
{
IBoundable bnode = obj.As <IBoundable>();
if (bnode == null || bnode.BoundingBox.IsEmpty || obj.Is <IGameObjectFolder>())
{
continue;
}
INameable nnode = obj.As <INameable>();
ITransformable trans = obj.As <ITransformable>();
if (renderBound)
{
Util3D.DrawAABB(bnode.BoundingBox);
}
if (renderCaption && nnode != null)
{
Vec3F topCenter = bnode.BoundingBox.Center;
topCenter.Y = bnode.BoundingBox.Max.Y;
Point pt = Project(vp, topCenter);
GameEngine.DrawText2D(nnode.Name, Util3D.CaptionFont, pt.X, pt.Y, Color.White);
}
}
if (renderPivot)
{
Util3D.RenderFlag = BasicRendererFlags.WireFrame
| BasicRendererFlags.DisableDepthTest;
// create few temp matrics to
Matrix4F toWorld = new Matrix4F();
Matrix4F PV = new Matrix4F();
Matrix4F sc = new Matrix4F();
Matrix4F bl = new Matrix4F();
Matrix4F recXform = new Matrix4F();
foreach (object obj in objects)
{
ITransformable trans = obj.As <ITransformable>();
IBoundable bnode = obj.As <IBoundable>();
if (trans == null || bnode == null || bnode.BoundingBox.IsEmpty || obj.Is <IGameObjectFolder>())
{
continue;
}
Path <DomNode> path = new Path <DomNode>(trans.Cast <DomNode>().GetPath());
toWorld.Set(Vec3F.ZeroVector);
TransformUtils.CalcPathTransform(toWorld, path, path.Count - 1);
// Offset by pivot
PV.Set(trans.Pivot);
toWorld.Mul(PV, toWorld);
Vec3F pos = toWorld.Translation;
float s;
Util.CalcAxisLengths(Camera, pos, out s);
s /= 12.0f;
sc.Scale(s);
Util.CreateBillboard(bl, pos, Camera.WorldEye, Camera.Up, Camera.LookAt);
Matrix4F.Multiply(sc, bl, recXform);
Util3D.DrawPivot(recXform, Color.Yellow);
}
}
}
private void RegenerateLocalToWorldMatrix()
{
_localToWorldMatrix = TransformUtils.GetLocalToWorldMatrix(_position, _rotation, _scale);
}
public static IEnumerator MoveTo(this Transform t, Vector3 to, float duration)
{
return(TransformUtils.MoveTo(t.position, to, duration, (newPosition) => t.position = newPosition));
}
/// <summary>
///
/// </summary>
/// <param name="duct"></param>
/// <param name="point"></param>
/// <param name="damperType"></param>
/// <param name="damperWidth"></param>
/// <param name="damperHeight"></param>
public static void InsertDamper(
Element duct,
Point point,
FamilyType damperType,
string damperWidth = "Duct Width",
string damperHeight = "Duct Height")
{
if (!(duct.InternalElement is Autodesk.Revit.DB.Mechanical.Duct duct1))
{
throw new ArgumentNullException(nameof(duct));
}
if (point == null)
{
throw new ArgumentNullException(nameof(point));
}
if (damperType == null)
{
throw new ArgumentNullException(nameof(damperType));
}
if (!(duct1.Location is Autodesk.Revit.DB.LocationCurve location))
{
throw new ArgumentException("Duct is not curve based.");
}
var doc = duct1.Document;
var xyz = point.ToRevitType();
var curve = location.Curve;
var result = curve.Project(xyz);
var pt = result.XYZPoint;
var symbol = damperType.InternalElement as Autodesk.Revit.DB.FamilySymbol;
TransactionManager.Instance.EnsureInTransaction(doc);
// (Konrad) Create new Damper instance and split duct into two.
var id = Autodesk.Revit.DB.Mechanical.MechanicalUtils.BreakCurve(doc, duct1.Id, pt);
if (!(doc.GetElement(id) is Autodesk.Revit.DB.Mechanical.Duct duct2))
{
throw new ArgumentException("Failed to split Duct.");
}
var fi = doc.Create.NewFamilyInstance(pt, symbol, duct1, Autodesk.Revit.DB.Structure.StructuralType.NonStructural);
doc.Regenerate();
// (Konrad) Rotate Damper.
var start = curve.GetEndPoint(0).ToPoint();
var end = curve.GetEndPoint(1).ToPoint();
var direction = Vector.ByTwoPoints(start, end);
var up = Vector.ZAxis();
var perpendicular = direction.Cross(up);
var cs = CoordinateSystem.ByOriginVectors(pt.ToPoint(), direction, perpendicular);
var transform = cs.ToTransform();
TransformUtils.ExtractEularAnglesFromTransform(transform, out var newRotationAngles);
var rotation = ConvertEularToAngleDegrees(newRotationAngles.FirstOrDefault());
var oldTransform = fi.GetTransform();
TransformUtils.ExtractEularAnglesFromTransform(oldTransform, out var oldRotationAngles);
var newRotationAngle = rotation * Math.PI / 180;
var rotateAngle = newRotationAngle - oldRotationAngles.FirstOrDefault();
var axis = Autodesk.Revit.DB.Line.CreateUnbound(oldTransform.Origin, oldTransform.BasisZ);
Autodesk.Revit.DB.ElementTransformUtils.RotateElement(doc, fi.Id, axis, -rotateAngle);
// (Konrad) Set Damper Width/Height to match Duct.
var sourceWidth = duct1.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.RBS_CURVE_WIDTH_PARAM).AsDouble();
var sourceHeight = duct1.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.RBS_CURVE_HEIGHT_PARAM).AsDouble();
fi.GetParameters(damperWidth).FirstOrDefault()?.Set(sourceWidth);
fi.GetParameters(damperHeight).FirstOrDefault()?.Set(sourceHeight);
// (Konrad) Connect Damper to Ducts.
var c1 = FindClosest(duct1.ConnectorManager.Connectors, xyz); // duct1 endpoint
var c1Other = FindOther(duct1.ConnectorManager.Connectors, c1);
var c1A = FindClosest(fi.MEPModel.ConnectorManager.Connectors, c1Other);
c1.ConnectTo(c1A);
var c2 = FindClosest(duct2.ConnectorManager.Connectors, xyz); // duct2 endpoint
var c2Other = FindOther(duct2.ConnectorManager.Connectors, c2);
var c2A = FindClosest(fi.MEPModel.ConnectorManager.Connectors, c2Other);
c2.ConnectTo(c2A);
TransactionManager.Instance.TransactionTaskDone();
}
/// <summary> /// Appends a centered skew matrix from the give angles in radians. /// </summary> /// <param name="radiansX">The X angle, in radians.</param> /// <param name="radiansY">The Y angle, in radians.</param> /// <returns>The <see cref="AffineTransformBuilder"/>.</returns> public AffineTransformBuilder AppendSkewRadians(float radiansX, float radiansY) => this.Append(size => TransformUtils.CreateSkewMatrixRadians(radiansX, radiansY, size));
private IEnumerable <ITargetGroup> GetAllTargetGroups()
{
return(TransformUtils.GetComponentsInDescendants <TargetGroupBase>(transform, true)
.OfType <ITargetGroup>());
}
private Transform CreatePlatform(int platformNumber, int positionNumber, int moveTime, int col, int row, int startHeight)
{
// Create the platform if it doesn't exist yet.
Transform platform;
if (!Platforms.TryGetValue(platformNumber, out platform))
{
platform = _assetPool.SpawnTransform(Constants.TAG_PLATFORM);
platform.GetComponent <Collider>().material = noFrictionMaterial;
platform.name = CreateUniqueItemName(Constants.TAG_PLATFORM);
var controller = platform.GetComponent <PlatformController>();
controller.Positions = new List <Vector3>();
controller.SecondsToReachTarget = new List <int>();
Platforms[platformNumber] = platform;
}
// Determine where this point falls on the grid.
var pointCoordinates = new Vector3(col, startHeight, row);
var platformDimensions = platform.localScale;
var platformPosition = TransformUtils.GetLocalPositionFromGridCoordinates(pointCoordinates, platformDimensions);
// Add the position to PlatformPositions
List <Vector3> positions;
if (!PlatformPositions.TryGetValue(platformNumber, out positions))
{
positions = new List <Vector3>();
}
while (positionNumber >= positions.Count)
{
positions.Add(Vector3.zero);
}
positions[positionNumber] = platformPosition;
PlatformPositions[platformNumber] = positions;
// Add the move time to PlatformMoveTimes
List <int> moveTimes;
if (!PlatformMoveTimes.TryGetValue(platformNumber, out moveTimes))
{
moveTimes = new List <int>();
}
while (positionNumber >= moveTimes.Count)
{
moveTimes.Add(0);
}
moveTimes[positionNumber] = moveTime;
PlatformMoveTimes[platformNumber] = moveTimes;
// Set the platform start location
if (positionNumber == 0)
{
platform.position = platformPosition;
Platforms[platformNumber] = platform;
}
return(platform);
}
public override VisualElement CreateInspectorGUI()
{
var visualTree = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>("Assets/Editor/CustomTransformInspector.uxml");
root = visualTree.CloneTree();
var styleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>("Assets/Editor/CustomTransformInspector.uss");
root.styleSheets.Add(styleSheet);
Vector3Field localPosField = root.Q <Vector3Field>("Vector3Position");
Vector3Field localRotField = root.Q <Vector3Field>("Vector3Rotation");
Vector3Field localScaleField = root.Q <Vector3Field>("Vector3Scale");
Vector3Field worldPosField = root.Q <Vector3Field>("Vector3WorldPosition");
Vector3Field worldRotField = root.Q <Vector3Field>("Vector3WorldRotation");
Vector3Field worldScaleField = root.Q <Vector3Field>("Vector3WorldScale");
localPosField.value = m_transform.localPosition;
localRotField.value = TransformUtils.GetInspectorRotation(m_transform);
localScaleField.value = m_transform.localScale;
worldPosField.value = m_transform.position;
worldScaleField.value = m_transform.lossyScale;
worldRotField.value = GetWorldRotation();
worldPosField.SetEnabled(false);
worldRotField.SetEnabled(false);
worldScaleField.SetEnabled(false);
localPosField.RegisterValueChangedCallback(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
m_transform.localPosition = localPosField.value;
});
localRotField.RegisterValueChangedCallback(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
TransformUtils.SetInspectorRotation(m_transform, localRotField.value);
});
localScaleField.RegisterValueChangedCallback(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
m_transform.localScale = localScaleField.value;
});
//전체 리셋
root.Q <Button>("LocalReset").RegisterCallback <MouseUpEvent>(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
ResetPositionField(localPosField);
ResetRotationField(localRotField);
ResetScaleField(localScaleField);
});
//개별 리셋
root.Q <Button>("RB").RegisterCallback <MouseUpEvent>(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
ResetPositionField(localPosField);
});
root.Q <Button>("GB").RegisterCallback <MouseUpEvent>(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
ResetRotationField(localRotField);
});
root.Q <Button>("BB").RegisterCallback <MouseUpEvent>(evt =>
{
Undo.RecordObject(m_transform, m_transform.name);
ResetScaleField(localScaleField);
});
// 스케쥴러
var scheduledAction = root.schedule.Execute(() =>
{
localPosField.value = m_transform.localPosition;
localRotField.value = TransformUtils.GetInspectorRotation(m_transform);
localScaleField.value = m_transform.localScale;
worldPosField.value = m_transform.position;
worldScaleField.value = m_transform.lossyScale;
worldRotField.value = GetWorldRotation();
});
scheduledAction.Every(100);
return(root);
}
/// <summary>
/// Computes transformation matrix from transformation related atrributes.</summary>
public void ComputeTransform()
{
Matrix4F xform = TransformUtils.CalcTransform(m_transformable);
SetAttribute(Schema.gameObjectType.transformAttribute, xform.ToArray());
}
protected virtual void OnSceneGUI()
{
TransformController transformController = (TransformController)target;
Vector3 orientationCorrection = new Vector3(0, 0, 0);
switch (transformController.FreeDOF)
{
case 4:
angularLimitHandle.xMin = transformController.LockMin;
angularLimitHandle.xMax = transformController.LockMax;
angularLimitHandle.xRange = new Vector2(-360, 360);
angularLimitHandle.yMotion = 0;
angularLimitHandle.zMotion = 0;
transformController.initialOffset = TransformUtils.GetInspectorRotation(transformController.transform).x;
break;
case 5:
angularLimitHandle.yMin = transformController.LockMin;
angularLimitHandle.yMax = transformController.LockMax;
angularLimitHandle.yRange = new Vector2(-360, 360);
angularLimitHandle.xMotion = 0;
angularLimitHandle.zMotion = 0;
orientationCorrection = new Vector3(0, 90, 0);
transformController.initialOffset = TransformUtils.GetInspectorRotation(transformController.transform).y;
break;
case 6:
angularLimitHandle.zMin = transformController.LockMin;
angularLimitHandle.zMax = transformController.LockMax;
angularLimitHandle.zRange = new Vector2(-360, 360);
angularLimitHandle.xMotion = 0;
angularLimitHandle.yMotion = 0;
orientationCorrection = new Vector3(0, 180, 90);
transformController.initialOffset = TransformUtils.GetInspectorRotation(transformController.transform).z;
break;
default:
// this is just for rotation (hinge) joints, if not one of these then return
return;
}
// set the handle matrix to match the object's position/rotation with a uniform scale
Matrix4x4 handleMatrix = Matrix4x4.TRS(
transformController.transform.position,
transformController.transform.parent.gameObject.transform.rotation * Quaternion.Euler(orientationCorrection),
Vector3.one
);
EditorGUI.BeginChangeCheck();
using (new Handles.DrawingScope(handleMatrix))
{
// maintain a constant screen-space size for the handle's radius based on the origin of the handle matrix
// add 30% to avoid the handle getting lost behind the transform
angularLimitHandle.radius = HandleUtility.GetHandleSize(Vector3.zero) * 1.3f;
// draw the handle
EditorGUI.BeginChangeCheck();
angularLimitHandle.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
// undone/redo
Undo.RecordObject(transformController, "Change transform lock angles");
// update JointController script
float[] validated = new float[2] {
0, 0
};
switch (transformController.FreeDOF)
{
case 4:
validated = LockCheckAngle(angularLimitHandle.xMin, angularLimitHandle.xMax);
break;
case 5:
validated = LockCheckAngle(angularLimitHandle.yMin, angularLimitHandle.yMax);
break;
case 6:
validated = LockCheckAngle(angularLimitHandle.zMin, angularLimitHandle.zMax);
break;
default:
// this is just for rotation (hinge) joints, if not one of these then do nothing
break;
}
transformController.LockMin = validated[0];
transformController.LockMax = validated[1];
}
}
}
private void DrawRotation()
{
GUILayout.BeginHorizontal();
{
bool reset = GUILayout.Button("R", GUILayout.Width(20f));
// Vector3 visible = (serializedObject.targetObject as Transform).localEulerAngles;
Vector3 visible = TransformUtils.GetInspectorRotation(serializedObject.targetObject as Transform);
visible.x = WrapAngle(visible.x);
visible.y = WrapAngle(visible.y);
visible.z = WrapAngle(visible.z);
Axes changed = CheckDifference(mRot);
Axes altered = Axes.None;
GUILayoutOption opt = GUILayout.MinWidth(30f);
if (FloatField("X", ref visible.x, (changed & Axes.X) != 0, false, opt))
{
altered |= Axes.X;
}
if (FloatField("Y", ref visible.y, (changed & Axes.Y) != 0, false, opt))
{
altered |= Axes.Y;
}
if (FloatField("Z", ref visible.z, (changed & Axes.Z) != 0, false, opt))
{
altered |= Axes.Z;
}
if (reset)
{
mRot.quaternionValue = Quaternion.identity;
}
else if (altered != Axes.None)
{
RegisterUndo("Change Rotation", serializedObject.targetObjects);
foreach (Object obj in serializedObject.targetObjects)
{
Transform t = obj as Transform;
//Vector3 v = t.localEulerAngles;
Vector3 v = TransformUtils.GetInspectorRotation(t);
if ((altered & Axes.X) != 0)
{
v.x = visible.x;
}
if ((altered & Axes.Y) != 0)
{
v.y = visible.y;
}
if ((altered & Axes.Z) != 0)
{
v.z = visible.z;
}
//t.localEulerAngles = v;
TransformUtils.SetInspectorRotation(t, v);
}
}
}
GUILayout.EndHorizontal();
}
protected override void OnPreviewSettingGUI()
{
_showTargetSetting = EditorGUILayout.Foldout(_showTargetSetting, "Target");
if (_showTargetSetting)
{
EditorGUI.indentLevel++;
Transform targetTF = TransformUtils.GetTransformByPath(_tht.targetPath);
Transform newTargetTF = EditorGUILayout.ObjectField(new GUIContent("Target in Scene", "The target transform in current scene, this will be converted and saved as path string."), targetTF, typeof(Transform), true) as Transform;
string targetPath = newTargetTF.ToPath();
if (targetTF == null && !string.IsNullOrEmpty(_tht.targetPath))
{
GUI.contentColor = Color.red;
}
string customTargetPath = EditorGUILayout.TextField(new GUIContent(string.IsNullOrEmpty(_tht.targetPath) ? "Enter Manually" : (targetTF == null ? "Not Found" : " "), "Manually set the target path, use this for dynamically-loaded prefab."), _tht.targetPath);
if (customTargetPath != _tht.targetPath)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Custom Target Path");
_tht.targetPath = customTargetPath;
targetPath = customTargetPath;
}
if (targetTF == null && !string.IsNullOrEmpty(_tht.targetPath))
{
GUI.contentColor = Color.white;
}
if ((string.IsNullOrEmpty(_tht.targetPath) || newTargetTF != null) && targetPath != _tht.targetPath)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Target Path");
_tht.targetPath = targetPath;
}
if (!string.IsNullOrEmpty(_tht.targetPath))
{
bool skipIfTargetInactive = EditorGUILayout.Toggle(new GUIContent("Skip If Target Inactive", "Mark this task complete if finding the target inactive."), _tht.skipIfTargetInactive);
if (skipIfTargetInactive != _tht.skipIfTargetInactive)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Skip If Target Inactive");
_tht.skipIfTargetInactive = skipIfTargetInactive;
}
bool cloneTarget = EditorGUILayout.Toggle(new GUIContent("Clone Target", "Clone a target and keep it in original place, use this on scroll slot etc."), _tht.cloneTarget);
if (cloneTarget != _tht.cloneTarget)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Clone Target");
_tht.cloneTarget = cloneTarget;
}
if (cloneTarget)
{
bool targetFollowCloneOnUpdate = EditorGUILayout.Toggle(new GUIContent("Target Follow Clone On Update", "Target follows the clone in update, use this on scroll slot etc."), _tht.targetFollowCloneOnUpdate);
if (targetFollowCloneOnUpdate != _tht.targetFollowCloneOnUpdate)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Target Follow Clone On Update");
_tht.targetFollowCloneOnUpdate = targetFollowCloneOnUpdate;
}
bool targetCanCatchRaycast = EditorGUILayout.Toggle(new GUIContent("Target Catch Raycast", "Toggle the target raycast, use this if you want tto turn on/off the target's interaction."), _tht.targetCanCatchRaycast);
if (targetCanCatchRaycast != _tht.targetCanCatchRaycast)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Target Can Catch Raycast");
_tht.targetCanCatchRaycast = targetCanCatchRaycast;
}
bool putCloneToTutorialPanelInstead = EditorGUILayout.Toggle(new GUIContent("Put Clone To Tutorial Panel Instead", "By default, put original target to tutorial panel, turn this on if you want the opposite."), _tht.putCloneToTutorialPanelInstead);
if (putCloneToTutorialPanelInstead != _tht.putCloneToTutorialPanelInstead)
{
EditorUtility.SetDirty(_tht);
Undo.RegisterCompleteObjectUndo(_tht, "Reassign Put Clone To Tutorial Panel Instead");
_tht.putCloneToTutorialPanelInstead = putCloneToTutorialPanelInstead;
}
}
}
EditorGUI.indentLevel--;
}
base.OnPreviewSettingGUI();
}
public void CappingModeNoneWithConcaveSection()
{
var sketch1 = Sketch.Create();
sketch1.Points.Add(0, new Pnt2d(-13.889948477751762, 14.273648711943792));
sketch1.Points.Add(1, new Pnt2d(-0.076740046838405171, 23.6359344262295));
sketch1.Points.Add(2, new Pnt2d(15.424749414519905, 21.180252927400467));
sketch1.Points.Add(3, new Pnt2d(21.870913348946136, 6.1392037470725977));
sketch1.Points.Add(4, new Pnt2d(9.8227259953161585, -8.978585480093674));
sketch1.Points.Add(5, new Pnt2d(-10.513386416861826, -4.8346229508196732));
sketch1.Segments.Add(0, new SketchSegmentLine(0, 1));
sketch1.Segments.Add(1, new SketchSegmentLine(1, 2));
sketch1.Segments.Add(2, new SketchSegmentLine(2, 3));
sketch1.Segments.Add(3, new SketchSegmentLine(3, 4));
sketch1.Segments.Add(4, new SketchSegmentLine(4, 5));
sketch1.Segments.Add(5, new SketchSegmentLine(5, 0));
Assume.That(sketch1.Make(Shape.MakeFlags.None));
var body1 = Body.Create(sketch1);
var sketch2 = Sketch.Create();
sketch2.Points.Add(0, new Pnt2d(-9.8227259953161639, 20.627724590163936));
sketch2.Points.Add(1, new Pnt2d(5.4024992974238826, 18.785963466042151));
sketch2.Points.Add(2, new Pnt2d(19.154315690866518, 24.679599063231855));
sketch2.Points.Add(3, new Pnt2d(26.766928337236532, 2.5784655737704947));
sketch2.Points.Add(4, new Pnt2d(9.2088056206089064, -2.4556814988290427));
sketch2.Points.Add(5, new Pnt2d(-14.12016861826698, -10.43664637002342));
sketch2.Segments.Add(0, new SketchSegmentLine(0, 1));
sketch2.Segments.Add(1, new SketchSegmentLine(1, 2));
sketch2.Segments.Add(2, new SketchSegmentLine(2, 3));
sketch2.Segments.Add(3, new SketchSegmentLine(3, 4));
sketch2.Segments.Add(4, new SketchSegmentLine(4, 5));
sketch2.Segments.Add(5, new SketchSegmentLine(5, 0));
Assume.That(sketch2.Make(Shape.MakeFlags.None));
var body2 = Body.Create(sketch2);
TransformUtils.Translate(body2, new Vec(0, 0, 20.0));
var sketch3 = Sketch.Create();
sketch3.Points.Add(0, new Pnt2d(-17.803690866510539, 3.560738173302112));
sketch3.Points.Add(1, new Pnt2d(-19.522667915690871, 23.574542388758786));
sketch3.Points.Add(2, new Pnt2d(6.7531241217798614, 28.854257611241216));
sketch3.Points.Add(3, new Pnt2d(30.573234660421541, 23.697326463700239));
sketch3.Points.Add(4, new Pnt2d(33.642836533957841, 0.24556814988290426));
sketch3.Points.Add(5, new Pnt2d(6.9986922716627582, 19.522667915690867));
sketch3.Segments.Add(0, new SketchSegmentLine(0, 1));
sketch3.Segments.Add(1, new SketchSegmentLine(1, 2));
sketch3.Segments.Add(2, new SketchSegmentLine(2, 3));
sketch3.Segments.Add(3, new SketchSegmentLine(3, 4));
sketch3.Segments.Add(4, new SketchSegmentLine(4, 5));
sketch3.Segments.Add(5, new SketchSegmentLine(5, 0));
Assume.That(sketch3.Make(Shape.MakeFlags.None));
var body3 = Body.Create(sketch3);
TransformUtils.Translate(body3, new Vec(0, 0, 40.0));
var loft = Loft.Create(body1, new[] { new BodyShapeOperand(body2), new BodyShapeOperand(body3) });
loft.StartCapping = Loft.CappingMode.None;
loft.EndCapping = Loft.CappingMode.None;
loft.ThickenDirection = Loft.Direction.Inwards;
Assert.IsTrue(loft.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(loft, Path.Combine(_BasePath, "CappingModeNoneWithConcaveSectionIn"));
loft.ThickenDirection = Loft.Direction.Outwards;
Assert.IsTrue(loft.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(loft, Path.Combine(_BasePath, "CappingModeNoneWithConcaveSectionOut"));
}
/// <summary>
/// Defines the rotation elements in the inspector.
/// </summary>
private void RotationInspector()
{
// Rotation Label - Adjusts to whether or not the inspector is in wide mode
if (EditorGUIUtility.wideMode)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Rotation", GUILayout.MinWidth(90), GUILayout.ExpandHeight(false));
}
else
{
GUILayout.Label("Rotation", GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
}
// Making the RotationVector3 Boxes in thier colours
EditorGUIUtility.labelWidth = 15;
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
// Hotfix 2 - try to stop the 90/270 issue
Vector3 _newRot = TransformUtils.GetInspectorRotation(_t);
if (EditorPrefs.GetBool("CarterGames-TransformColours-Use2D"))
{
//// Rotation X - Red
GUI.backgroundColor = _hidden;
_newRot.x = EditorGUILayout.FloatField(new GUIContent("X"), _newRot.x, GUILayout.Width(70), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
//// Rotation Y - Green
_newRot.y = EditorGUILayout.FloatField(new GUIContent("Y"), _newRot.y, GUILayout.Width(70), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
GUI.backgroundColor = Color.white;
//// Rotation Z - Blue
GUI.backgroundColor = Color.blue;
_newRot.z = EditorGUILayout.FloatField(new GUIContent("Z"), _newRot.z, GUILayout.Width(70), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
GUI.backgroundColor = Color.white;
}
else
{
//// Rotation X - Red
GUI.backgroundColor = Color.red;
_newRot.x = EditorGUILayout.FloatField(new GUIContent("X"), _newRot.x, GUILayout.Width(70), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
GUI.backgroundColor = Color.white;
//// Rotation Y - Green
GUI.backgroundColor = Color.green;
_newRot.y = EditorGUILayout.FloatField(new GUIContent("Y"), _newRot.y, GUILayout.Width(70), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
GUI.backgroundColor = Color.white;
//// Rotation Z - Blue
GUI.backgroundColor = Color.blue;
_newRot.z = EditorGUILayout.FloatField(new GUIContent("Z"), _newRot.z, GUILayout.Width(70), GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false));
GUI.backgroundColor = Color.white;
}
EditorGUILayout.EndHorizontal();
// Hotfix 2 - try to stop the 90/270 issue
TransformUtils.SetInspectorRotation(_t, _newRot);
// Runs if a edit was made to one of the fields above
if (EditorGUI.EndChangeCheck())
{
_rotChange = true;
}
// Adjusts the editor Hoz grouping so the label shows above the boxes if the inspector is not in wide mode
if (EditorGUIUtility.wideMode)
{
EditorGUILayout.EndHorizontal();
}
}
public static async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req, FunctionContext executionContext)
{
var log = executionContext.GetLogger("SubmitEncodingJob");
log.LogInformation("C# HTTP trigger function processed a request.");
// Get request body data.
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var data = (RequestBodyModel)JsonConvert.DeserializeObject(requestBody, typeof(RequestBodyModel));
// Return bad request if input asset name is not passed in
if (data.InputAssetName == null && data.InputUrl == null)
{
return(HttpRequest.ResponseBadRequest(req, "Please pass inputAssetName or inputUrl in the request body"));
}
// Return bad request if input asset name is not passed in
if (data.TransformName == null)
{
return(HttpRequest.ResponseBadRequest(req, "Please pass transformName in the request body"));
}
ConfigWrapper config = ConfigUtils.GetConfig();
IAzureMediaServicesClient client;
try
{
client = await Authentication.CreateMediaServicesClientAsync(config, log);
log.LogInformation("AMS Client created.");
}
catch (Exception e)
{
if (e.Source.Contains("ActiveDirectory"))
{
log.LogError("TIP: Make sure that you have filled out the appsettings.json file before running this sample.");
}
log.LogError($"{e.Message}");
return(HttpRequest.ResponseBadRequest(req, e.Message));
}
// Set the polling interval for long running operations to 2 seconds.
// The default value is 30 seconds for the .NET client SDK
client.LongRunningOperationRetryTimeout = 2;
// Creating a unique suffix so that we don't have name collisions if you run the sample
// multiple times without cleaning up.
string uniqueness = Guid.NewGuid().ToString().Substring(0, 13);
string jobName = $"job-{uniqueness}";
string outputAssetName = $"output-{uniqueness}";
Transform transform;
try
{
// Ensure that you have the encoding Transform. This is really a one time setup operation.
transform = await TransformUtils.CreateEncodingTransform(client, log, config.ResourceGroup, config.AccountName, data.TransformName, data.BuiltInPreset);
log.LogInformation("Transform retrieved.");
}
catch (Exception e)
{
log.LogError("Error when creating/getting the transform.");
log.LogError($"{e.Message}");
return(HttpRequest.ResponseBadRequest(req, e.Message));
}
Asset outputAsset;
try
{
// Output from the job must be written to an Asset, so let's create one
outputAsset = await AssetUtils.CreateAssetAsync(client, log, config.ResourceGroup, config.AccountName, outputAssetName, data.OutputAssetStorageAccount);
log.LogInformation($"Output asset '{outputAssetName}' created.");
}
catch (Exception e)
{
log.LogError("Error when creating the output asset.");
log.LogError($"{e.Message}");
return(HttpRequest.ResponseBadRequest(req, e.Message));
}
// Job input prepration : asset or url
JobInput jobInput;
if (data.InputUrl != null)
{
jobInput = new JobInputHttp(files: new[] { data.InputUrl });
log.LogInformation("Input is a Url.");
}
else
{
jobInput = new JobInputAsset(assetName: data.InputAssetName);
log.LogInformation($"Input is asset '{data.InputAssetName}'.");
}
Job job;
try
{
// Job submission to Azure Media Services
job = await JobUtils.SubmitJobAsync(
client,
log,
config.ResourceGroup,
config.AccountName,
data.TransformName,
jobName,
jobInput,
outputAssetName
);
log.LogInformation($"Job '{jobName}' submitted.");
}
catch (Exception e)
{
log.LogError("Error when submitting the job.");
log.LogError($"{e.Message}");
return(HttpRequest.ResponseBadRequest(req, e.Message));
}
AnswerBodyModel dataOk = new()
{
OutputAssetName = outputAsset.Name,
JobName = job.Name
};
return(HttpRequest.ResponseOk(req, dataOk));
}
}
public static async Task <HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req, FunctionContext executionContext)
{
var log = executionContext.GetLogger("SubmitSubclipJob");
log.LogInformation("C# HTTP trigger function processed a request.");
string triggerStart = DateTime.UtcNow.ToString("yyMMddHHmmss");
// Get request body data.
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var data = (RequestBodyModel)JsonConvert.DeserializeObject(requestBody, typeof(RequestBodyModel));
// Return bad request if input asset name is not passed in
if (data.LiveEventName == null || data.LiveOutputName == null)
{
return(HttpRequest.ResponseBadRequest(req, "Please pass liveEventName and liveOutputName in the request body"));
}
data.IntervalSec ??= 60;
ConfigWrapper config = ConfigUtils.GetConfig();
IAzureMediaServicesClient client;
try
{
client = await Authentication.CreateMediaServicesClientAsync(config);
}
catch (Exception e)
{
if (e.Source.Contains("ActiveDirectory"))
{
log.LogError("TIP: Make sure that you have filled out the appsettings.json file before running this sample.");
}
log.LogError($"{e.Message}");
return(HttpRequest.ResponseBadRequest(req, e.Message));
}
// Set the polling interval for long running operations to 2 seconds.
// The default value is 30 seconds for the .NET client SDK
client.LongRunningOperationRetryTimeout = 2;
try
{
// Ensure that you have customized encoding Transform. This is really a one time setup operation.
Transform transform = await TransformUtils.GetOrCreateSubclipTransform(client, log, config.ResourceGroup, config.AccountName, SubclipTransformName);
}
catch (ErrorResponseException ex)
{
return(HttpRequest.ResponseBadRequest(req, LogUtils.LogError(log, ex, "Error when getting or creating the transform.")));
}
var liveOutput = await client.LiveOutputs.GetAsync(config.ResourceGroup, config.AccountName, data.LiveEventName, data.LiveOutputName);
// let's analyze the client manifest and adjust times for the subclip job
var doc = await LiveManifest.TryToGetClientManifestContentAsABlobAsync(client, config.ResourceGroup, config.AccountName, liveOutput.AssetName);
var assetmanifestdata = LiveManifest.GetManifestTimingData(doc);
if (assetmanifestdata.Error)
{
return(HttpRequest.ResponseBadRequest(req, "Data cannot be read from live output / asset manifest."));
}
log.LogInformation("Timestamps : " + string.Join(",", assetmanifestdata.TimestampList.Select(n => n.ToString()).ToArray()));
var livetime = TimeSpan.FromSeconds(assetmanifestdata.TimestampEndLastChunk / (double)assetmanifestdata.TimeScale);
log.LogInformation($"Livetime : {livetime}");
var starttime = LiveManifest.ReturnTimeSpanOnGOP(assetmanifestdata, livetime.Subtract(TimeSpan.FromSeconds((int)data.IntervalSec)));
log.LogInformation($"Value starttime : {starttime}");
if (data.LastSubclipEndTime != null)
{
var lastEndTime = (TimeSpan)data.LastSubclipEndTime;
log.LogInformation($"Value lastEndTime : {lastEndTime}");
var delta = (livetime - lastEndTime - TimeSpan.FromSeconds((int)data.IntervalSec)).Duration();
log.LogInformation($"Delta: {delta}");
if (delta < (TimeSpan.FromSeconds(3 * (int)data.IntervalSec))) // less than 3 times the normal duration (3*60s)
{
starttime = lastEndTime;
log.LogInformation($"Value new starttime : {starttime}");
}
}
var duration = livetime - starttime;
log.LogInformation($"Value duration: {duration}");
if (duration == new TimeSpan(0)) // Duration is zero, this may happen sometimes !
{
return(HttpRequest.ResponseBadRequest(req, "Stopping. Duration of subclip is zero."));
}
Asset outputAsset;
try
{
// Output from the Job must be written to an Asset, so let's create one
outputAsset = await AssetUtils.CreateAssetAsync(client, log, config.ResourceGroup, config.AccountName, liveOutput.Name + "-subclip-" + triggerStart, data.OutputAssetStorageAccount);
}
catch (ErrorResponseException ex)
{
return(HttpRequest.ResponseBadRequest(req, LogUtils.LogError(log, ex, "Error when creating the output asset.")));
}
JobInput jobInput = new JobInputAsset(
assetName: liveOutput.AssetName,
start: new AbsoluteClipTime(starttime.Subtract(TimeSpan.FromMilliseconds(100))),
end: new AbsoluteClipTime(livetime.Add(TimeSpan.FromMilliseconds(100)))
);
Job job;
try
{
job = await JobUtils.SubmitJobAsync(
client,
log,
config.ResourceGroup,
config.AccountName,
SubclipTransformName,
$"Subclip-{liveOutput.Name}-{triggerStart}",
jobInput,
outputAsset.Name
);
}
catch (ErrorResponseException ex)
{
return(HttpRequest.ResponseBadRequest(req, LogUtils.LogError(log, ex, "Error when submitting the job.")));
}
AnswerBodyModel dataOk = new()
{
SubclipAssetName = outputAsset.Name,
SubclipJobName = job.Name,
SubclipTransformName = SubclipTransformName,
SubclipEndTime = starttime + duration
};
return(HttpRequest.ResponseOk(req, dataOk, HttpStatusCode.Accepted));
}
}
/// <summary> /// Appends a centered skew matrix from the give angles in degrees. /// </summary> /// <param name="degreesX">The X angle, in degrees.</param> /// <param name="degreesY">The Y angle, in degrees.</param> /// <returns>The <see cref="AffineTransformBuilder"/>.</returns> public AffineTransformBuilder AppendSkewDegrees(float degreesX, float degreesY) => this.Append(size => TransformUtils.CreateSkewMatrixDegrees(degreesX, degreesY, size));
/// <summary> /// Appends a centered skew matrix from the give angles in radians. /// </summary> /// <param name="radiansX">The X angle, in radians.</param> /// <param name="radiansY">The Y angle, in radians.</param> /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns> public ProjectiveTransformBuilder AppendSkewRadians(float radiansX, float radiansY) => this.Append(size => new Matrix4x4(TransformUtils.CreateSkewMatrixRadians(radiansX, radiansY, size)));
/// <summary> /// Appends a rotation matrix using the given rotation angle in radians /// and the image center point as rotation center. /// </summary> /// <param name="radians">The amount of rotation, in radians.</param> /// <returns>The <see cref="AffineTransformBuilder"/>.</returns> public AffineTransformBuilder AppendRotationRadians(float radians) => this.Append(size => TransformUtils.CreateRotationMatrixRadians(radians, size));
/// <summary> /// Appends a matrix that performs a tapering projective transform. /// </summary> /// <param name="side">An enumeration that indicates the side of the rectangle that tapers.</param> /// <param name="corner">An enumeration that indicates on which corners to taper the rectangle.</param> /// <param name="fraction">The amount to taper.</param> /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns> public ProjectiveTransformBuilder AppendTaper(TaperSide side, TaperCorner corner, float fraction) => this.Append(size => TransformUtils.CreateTaperMatrix(size, side, corner, fraction));
public override bool Init()
{
if (string.IsNullOrEmpty(targetPath))
{
Debug.LogErrorFormat("{0}:{1}:Init - Target path not set", name, GetType());
return(false);
}
Transform targetTF = TransformUtils.GetTransformByPath(targetPath);
if (targetTF == null)
{
Debug.LogErrorFormat("{0}:{1}:Init - Target transform not found, targetPath={2}", name, GetType(), targetPath);
return(false);
}
if (string.IsNullOrEmpty(targetComponentName))
{
Debug.LogErrorFormat("{0}:{1}:Init - Target component not set", name, GetType());
return(false);
}
System.Type targetComponentType = System.Type.GetType(targetComponentName);
if (targetComponentType == null)
{
Debug.LogErrorFormat("{0}:{1}:Init - Target component type not found, targetComponentName={2}", name, GetType(), targetComponentName);
return(false);
}
Component targetC = targetTF.GetComponent(targetComponentName) as Component;
if (targetC == null)
{
Debug.LogErrorFormat("{0}:{1}:Init - Target component not found, targetComponentType={2}", name, GetType(), targetComponentType);
return(false);
}
UnityAction handler = DoComplete;
if (string.IsNullOrEmpty(fieldName))
{
try {
EventInfo ei = targetComponentType.GetEvent(eventName, BindingFlags.Public | BindingFlags.Instance);
ei.AddEventHandler(targetC, handler);
} catch {
Debug.LogWarningFormat("{0}:{1}:Init - Action not found, targetC={2}, actionName={3}", name, GetType(), targetC, eventName);
return(false);
}
}
else
{
object obj;
try {
obj = (object)targetComponentType.GetField(fieldName, BindingFlags.Public | BindingFlags.Instance).GetValue(targetC);
} catch {
Debug.LogWarningFormat("{0}:{1}:Init - Target field not found, targetC={2}, fieldName={3}", name, GetType(), targetC, fieldName);
return(false);
}
try {
EventInfo ei = obj.GetType().GetEvent(eventName, BindingFlags.Public | BindingFlags.Instance);
ei.AddEventHandler(obj, handler);
} catch {
Debug.LogWarningFormat("{0}:{1}:Init - Event not found, targetC={2}, obj={3}, eventName={4}", name, GetType(), targetC, obj, eventName);
return(false);
}
}
return(true);
}
/// <summary> /// Appends a centered rotation matrix using the given rotation in radians. /// </summary> /// <param name="radians">The amount of rotation, in radians.</param> /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns> public ProjectiveTransformBuilder AppendRotationRadians(float radians) => this.Append(size => new Matrix4x4(TransformUtils.CreateRotationMatrixRadians(radians, size)));
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_hitRegion == HitRegion.None || m_activeOp == null || m_activeOp.NodeList.Count == 0)
{
return;
}
// create ray in view space.
Ray3F rayV = vc.GetWorldRay(scrPt);
using (var intersectionScene = GameEngine.GetEditorSceneManager().GetIntersectionScene())
{
PickResult intersectionPt;
if (!CalculateTerrainIntersection(vc, rayV, intersectionScene, out intersectionPt))
{
return;
}
if (m_pendingStartPt)
{
m_startPt = intersectionPt._pt.Value;
m_pendingStartPt = false;
}
else
{
ISnapSettings snapSettings = (ISnapSettings)DesignView;
bool clampToSurface = Control.ModifierKeys == Keys.Shift;
var pt = intersectionPt._pt.Value;
Vec3F translate = new Vec3F(pt.X - m_startPt.X, pt.Y - m_startPt.Y, 0.0f);
for (int i = 0; i < m_activeOp.NodeList.Count; i++)
{
ITransformable node = m_activeOp.NodeList[i];
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
Vec3F newWorldPos = m_originalTranslations[i] + translate;
float terrainHeight = 0.0f;
GUILayer.Vector3 terrainNormal;
if (GUILayer.EditorInterfaceUtils.GetTerrainHeightAndNormal(
out terrainHeight, out terrainNormal,
intersectionScene, newWorldPos.X, newWorldPos.Y))
{
newWorldPos.Z = terrainHeight + (clampToSurface ? 0.0f : m_originalHeights[i]);
Vec3F localTranslation;
parentWorldToLocal.TransformVector(newWorldPos, out localTranslation);
node.Translation = localTranslation;
// There are two ways to orient the "up" vector of the object.
// One way is to decompose the 3x3 rotation matrix into a up vector + a rotation around
// that vector. Then we retain the rotation, and just move the up vector.
// Another way is to take the 3x3 matrix, and adjust it's up vector. Then just perform
// the Gram–Schmidt algorithm to re-orthogonalize it.
// We'll use the code from the SCEE level editor. This isn't the ideal math (there's a
// lot of room for floating point creep) but it should work.
var currentUp = node.Transform.ZAxis;
if (snapSettings.TerrainAlignment == TerrainAlignmentMode.TerrainUp)
{
node.Rotation = TransformUtils.RotateToVector(
node.Rotation, new Vec3F(terrainNormal.X, terrainNormal.Y, terrainNormal.Z),
AxisSystemType.ZIsUp);
}
else
if (snapSettings.TerrainAlignment == TerrainAlignmentMode.WorldUp)
{
// Prevent the change if the normal is already very close to straight up
if (Math.Abs(currentUp.X - 0.0f) > 1e-4f || Math.Abs(currentUp.Y - 0.0f) > 1e-4f || Math.Abs(currentUp.Z - 1.0f) > 1e-4f)
{
node.Rotation = TransformUtils.RotateToVector(
node.Rotation, new Vec3F(0.0f, 0.0f, 1.0f),
AxisSystemType.ZIsUp);
}
}
node.UpdateTransform();
}
}
}
}
}
public override void OnBeginDrag()
{
if (m_hitRegion == HitRegion.None)
{
return;
}
var selection = DesignView.Context.As <ISelectionContext>().Selection;
var transactionContext = DesignView.Context.As <ITransactionContext>();
NodeList.Clear();
m_isUniformScaling = false;
IEnumerable <DomNode> rootDomNodes = DomNode.GetRoots(selection.AsIEnumerable <DomNode>());
foreach (DomNode node in rootDomNodes)
{
ITransformable transNode = node.As <ITransformable>();
if (transNode == null || (transNode.TransformationType & TransformationTypes.Scale) == 0)
{
continue;
}
IVisible vn = node.As <IVisible>();
if (!vn.Visible)
{
continue;
}
ILockable lockable = node.As <ILockable>();
if (lockable.IsLocked)
{
continue;
}
// force uniform scaling if any node requires it
if ((transNode.TransformationType & TransformationTypes.UniformScale) == TransformationTypes.UniformScale)
{
m_isUniformScaling = true;
}
NodeList.Add(transNode);
IManipulatorNotify notifier = transNode.As <IManipulatorNotify>();
if (notifier != null)
{
notifier.OnBeginDrag();
}
}
// to compute offset use bounding box in local space.
Vec3F offset = Vec3F.ZeroVector;// 0.5f; // use bounding box in local space
switch (m_hitRegion)
{
case HitRegion.XAxis:
case HitRegion.YAxis:
case HitRegion.ZAxis:
offset = new Vec3F(-1, -1, -1);
break;
case HitRegion.NegXAxis:
case HitRegion.NegYAxis:
case HitRegion.NegZAxis:
offset = new Vec3F(1, 1, 1);
break;
default:
break;
}
m_originalScales = new Vec3F[NodeList.Count];
m_originalTranslations = new Vec3F[NodeList.Count];
m_pivotOffset = new Vec3F[NodeList.Count];
int k = 0;
foreach (ITransformable node in NodeList)
{
IBoundable boundable = node.As <IBoundable>();
Vec3F pivot = Vec3F.Mul(boundable.LocalBoundingBox.Radius, offset);
m_pivotOffset[k] = pivot;
m_originalScales[k] = node.Scale;
Matrix4F mtrx = TransformUtils.CalcTransform(
Vec3F.ZeroVector,
node.Rotation,
node.Scale,
pivot
);
m_originalTranslations[k] = node.Translation - mtrx.Translation;
k++;
}
if (NodeList.Count > 0)
{
transactionContext.Begin("Extend".Localize());
}
}
public Vector3 GetGridNodeIndex(Vector3 worldPoint)
{
Vector3 localSpacePoint = VoxelContainer.InverseTransformPoint(worldPoint);
return(TransformUtils.SnapToGrid(localSpacePoint, snapToForGridSize, inverseSnapToForGrid) * inverseSnapToForGrid);
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_hitRegion == HitRegion.None || NodeList.Count == 0)
{
return;
}
Matrix4F view = vc.Camera.ViewMatrix;
// compute world * view
Matrix4F wv = new Matrix4F();
wv.Mul(HitMatrix, view);
// create ray in view space.
Ray3F rayV = vc.GetRay(scrPt, vc.Camera.ProjectionMatrix);
Vec3F xAxis = wv.XAxis;
Vec3F yAxis = wv.YAxis;
Vec3F zAxis = wv.ZAxis;
Vec3F origin = wv.Translation;
m_scale = new Vec3F(1, 1, 1);
float scale = 1;
float a1, a2;
switch (m_hitRegion)
{
case HitRegion.XAxis:
case HitRegion.NegXAxis:
{
a1 = Math.Abs(Vec3F.Dot(HitRayV.Direction, yAxis));
a2 = Math.Abs(Vec3F.Dot(HitRayV.Direction, zAxis));
Vec3F axis = (a1 > a2 ? yAxis : zAxis);
Vec3F p0 = HitRayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = rayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot((p1 - p0), xAxis);
if (m_hitRegion == HitRegion.NegXAxis)
{
dragAmount *= -1;
}
m_scale.X = 1.0f + dragAmount / m_hitScale;
scale = m_scale.X;
}
break;
case HitRegion.YAxis:
case HitRegion.NegYAxis:
{
a1 = Math.Abs(Vec3F.Dot(HitRayV.Direction, zAxis));
a2 = Math.Abs(Vec3F.Dot(HitRayV.Direction, xAxis));
Vec3F axis = (a1 > a2 ? zAxis : xAxis);
Vec3F p0 = HitRayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = rayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot((p1 - p0), yAxis);
if (m_hitRegion == HitRegion.NegYAxis)
{
dragAmount *= -1;
}
m_scale.Y = 1.0f + dragAmount / m_hitScale;
scale = m_scale.Y;
}
break;
case HitRegion.ZAxis:
case HitRegion.NegZAxis:
{
a1 = Math.Abs(Vec3F.Dot(HitRayV.Direction, xAxis));
a2 = Math.Abs(Vec3F.Dot(HitRayV.Direction, yAxis));
Vec3F axis = (a1 > a2 ? xAxis : yAxis);
Vec3F p0 = HitRayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
Vec3F p1 = rayV.IntersectPlane(axis, -Vec3F.Dot(axis, origin));
float dragAmount = Vec3F.Dot((p1 - p0), zAxis);
if (m_hitRegion == HitRegion.NegZAxis)
{
dragAmount *= -1;
}
m_scale.Z = 1.0f + dragAmount / m_hitScale;
scale = m_scale.Z;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if (m_isUniformScaling)
{
m_scale = new Vec3F(scale, scale, scale);
}
// scale
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
node.Scale = Vec3F.Mul(m_originalScales[i], m_scale);
Matrix4F mtrx = TransformUtils.CalcTransform(
Vec3F.ZeroVector,
node.Rotation,
node.Scale,
m_pivotOffset[i]);
node.Translation = m_originalTranslations[i] + mtrx.Translation;
}
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_cancelDrag || m_hitRegion == HitRegion.None || m_activeOp == null || m_activeOp.NodeList.Count == 0)
{
return;
}
var nativeVC = vc as NativeDesignControl;
if (nativeVC == null)
{
return;
}
bool hitAxis = m_hitRegion == HitRegion.XAxis ||
m_hitRegion == HitRegion.YAxis ||
m_hitRegion == HitRegion.ZAxis;
Matrix4F proj = vc.Camera.ProjectionMatrix;
// create ray in view space.
Ray3F rayV = vc.GetRay(scrPt, proj);
Vec3F translate = m_translatorControl.OnDragging(rayV);
ISnapSettings snapSettings = (ISnapSettings)DesignView;
bool snapToGeom = Control.ModifierKeys == m_snapGeometryKey;
if (snapToGeom)
{
Matrix4F view = vc.Camera.ViewMatrix;
Matrix4F vp = view * proj;
// create ray in world space.
Ray3F rayW = vc.GetRay(scrPt, vp);
Vec3F manipPos = HitMatrix.Translation;
Vec3F manipMove;
if (hitAxis)
{
//Make rayw to point toward moving axis and starting
// from manipulator’s world position.
rayW.Direction = Vec3F.Normalize(translate);
rayW.Origin = manipPos;
manipMove = Vec3F.ZeroVector;
m_cancelDrag = true; //stop further snap-to's
}
else
{
manipMove = rayW.ProjectPoint(manipPos) - manipPos;
}
for (int i = 0; i < m_activeOp.NodeList.Count; i++)
{
ITransformable node = m_activeOp.NodeList[i];
Vec3F snapOffset = TransformUtils.CalcSnapFromOffset(node, snapSettings.SnapFrom);
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Vec3F orgPosW;
parentLocalToWorld.Transform(m_originalValues[i], out orgPosW);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
rayW.MoveToIncludePoint(orgPosW + snapOffset + manipMove);
var hits = XLEBridgeUtils.Picking.RayPick(
nativeVC.Adapter, rayW,
XLEBridgeUtils.Picking.Flags.Terrain | XLEBridgeUtils.Picking.Flags.Objects | XLEBridgeUtils.Picking.Flags.IgnoreSelection);
bool cansnap = false;
var target = new XLEBridgeUtils.Picking.HitRecord();
if (hits != null && hits.Length > 0)
{
// find hit record.
foreach (var hit in hits)
{
if (m_snapFilter.CanSnapTo(node, m_nativeIdMapping.GetAdapter(hit.documentId, hit.instanceId)))
{
target = hit;
cansnap = true;
break;
}
}
}
if (cansnap)
{
Vec3F pos;
if (target.hasNearestVert && snapSettings.SnapVertex)
{
pos = target.nearestVertex;
}
else
{
pos = target.hitPt;
}
pos -= snapOffset;
parentWorldToLocal.Transform(ref pos);
Vec3F diff = pos - node.Transform.Translation;
node.Translation += diff;
bool rotateOnSnap = snapSettings.RotateOnSnap &&
target.hasNormal &&
(node.TransformationType & TransformationTypes.Rotation) != 0;
if (rotateOnSnap)
{
Vec3F localSurfaceNormal;
parentWorldToLocal.TransformNormal(target.normal, out localSurfaceNormal);
node.Rotation = TransformUtils.RotateToVector(
m_originalRotations[i],
localSurfaceNormal,
AxisSystemType.YIsUp);
}
}
}
}
else
{
IGrid grid = DesignView.Context.Cast <IGame>().Grid;
bool snapToGrid = Control.ModifierKeys == m_snapGridKey &&
grid.Visible &&
vc.Camera.ViewType == ViewTypes.Perspective;
float gridHeight = grid.Height;
// translate.
for (int i = 0; i < m_activeOp.NodeList.Count; i++)
{
ITransformable node = m_activeOp.NodeList[i];
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
Vec3F localTranslation;
parentWorldToLocal.TransformVector(translate, out localTranslation);
Vec3F trans = m_originalValues[i] + localTranslation;
if (snapToGrid)
{
if (grid.Snap)
{
trans = grid.SnapPoint(trans);
}
else
{
trans.Y = gridHeight;
}
}
node.Translation = trans;
}
}
}
public override void OnInspectorGUI()
{
serializedObject.Update();
bool isPlaying = Application.isPlaying;
#if UNITY_2018_2_OR_NEWER
if (!serializedObject.isEditingMultipleObjects)
{
isPlaying = Application.IsPlaying(target);
}
#endif
GUI.enabled = !isPlaying;
EditorGUILayout.PropertyField(rotationProp);
EditorGUILayout.HelpBox("Initial Rotation should make sure palm faces forward, fingers points up in global axis.",
MessageType.Info);
EditorGUILayout.HelpBox("Global rotation of Transform component is locked to use value of Initial Rotation",
MessageType.None);
EditorGUILayout.PropertyField(isLeftProp);
EditorGUILayout.PropertyField(collliderProp);
EditorGUILayout.PropertyField(confidenceProp);
EditorGUILayout.PropertyField(handProp);
if (nodesProp.hasMultipleDifferentValues)
{
EditorGUILayout.LabelField("Nodes", "-");
}
else
{
showNodes.target = EditorGUILayout.Foldout(showNodes.target, "Nodes");
if (EditorGUILayout.BeginFadeGroup(showNodes.faded))
{
EditorGUI.indentLevel++;
for (int i = 0; i < 21; i++)
{
var element = nodesProp.GetArrayElementAtIndex(i);
element.objectReferenceValue =
EditorGUILayout.ObjectField(names[i], element.objectReferenceValue, typeof(Transform), true);
}
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFadeGroup();
}
serializedObject.ApplyModifiedProperties();
GUI.enabled = true;
if (isPlaying)
{
return;
}
foreach (ModelRenderer target in targets)
{
TransformUtils.SetInspectorRotation(target.transform, target.initialRotation);
target.initialRotation = TransformUtils.GetInspectorRotation(target.transform);
}
if (serializedObject.isEditingMultipleObjects)
{
return;
}
GUILayout.Space(5);
if (GUILayout.Button("Auto detect properties"))
{
AutoDetect(target as ModelRenderer);
}
EditorGUILayout.HelpBox("Please manually check if auto detect set fields correctly. Please refer to help page for details.",
MessageType.Info);
}