void IRenderable.Draw(WSceneView view) { Vector3 scale = Transform.LocalScale; Quaternion rotation = Transform.Rotation; Vector3 translation = Transform.Position; if (RoomTransform != null) { rotation = Quaternion.FromAxisAngle(Vector3.UnitY, WMath.DegreesToRadians(RoomTransform.YRotation)); translation = new Vector3(RoomTransform.Translation.X, 0, RoomTransform.Translation.Y); } Matrix4 trs = Matrix4.CreateScale(scale) * Matrix4.CreateFromQuaternion(rotation) * Matrix4.CreateTranslation(translation); foreach (var mesh in m_roomModels) { mesh.Render(view.ViewMatrix, view.ProjMatrix, trs); } }
/// <summary> /// Create a Quaternion from Euler Angles. These should be in degrees in [-180, 180] space. /// </summary> public static Quaternion FromEulerAngles(this Quaternion quat, Vector3 eulerAngles) { eulerAngles.X = WMath.DegreesToRadians(eulerAngles.X); eulerAngles.Y = WMath.DegreesToRadians(eulerAngles.Y); eulerAngles.Z = WMath.DegreesToRadians(eulerAngles.Z); double c1 = Math.Cos(eulerAngles.Y / 2f); double s1 = Math.Sin(eulerAngles.Y / 2f); double c2 = Math.Cos(eulerAngles.X / 2f); double s2 = Math.Sin(eulerAngles.X / 2f); double c3 = Math.Cos(eulerAngles.Z / 2f); double s3 = Math.Sin(eulerAngles.Z / 2f); double c1c2 = c1 * c2; double s1s2 = s1 * s2; float w = (float)(c1c2 * c3 - s1s2 * s3); float x = (float)(c1c2 * s3 + s1s2 * c3); float y = (float)(s1 * c2 * c3 + c1 * s2 * s3); float z = (float)(c1 * s2 * c3 - s1 * c2 * s3); return(new Quaternion(x, y, z, w)); }
public Vector3 GetCenter() { List <J3DNode> m_roomModelNodes = GetChildrenOfType <J3DNode>(); Vector3 roomOffset = Vector3.Zero; if (m_roomModelNodes.Count > 0) { roomOffset += m_roomModelNodes[0].Model.BoundingSphere.Center; } if (RoomTransform != null) { roomOffset += new Vector3(RoomTransform.Translation.X, 0, RoomTransform.Translation.Y); float angle = WMath.DegreesToRadians(-RoomTransform.YRotation); float origX = roomOffset.X; float origZ = roomOffset.Z; roomOffset.X = (float)(origX * Math.Cos(angle) - origZ * Math.Sin(angle)); roomOffset.Z = (float)(origX * Math.Sin(angle) + origZ * Math.Cos(angle)); } return(roomOffset); }
public static Quaternion FromEulerAnglesRobust(this Quaternion quat, Vector3 eulerAngles, string rotationOrder, bool usesX, bool usesY, bool usesZ) { quat = Quaternion.Identity; foreach (var axis in rotationOrder) { int axisIndex = "XYZ".IndexOf(axis); if (new[] { usesX, usesY, usesZ }[axisIndex]) { float thisAxisRot = new[] { eulerAngles.X, eulerAngles.Y, eulerAngles.Z }[axisIndex]; Vector3 axisUnitVector = new Vector3(axis == 'X' ? 1 : 0, axis == 'Y' ? 1 : 0, axis == 'Z' ? 1 : 0); Quaternion thisAxisRotQ = Quaternion.FromAxisAngle(axisUnitVector, WMath.DegreesToRadians(thisAxisRot)); quat *= thisAxisRotQ; } ; } return(quat); }
public bool TransformFromInput(FRay ray, WSceneView view) { if (m_mode != FTransformMode.Translation) { WrapCursor(); } // Store the cursor position in viewport coordinates. Vector2 screenDimensions = App.GetScreenGeometry(); Vector2 cursorPos = App.GetCursorPosition(); Vector2 mouseCoords = new Vector2(((2f * cursorPos.X) / screenDimensions.X) - 1f, (1f - ((2f * cursorPos.Y) / screenDimensions.Y))); //[-1,1] range bool shiftPressed = WInput.GetKey(Key.LeftShift) || WInput.GetKey(Key.RightShift); if (m_mode == FTransformMode.Translation) { // Create a Translation Plane Vector3 axisA, axisB; if (GetNumSelectedAxes() == 1) { if (m_selectedAxes == FSelectedAxes.X) { axisB = Vector3.UnitX; } else if (m_selectedAxes == FSelectedAxes.Y) { axisB = Vector3.UnitY; } else { axisB = Vector3.UnitZ; } Vector3 dirToCamera = (m_position - view.GetCameraPos()).Normalized(); axisA = Vector3.Cross(axisB, dirToCamera); } else { axisA = ContainsAxis(m_selectedAxes, FSelectedAxes.X) ? Vector3.UnitX : Vector3.UnitZ; axisB = ContainsAxis(m_selectedAxes, FSelectedAxes.Y) ? Vector3.UnitY : Vector3.UnitZ; } Vector3 planeNormal = Vector3.Cross(axisA, axisB).Normalized(); m_translationPlane = new FPlane(planeNormal, m_position); float intersectDist; if (m_translationPlane.RayIntersectsPlane(ray, out intersectDist)) { Vector3 hitPos = ray.Origin + (ray.Direction * intersectDist); Vector3 localDelta = Vector3.Transform(hitPos - m_position, m_rotation.Inverted()); // Calculate a new position Vector3 newPos = m_position; if (ContainsAxis(m_selectedAxes, FSelectedAxes.X)) { newPos += Vector3.Transform(Vector3.UnitX, m_rotation) * localDelta.X; } if (ContainsAxis(m_selectedAxes, FSelectedAxes.Y)) { newPos += Vector3.Transform(Vector3.UnitY, m_rotation) * localDelta.Y; } if (ContainsAxis(m_selectedAxes, FSelectedAxes.Z)) { newPos += Vector3.Transform(Vector3.UnitZ, m_rotation) * localDelta.Z; } if (shiftPressed) { // Round to nearest 100 unit increment while shift is held down. newPos.X = (float)Math.Round(newPos.X / 100f) * 100f; newPos.Y = (float)Math.Round(newPos.Y / 100f) * 100f; newPos.Z = (float)Math.Round(newPos.Z / 100f) * 100f; } // Check the new location to see if it's skyrocked off into the distance due to near-plane raytracing issues. Vector3 newPosDirToCamera = (newPos - view.GetCameraPos()).Normalized(); float dot = Math.Abs(Vector3.Dot(planeNormal, newPosDirToCamera)); //Console.WriteLine("hitPos: {0} localOffset: {1} newPos: {2}, dotResult: {3}", hitPos, localOffset, newPos, dot); if (dot < 0.02f) { return(false); } // This is used to set the offset to the gizmo the mouse cursor is from the origin of the gizmo on the first frame // that you click on the gizmo. if (!m_hasSetMouseOffset) { m_translateOffset = m_position - newPos; m_deltaTranslation = Vector3.Zero; m_hasSetMouseOffset = true; return(false); } // Apply Translation m_deltaTranslation = Vector3.Transform(newPos - m_position + m_translateOffset, m_rotation.Inverted()); if (!ContainsAxis(m_selectedAxes, FSelectedAxes.X)) { m_deltaTranslation.X = 0f; } if (!ContainsAxis(m_selectedAxes, FSelectedAxes.Y)) { m_deltaTranslation.Y = 0f; } if (!ContainsAxis(m_selectedAxes, FSelectedAxes.Z)) { m_deltaTranslation.Z = 0f; } m_totalTranslation += m_deltaTranslation; m_position += Vector3.Transform(m_deltaTranslation, m_rotation); if (!m_hasTransformed && (m_deltaTranslation != Vector3.Zero)) { m_hasTransformed = true; } return(m_hasTransformed); } else { // Our raycast missed the plane m_deltaTranslation = Vector3.Zero; return(false); } } else if (m_mode == FTransformMode.Rotation) { Vector3 rotationAxis; if (m_selectedAxes == FSelectedAxes.X) { rotationAxis = Vector3.UnitX; } else if (m_selectedAxes == FSelectedAxes.Y) { rotationAxis = Vector3.UnitY; } else { rotationAxis = Vector3.UnitZ; } // Convert these from [0-1] to [-1, 1] to match our mouse coords. Vector2 lineOrigin = (view.UnprojectWorldToViewport(m_hitPoint) * 2) - Vector2.One; Vector2 lineEnd = (view.UnprojectWorldToViewport(m_hitPoint + m_moveDir) * 2) - Vector2.One; lineOrigin.Y = -lineOrigin.Y; lineEnd.Y = -lineEnd.Y; Vector2 lineDir = (lineEnd - lineOrigin).Normalized(); float rotAmount = Vector2.Dot(lineDir, mouseCoords + m_wrapOffset - lineOrigin) * 180f; if (float.IsNaN(rotAmount)) { Console.WriteLine("rotAmountNaN!"); return(false); } if (!m_hasSetMouseOffset) { m_rotateOffset = -rotAmount; m_deltaRotation = Quaternion.Identity; m_hasSetMouseOffset = true; return(false); } // Apply Rotation rotAmount += m_rotateOffset; if (shiftPressed) { // Round to nearest 45 degree increment while shift is held down. rotAmount = (float)Math.Round(rotAmount / 45f) * 45f; } Quaternion oldRot = m_currentRotation; m_currentRotation = Quaternion.FromAxisAngle(rotationAxis, WMath.DegreesToRadians(rotAmount)); m_deltaRotation = m_currentRotation * oldRot.Inverted(); if (m_transformSpace == FTransformSpace.Local) { m_rotation *= m_deltaRotation; } // Add to Total Rotation recorded for UI. if (m_selectedAxes == FSelectedAxes.X) { m_totalRotation.X = rotAmount; } else if (m_selectedAxes == FSelectedAxes.Y) { m_totalRotation.Y = rotAmount; } else { m_totalRotation.Z = rotAmount; } if (!m_hasTransformed && rotAmount != 0f) { m_hasTransformed = true; } return(m_hasTransformed); } else if (m_mode == FTransformMode.Scale) { // Create a line in screen space. // Convert these from [0-1] to [-1, 1] to match our mouse coords. Vector2 lineOrigin = (view.UnprojectWorldToViewport(m_position) * 2) - Vector2.One; lineOrigin.Y = -lineOrigin.Y; // Determine the appropriate world space directoin using the selected axes and then conver this for use with // screen-space controlls. This has to be done every frame because the axes can be flipped while the gizmo // is transforming, so we can't pre-calculate this. Vector3 dirX = Vector3.Transform(mFlipScaleX ? -Vector3.UnitX : Vector3.UnitX, m_rotation); Vector3 dirY = Vector3.Transform(mFlipScaleY ? -Vector3.UnitY : Vector3.UnitY, m_rotation); Vector3 dirZ = Vector3.Transform(mFlipScaleZ ? -Vector3.UnitZ : Vector3.UnitZ, m_rotation); Vector2 lineDir; // If there is only one axis, then the world space direction is the selected axis. if (GetNumSelectedAxes() == 1) { Vector3 worldDir; if (ContainsAxis(m_selectedAxes, FSelectedAxes.X)) { worldDir = dirX; } if (ContainsAxis(m_selectedAxes, FSelectedAxes.Y)) { worldDir = dirY; } else { worldDir = dirZ; } Vector2 worldPoint = (view.UnprojectWorldToViewport(m_position + worldDir) * 2) - Vector2.One; worldPoint.Y = -lineOrigin.Y; lineDir = (worldPoint - lineOrigin).Normalized(); } // If there's two axii selected, then convert both to screen space and average them out to get the line direction. else if (GetNumSelectedAxes() == 2) { Vector3 axisA = ContainsAxis(m_selectedAxes, FSelectedAxes.X) ? dirX : dirY; Vector3 axisB = ContainsAxis(m_selectedAxes, FSelectedAxes.Z) ? dirZ : dirY; Vector2 screenA = (view.UnprojectWorldToViewport(m_position + axisA) * 2) - Vector2.One; screenA.Y = -screenA.Y; Vector2 screenB = (view.UnprojectWorldToViewport(m_position + axisB) * 2) - Vector2.One; screenB.Y = -screenB.Y; screenA = (screenA - lineOrigin).Normalized(); screenB = (screenB - lineOrigin).Normalized(); lineDir = ((screenA + screenB) / 2f).Normalized(); } // There's three axis, just use up. else { lineDir = Vector2.UnitY; } float scaleAmount = Vector2.Dot(lineDir, mouseCoords + m_wrapOffset - lineOrigin) * 5f; if (shiftPressed) { // Round to nearest whole number scale while shift is held down. scaleAmount = (float)Math.Round(scaleAmount); } // Set their initial offset if we haven't already if (!m_hasSetMouseOffset) { m_scaleOffset = -scaleAmount; m_deltaScale = Vector3.One; m_hasSetMouseOffset = true; return(false); } // Apply the scale scaleAmount = scaleAmount + m_scaleOffset + 1f; // A multiplier is applied to the scale amount if it's less than one to prevent it dropping into the negatives. // ??? if (scaleAmount < 1f) { scaleAmount = 1f / (-(scaleAmount - 1f) + 1f); } Vector3 oldScale = m_totalScale; m_totalScale = Vector3.One; if (ContainsAxis(m_selectedAxes, FSelectedAxes.X)) { m_totalScale.X = scaleAmount; } if (ContainsAxis(m_selectedAxes, FSelectedAxes.Y)) { m_totalScale.Y = scaleAmount; } if (ContainsAxis(m_selectedAxes, FSelectedAxes.Z)) { m_totalScale.Z = scaleAmount; } m_deltaScale = new Vector3(m_totalScale.X / oldScale.X, m_totalScale.Y / oldScale.Y, m_totalScale.Z / oldScale.Z); if (!m_hasTransformed && (scaleAmount != 1f)) { m_hasTransformed = true; } return(m_hasTransformed); } return(false); }
public void Rotate(Vector3 axis, float angleInDegrees) { Quaterniond rotQuat = Quaterniond.FromAxisAngle((Vector3d)axis, WMath.DegreesToRadians(angleInDegrees)); Rotation = rotQuat * Rotation; }
private WActorNode LoadActorFromChunk(string fourCC, MapActorDescriptor template) { var newActor = new WActorNode(fourCC, m_world); List <IPropertyValue> actorProperties = new List <IPropertyValue>(); foreach (var field in template.Fields) { IPropertyValue propValue = null; switch (field.FieldType) { case PropertyValueType.Byte: propValue = new TBytePropertyValue(m_reader.ReadByte(), field.FieldName); break; case PropertyValueType.Bool: propValue = new TBoolPropertyValue(m_reader.ReadBoolean(), field.FieldName); break; case PropertyValueType.Short: propValue = new TShortPropertyValue(m_reader.ReadInt16(), field.FieldName); break; case PropertyValueType.Int: propValue = new TIntPropertyValue(m_reader.ReadInt32(), field.FieldName); break; case PropertyValueType.Float: propValue = new TFloatPropertyValue(m_reader.ReadSingle(), field.FieldName); break; case PropertyValueType.FixedLengthString: case PropertyValueType.String: string stringVal = (field.Length == 0) ? m_reader.ReadStringUntil('\0') : m_reader.ReadString(field.Length); stringVal = stringVal.Trim(new[] { '\0' }); propValue = new TStringPropertyValue(stringVal, field.FieldName); break; case PropertyValueType.Vector2: propValue = new TVector2PropertyValue(new OpenTK.Vector2(m_reader.ReadSingle(), m_reader.ReadSingle()), field.FieldName); break; case PropertyValueType.Vector3: propValue = new TVector3PropertyValue(new OpenTK.Vector3(m_reader.ReadSingle(), m_reader.ReadSingle(), m_reader.ReadSingle()), field.FieldName); break; case PropertyValueType.XRotation: case PropertyValueType.YRotation: case PropertyValueType.ZRotation: propValue = new TShortPropertyValue(m_reader.ReadInt16(), field.FieldName); break; case PropertyValueType.Color24: propValue = new TLinearColorPropertyValue(new WLinearColor(m_reader.ReadByte() / 255f, m_reader.ReadByte() / 255f, m_reader.ReadByte() / 255f), field.FieldName); break; case PropertyValueType.Color32: propValue = new TLinearColorPropertyValue(new WLinearColor(m_reader.ReadByte() / 255f, m_reader.ReadByte() / 255f, m_reader.ReadByte() / 255f, m_reader.ReadByte() / 255f), field.FieldName); break; default: Console.WriteLine("Unsupported PropertyValueType: {0}", field.FieldType); break; } propValue.SetUndoStack(m_world.UndoStack); actorProperties.Add(propValue); } // Now that we have loaded all properties out of it, we need to post-process them. IPropertyValue positionProperty = actorProperties.Find(x => x.Name == "Position"); IPropertyValue xRotProperty = actorProperties.Find(x => x.Name == "X Rotation"); IPropertyValue yRotProperty = actorProperties.Find(x => x.Name == "Y Rotation"); IPropertyValue zRotProperty = actorProperties.Find(x => x.Name == "Z Rotation"); IPropertyValue xScaleProperty = actorProperties.Find(x => x.Name == "X Scale"); IPropertyValue yScaleProperty = actorProperties.Find(x => x.Name == "Y Scale"); IPropertyValue zScaleProperty = actorProperties.Find(x => x.Name == "Z Scale"); // Remove these properties from the actor so they don't get added to the UI. actorProperties.Remove(positionProperty); actorProperties.Remove(xRotProperty); actorProperties.Remove(yRotProperty); actorProperties.Remove(zRotProperty); actorProperties.Remove(xScaleProperty); actorProperties.Remove(yScaleProperty); actorProperties.Remove(zScaleProperty); if (positionProperty != null) { newActor.Transform.Position = (Vector3)positionProperty.GetValue(); } float xRot = 0, yRot = 0, zRot = 0; if (xRotProperty != null) { xRot = WMath.RotationShortToFloat((short)xRotProperty.GetValue()); } if (yRotProperty != null) { yRot = WMath.RotationShortToFloat((short)yRotProperty.GetValue()); } if (zRotProperty != null) { zRot = WMath.RotationShortToFloat((short)zRotProperty.GetValue()); } // Build rotation with ZYX order. Quaternion xRotQ = Quaternion.FromAxisAngle(new Vector3(1, 0, 0), WMath.DegreesToRadians(xRot)); Quaternion yRotQ = Quaternion.FromAxisAngle(new Vector3(0, 1, 0), WMath.DegreesToRadians(yRot)); Quaternion zRotQ = Quaternion.FromAxisAngle(new Vector3(0, 0, 1), WMath.DegreesToRadians(zRot)); newActor.Transform.Rotation = zRotQ * yRotQ * xRotQ; float xScale = 1, yScale = 1, zScale = 1; if (xScaleProperty != null) { xScale = ((byte)xScaleProperty.GetValue()) / 10f; } if (yScaleProperty != null) { yScale = ((byte)yScaleProperty.GetValue()) / 10f; } if (zScaleProperty != null) { zScale = ((byte)zScaleProperty.GetValue()) / 10f; } newActor.Transform.LocalScale = new Vector3(xScale, yScale, zScale); newActor.Properties.AddRange(actorProperties); newActor.PostFinishedLoad(); return(newActor); }
public void SetRoomTransform(WRoomTransform roomTransform) { List <J3DNode> m_roomModelNodes = GetChildrenOfType <J3DNode>(); RoomTransform = roomTransform; foreach (J3DNode j3d_node in m_roomModelNodes) { j3d_node.Transform.Position = new Vector3(RoomTransform.Translation.X, 0, RoomTransform.Translation.Y); j3d_node.Transform.LocalRotation = Quaterniond.FromAxisAngle(Vector3d.UnitY, WMath.DegreesToRadians(RoomTransform.YRotation)); } }