private RenderedPrimitives GetPixelSpacePrimitives(PerspectiveType perspectiveType) { if (Renderer == null) { return(new RenderedPrimitives()); } var renderedPrimitives = Renderer.GetRenderedPrimitives(perspectiveType, this); var trasnformedPoints = renderedPrimitives.Points .Select(point => new Vertex2D( ConvertPointToPixelSpace(point.Position), point.Color )).ToList(); var trasnformedPixels = renderedPrimitives.RawPixels .Select(point => new Vertex2D( ConvertPointToPixelSpace(point.Position), point.Color )).ToList(); var transformedLines = renderedPrimitives.Lines .Select(line => new Line2D( ConvertPointToPixelSpace(line.From), ConvertPointToPixelSpace(line.To), line.Color )).ToList(); return(new RenderedPrimitives() { RawPixels = trasnformedPixels, Points = trasnformedPoints, Lines = transformedLines, }); }
protected override void OnDrawAfterInterfaceMoveLine() { base.OnDrawAfterInterfaceMoveLine(); EditorGUILayout.BeginHorizontal(); EditorStatics.CreateLabelField("Display", string.Empty, EditorStatics.Width_70); viewType = (ViewType)EditorGUILayout.EnumPopup( string.Empty, viewType, EditorStatics.Width_90 ); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); EditorStatics.CreateLabelField("Perspective", string.Empty, EditorStatics.Width_70); perspectiveType = (PerspectiveType)EditorGUILayout.EnumPopup( string.Empty, perspectiveType, EditorStatics.Width_90 ); EditorGUILayout.EndHorizontal(); }
private Matrix4X4 GetProjectionMatrix(PerspectiveType perspectiveType) { var camera = Scene?.Camera; if (camera == null) { return(Matrix4X4.Identity); } var aspectMatrix = Transformations3D.Scaling(new Vector3D(1.0 / _aspectRatio, 1.0, 1.0)); Matrix4X4 projection; switch (perspectiveType) { case PerspectiveType.Standard: projection = aspectMatrix * camera.GetPerspectiveMatrix(); break; case PerspectiveType.LeftEye: projection = aspectMatrix * camera.GetPerspectiveMatrix(-EyeDistance); break; case PerspectiveType.RightEye: projection = aspectMatrix * camera.GetPerspectiveMatrix(+EyeDistance); break; default: throw new ArgumentOutOfRangeException(nameof(perspectiveType), perspectiveType, null); } return(projection); }
/** * Provides the point in the image corresponding to a ray projecting * from the camera. * * Given a ray projected from the camera in the specified direction, ``RectilinearToPixel()`` * corrects for camera distortion and returns the corresponding pixel * coordinates in the image. * * The ray direction is specified in relationship to the camera. The first * vector element corresponds to the "horizontal" view angle; the second * corresponds to the "vertical" view angle. * * \include Image_warp_1.txt * * The ``RectilinearToPixel()`` function returns pixel coordinates outside of the image bounds * if you project a ray toward a point for which there is no recorded data. * * ``RectilinearToPixel()`` is typically not fast enough for realtime distortion correction. * For better performance, use a shader program exectued on a GPU. * * **Note:** This function should be called immediately after an image is obtained. Incorrect * results will be returned if the image orientation has changed or a different device is plugged * in between the time the image was received and the time this function is called. * * Note, this function was formerly named Warp(). * * @param camera whether the ray parameter intercepts the left or the right stereo image. * @param ray A Vector containing the ray direction. * @returns A Vector containing the pixel coordinates [x, y, 1] (with z always one). * @since 2.1.0 */ public Vector RectilinearToPixel(PerspectiveType camera, Vector ray) { if (this.IsValid && imageData.isComplete) { Connection connection = Connection.GetConnection(); return(connection.RectilinearToPixel(camera, ray)); } return(Vector.Zero); }
/** * Provides the corrected camera ray intercepting the specified point on the image. * * Given a point on the image, ``PixelToRectilinear()`` corrects for camera distortion * and returns the true direction from the camera to the source of that image point * within the Leap Motion field of view. * * This direction vector has an x and y component [x, y, 1], with the third element * always one. Note that this vector uses the 2D camera coordinate system * where the x-axis parallels the longer (typically horizontal) dimension and * the y-axis parallels the shorter (vertical) dimension. The camera coordinate * system does not correlate to the 3D Leap Motion coordinate system. * * \include Image_rectify_1.txt * * **Note:** This function should be called immediately after an image is obtained. Incorrect * results will be returned if the image orientation has changed or a different device is plugged * in between the time the image was received and the time this function is called. * * Note, this function was formerly named Rectify(). * * @param camera whether the pixel parameter is a pixel in the left or the right stereo image. * @param pixel A Vector containing the position of a pixel in the image. * @returns A Vector containing the ray direction (the z-component of the vector is always one). * @since 2.1.0 */ public Vector PixelToRectilinear(PerspectiveType camera, Vector pixel) { if (this.IsValid && imageData.isComplete) { Connection connection = Connection.GetConnection(); return(connection.PixelToRectilinear(camera, pixel)); } return(Vector.Zero); }
private PerspectiveInterval ExpectedInterval(int startOffsetInMinutes, int endOffsetInMinutes, PerspectiveType type) { var interval = base.ExpectedInterval(startOffsetInMinutes, endOffsetInMinutes); interval.Perspective = type; return(interval); }
// // Called every frame. 'delta' is the elapsed time since the previous frame. // public override void _Process(float delta) // { // // } /// <summary> /// Sets the viewport's camera to the perspective specified by the button press id /// passed by the button connection signal. /// </summary> /// <param name = "id">The PerspectiveTypeEmun value for the camera perspective associated with the toolbar button</param> /// private void toolbarChangePerspective(int id) { currentPerspective = (PerspectiveType)id; Node tmp = this.GetNode("../Viewport/Camera/CameraObj"); GD.Print(tmp.Name); GD.Print(tmp.GetType()); Godot.Camera tmp2 = (Godot.Camera)tmp; Godot.Camera subCam = (Godot.Camera)GetNode("../Viewport/Camera/CameraObj"); Script gdClass = ResourceLoader.Load("res://src/CameraObj.gd") as Script; Object gdCam = new Object(); gdCam = (Godot.Object)gdClass.Call("new"); gdCam.SetScript(gdClass); switch (currentPerspective) { case PerspectiveType.Front: //GD.Print(subCam.GetClass() + subCam.GetFilename()); Vector3 newLook = new Vector3(5, 1, 0); subCam.LookAtFromPosition(newLook, new Vector3(0, 0, 0), new Vector3(0, 1, 0)); gdCam.Call("_update_mouselook"); gdCam.Call("_update_movement"); break; case PerspectiveType.Back: //subCam = GetNode<Camera>("../Viewport/Camera/CameraObj"); newLook = new Vector3(-5, 1, 0); subCam.LookAtFromPosition(newLook, new Vector3(0, 0, 0), new Vector3(0, 1, 0)); gdCam.Call("_update_mouselook"); gdCam.Call("_update_movement"); break; case PerspectiveType.Orthogonal: //subCam = GetNode<Camera>("../Viewport/Camera/CameraObj"); subCam.SetOrthogonal(3, 1, 10); gdCam.Call("_update_mouselook"); gdCam.Call("_update_movement"); break; case PerspectiveType.NOrthogonal: subCam.Projection = 0; gdCam.Call("_update_mouselook"); gdCam.Call("_update_movement"); break; default: GD.Print("Unrecognized Menu Item"); break; } }
public void InitPerspective(PerspectiveType type) { if (selectedPespective == PerspectiveType.none) { selectedPespective = type; } else { Debug.LogError("try to change perspective in an unproper case"); } }
private static Color?GetPerspectiveColorOverride(PerspectiveType perspectiveType) { Color?perspectiveColorOverride = null; switch (perspectiveType) { case PerspectiveType.LeftEye: perspectiveColorOverride = RightEyeFilteredColor; break; case PerspectiveType.RightEye: perspectiveColorOverride = LeftEyeFilteredColor; break; } return(perspectiveColorOverride); }
public void Rotate(double x, double y, double z) { m_editableHull.Rotate(x, y, z); _perspective = PerspectiveType.PERSPECTIVE; IsEditable = false; }
public RenderedPrimitives GetRenderedPrimitives(PerspectiveType perspectiveType, RenderTarget renderTarget) { // todo: fixme _aspectRatio = (float)renderTarget.OutputBitmap.PixelWidth / renderTarget.OutputBitmap.PixelHeight; var projection = GetProjectionMatrix(perspectiveType); var viewProj = projection * Scene.Camera.GetViewMatrix(); var rasterizedLines = new List <Line2D>(); var perspectiveColorOverride = GetPerspectiveColorOverride(perspectiveType); foreach (var worldObject in Scene.Objects) { worldObject.PrerenderUpdate(); } if (Scene.GrabbedObjects.Count > 0) { Scene.Manipulator.Position = Scene.GrabbedObjects.First().WorldPosition; } foreach (var worldObject in Scene.Objects) { var shape = worldObject.Shape; var transformation = viewProj * worldObject.GetWorldMatrix(); var dynamicShape = shape as IDynamicShape; dynamicShape?.UpdateGeometry( /*(p1, p2) => // calculate with clip (only visible length) * { * var v1 = ((Vector3D) p1).ExtendTo4D(); * var v2 = ((Vector3D) p2).ExtendTo4D(); * if (!TransformLineWithClip(transformation, ref v1, ref v2)) * return 0.0; * var pt1 = renderTarget.ConvertPointToPixelSpace((Point) v1); * var pt2 = renderTarget.ConvertPointToPixelSpace((Point) v2); * return (pt1-pt2).Length; * },*/ (p1, p2) => { var v1 = (Point)((Vector3D)p1).ExtendTo4D().Transform(transformation).WDivide(); var v2 = (Point)((Vector3D)p2).ExtendTo4D().Transform(transformation).WDivide(); return((renderTarget.ConvertPointToPixelSpace(v1) - renderTarget.ConvertPointToPixelSpace(v2)).Length); }, p => IsPositionInsideProjectiveCube(((Vector3D)p).ExtendTo4D().Transform(transformation)) ); foreach (var segment in shape.Lines) { var firstIndex = segment.First; var secondIndex = segment.Second; var v1 = shape.Vertices[firstIndex]; var v2 = shape.Vertices[secondIndex]; var segmentColor = ColorHelpers.Lerp(v1.Color, v2.Color, 0.5); var firstPos = ((Vector3D)v1.Position).ExtendTo4D(); var secondPos = ((Vector3D)v2.Position).ExtendTo4D(); if (!TransformLineWithClip(transformation, ref firstPos, ref secondPos)) { continue; } rasterizedLines.Add(new Line2D((Point)firstPos, (Point)secondPos, perspectiveColorOverride ?? segmentColor)); } } var rasterizedMarkerPoints = RasterizePoints(viewProj, perspectiveColorOverride, t => t.MarkerPoints); var rasterizedRawPixels = RasterizePoints(viewProj, perspectiveColorOverride, t => t.RawPoints); return(new RenderedPrimitives() { Points = rasterizedMarkerPoints, Lines = rasterizedLines, RawPixels = rasterizedRawPixels, }); }