public void Process(ISensor sensor, MoveEvent moveEvent)
{
var startX = moveEvent.StartMoveX;
var startY = moveEvent.StartMoveY;
var endX = moveEvent.EndMoveX;
var endY = moveEvent.EndMoveY;
if (startX.EqualsTo(endX) && startY.EqualsTo(endY))
{
return;
}
var offset = moveEvent.Camera.Frame.Offset;
var endMoveOffset = ViewProjection.ProjectCanvasToSceneSystem(moveEvent.EndMoveX, moveEvent.EndMoveY, moveEvent.CanvasWidth, moveEvent.CanvasHeight, moveEvent.Camera.NearPlane, moveEvent.Camera.Frame);
var endMoveDirection = endMoveOffset - offset;
var endMoveRay = new Axis3D(endMoveOffset, endMoveDirection);
var body = _scene.GetBody(moveEvent.SelectedBodyId);
var camera = moveEvent.Camera;
var canvasWidth = moveEvent.CanvasWidth;
var canvasHeight = moveEvent.CanvasHeight;
var bodyTouchPosition = moveEvent.BodyTouchPosition;
var canvasOrigin = ViewProjection.ProjectCanvasToSceneSystem(0.0, 0.0, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
var canvasExPos = ViewProjection.ProjectCanvasToSceneSystem(1.0, 0.0, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
var canvasEyPos = ViewProjection.ProjectCanvasToSceneSystem(0.0, 1.0, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
var exAxis = (canvasExPos - canvasOrigin).Normalize();
var ezAxis = (canvasEyPos - canvasOrigin).Normalize();
var zCylinderAxis = new Axis3D(body.Frame.Offset, ezAxis);
var xCylinderAxis = new Axis3D(body.Frame.Offset, exAxis);
Process(body, bodyTouchPosition, startX, startY, endMoveRay, zCylinderAxis, canvasWidth, canvasHeight, camera);
Process(body, bodyTouchPosition, startX, startY, endMoveRay, xCylinderAxis, canvasWidth, canvasHeight, camera);
}
public void Render(RenderContext context, Vector2 position)
{
DrawBatch batch = context.MainBatch;
IconShaderResources shaderResources = context.ShaderResources.Icon;
ViewProjection vp = context.OrthoProjection;
(QuadGeometry quad, _) = QuadGeometry.Create(
new SizeF(_texture.Width, _texture.Height),
Matrix4x4.CreateTranslation(new Vector3(position, 0)),
Vector2.Zero,
Vector2.One,
color: Vector4.One
);
var geometry = QuadGeometryUV3.FromQuad(quad, layer: _activeFrame);
Mesh <QuadVertexUV3> mesh = context.QuadsUV3
.Append(MemoryMarshal.CreateReadOnlySpan(ref geometry.TopLeft, 4));
batch.PushDraw(new Draw
{
Pipeline = shaderResources.Pipeline,
ResourceBindings = new ResourceBindings(
new ResourceSetKey(vp.ResourceLayout, vp.Buffer.VdBuffer),
new ResourceSetKey(
shaderResources.ResourceLayout,
_texture,
context.GetSampler(FilterMode.Linear)
)
),
BufferBindings = new BufferBindings(mesh.Vertices.Buffer, mesh.Indices.Buffer),
Params = DrawParams.Indexed(0, 0, 6)
});
}
public IEnumerable <int> GetHiddenLineGraphics(Scene scene, Camera camera, double canvasWidth, double canvasHeight)
{
// Convert to hidden line graphics scene
var sceneHL = scene.ToHiddenLineScene(camera);
// clipp 3D lines at near planle
var clippedEdges = sceneHL.Edges.ClippAtNearPlane(sceneHL.NearPlaneDistance);
// Project 3D lines on Nearplane to 2D lines
var planeLines = clippedEdges.ProjectToCameraPlane(sceneHL.NearPlaneDistance);
// Filter lines with at least one visible triangle
var visiblePlaneLines = planeLines.FilterLinesOfVisibleTriangles();
// Clipp lines at the projected screen limits
var(left, bottom) = ViewProjection.ProjectCanvasToCameraPlane(0, canvasHeight, canvasWidth, canvasHeight);
var(right, top) = ViewProjection.ProjectCanvasToCameraPlane(canvasWidth, 0, canvasWidth, canvasHeight);
var clippedLines = visiblePlaneLines.Clipp(left, right, bottom, top);
// Cut 2D lines in uncutted 2D lines
var cuttedLines = clippedLines.CutLines();
var visibleLines = cuttedLines.FilterOutHiddenLines(sceneHL);
var visibleLineCoordinates = visibleLines.SelectMany(line => line.ToLineCoordinates(canvasWidth, canvasHeight));
return(visibleLineCoordinates);
}
public ViewProjection <TView, TId> ProjectView <TView, TId>() where TView : class
{
var projection = new ViewProjection <TView, TId>();
InlineProjections.Add(projection);
return(projection);
}
public void Process(ISensor sensor, MoveEvent moveEvent)
{
var offset = moveEvent.Camera.Frame.Offset;
var startMoveOffset = ViewProjection.ProjectCanvasToSceneSystem(moveEvent.StartMoveX, moveEvent.StartMoveY, moveEvent.CanvasWidth, moveEvent.CanvasHeight, moveEvent.Camera.NearPlane, moveEvent.Camera.Frame);
var startMoveDirection = startMoveOffset - offset;
var startMoveRay = new Axis3D(startMoveOffset, startMoveDirection);
var endMoveOffset = ViewProjection.ProjectCanvasToSceneSystem(moveEvent.EndMoveX, moveEvent.EndMoveY, moveEvent.CanvasWidth, moveEvent.CanvasHeight, moveEvent.Camera.NearPlane, moveEvent.Camera.Frame);
var endMoveDirection = endMoveOffset - offset;
var endMoveRay = new Axis3D(endMoveOffset, endMoveDirection);
var body = _scene.GetBody(moveEvent.SelectedBodyId);
Process(sensor as CylinderSensor,
body,
moveEvent.BodyTouchPosition,
moveEvent.StartMoveX,
moveEvent.StartMoveY,
startMoveRay,
moveEvent.EndMoveX,
moveEvent.EndMoveY,
endMoveRay,
moveEvent.CanvasWidth,
moveEvent.CanvasHeight,
moveEvent.Camera);
}
public void Draw(VKImage image, float tick)
{
if (Count == 0)
{
return;
}
var vp = new ViewProjection {
View = View, Projection = Projection
};
UProjection.Write(ref vp);
UTime.Write(ref tick);
var cb = CBuffer[image];
cb.Begin();
cb.BeginPass(Pipeline);
cb.Draw(Graphics.SquareSprite, Instances, Count);
cb.EndPass();
cb.End();
cb.Submit(true);
cb.Reset();
}
private static LineHL ToLine2D(this EdgeHL edge, double nearPlaneDist)
{
var(x1, y1) = ViewProjection.ProjectCameraSystemToCameraPlane(edge.Start, nearPlaneDist);
var(x2, y2) = ViewProjection.ProjectCameraSystemToCameraPlane(edge.End, nearPlaneDist);
var line2d = new LineHL {
Start = new PointHL(x1, y1), End = new PointHL(x2, y2), Edge = edge
};
return(line2d);
}
private static TriangleSpin DetermineTriangleSpin(Position3D p1, Position3D p2, Position3D p3, double nearPlane)
{
var(x1, y1) = ViewProjection.ProjectCameraSystemToCameraPlane(p1, nearPlane);
var(x2, y2) = ViewProjection.ProjectCameraSystemToCameraPlane(p2, nearPlane);
var(x3, y3) = ViewProjection.ProjectCameraSystemToCameraPlane(p3, nearPlane);
var area = 0.5 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2));
var result = area > 0.0 ? TriangleSpin.counter_clockwise : area < 0.0 ? TriangleSpin.clockwise : TriangleSpin.no_clockwise;
return(result);
}
private static Axis3D GetRaytracingRay(LineHL line, double nearPlaneDistance)
{
var start = line.Start;
var end = line.End;
var centerViewLine = new PointHL((start.X + end.X) / 2.0, (start.Y + end.Y) / 2.0);
var centerCameraPlaneLine = ViewProjection.ProjectCameraPlaneToCameraSystem(centerViewLine.X, centerViewLine.Y, nearPlaneDistance);
var rayOffset = new Position3D(0.0, 0.0, 0.0);
var rayDirection = centerCameraPlaneLine - rayOffset;
return(new Axis3D(rayOffset, rayDirection));
}
public static IEnumerable <int> ToLineCoordinates(this LineHL line, double canvasWidth, double canvasHeight)
{
var(x1, y1) = ViewProjection.ProjectCameraPlaneToCanvas(line.Start.X, line.Start.Y, canvasWidth, canvasHeight);
var(x2, y2) = ViewProjection.ProjectCameraPlaneToCanvas(line.End.X, line.End.Y, canvasWidth, canvasHeight);
yield return(x1);
yield return(y1);
yield return(x2);
yield return(y2);
}
public static bool IsBirdsEye(this ViewProjection viewProjection)
{
switch (viewProjection)
{
case ViewProjection.BirdsEye_0:
case ViewProjection.BirdsEye_90:
case ViewProjection.BirdsEye_180:
case ViewProjection.BirdsEye_270:
return(true);
}
return(false);
}
public SelectedBodyState SelectBody(SelectEvent selectEvent)
{
var posScene = ViewProjection.ProjectCanvasToSceneSystem(selectEvent.selectPositionX, selectEvent.selectPositionY, selectEvent.CanvasWidth, selectEvent.CanvasHeight, selectEvent.Camera.NearPlane, selectEvent.Camera.Frame);
var rayOffset = selectEvent.Camera.Frame.Offset;
var rayDirection = posScene - rayOffset;
var(isIntersected, intersection, body) = Scene.GetIntersectionOfRayAndScene(rayOffset, rayDirection);
return(new SelectedBodyState {
SelectedBodyId = isIntersected ? body.Id : Guid.Empty, IsBodySelected = isIntersected, BodyIntersection = intersection
});
}
private static double CalculateAngleForAxisLieingInCanvas(
Position3D bodyTouchPosition,
double startX,
double startY,
Axis3D endMoveRay,
Axis3D cylinderAxis,
double canvasWidth,
double canvasHeight,
Camera camera
)
{
var angle = 0.0;
var cameraDirection = camera.Frame.Ey;
var direction = (cameraDirection & cylinderAxis.Direction).Normalize() * 10000.0;
var offset = ViewProjection.ProjectCanvasToSceneSystem(startX, startY, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
var p1 = offset - direction;
var p2 = offset + direction;
var projectedAxis = new Axis3D(p1, p2 - p1);
var(success, plump) = projectedAxis.CalculatePerpendicularPoint(endMoveRay);
if (success)
{
// Ermitteln des Vorzeichens für Drehung
var sign = (plump - p1).Length < (plump - p2).Length ? -1.0 : 1.0;
// Ermitteln der Länge der Mausbewegung in Richtung senkrecht zur Rotationsachse
var(endX, endY) = ViewProjection.ProjectSceneSystemToCanvas(plump, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
double delta = Vector2DMath.Length(startX, startY, endX, endY);
// Projektion Berührungspunkt auf Rotationsachse.
// Ermittel Scheitelpunkte der Rotation auf Achse senkrecht zur Kamera und Rotationsachse.
// Projektion der Scheitelpunkte auf Canvas.
// Abstand Scheitelpunkte auf Achse ist die Mausbewegung für 180°.
// Winkel ist Verhältnis Länge Mausbewegung zur Länge für 180°.
var plumpPoint = cylinderAxis.CalculatePerpendicularPoint(bodyTouchPosition);
var distance = (bodyTouchPosition - plumpPoint).Length;
direction = direction.Normalize() * distance;
var startPosition = cylinderAxis.Offset - direction;
var endPosition = cylinderAxis.Offset + direction;
(startX, startY) = ViewProjection.ProjectSceneSystemToCanvas(startPosition, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
(endX, endY) = ViewProjection.ProjectSceneSystemToCanvas(endPosition, canvasWidth, canvasHeight, camera.NearPlane, camera.Frame);
var lengthOfHalfRotation = Vector2DMath.Length(startX, startY, endX, endY);
var angleInDegree = 180.0 * delta / lengthOfHalfRotation;
angle = sign * angleInDegree.DegToRad();
}
return(angle);
}
public Camera Select(SelectEvent selectEvent)
{
var posScene = ViewProjection.ProjectCanvasToSceneSystem(selectEvent.selectPositionX, selectEvent.selectPositionY, selectEvent.CanvasWidth, selectEvent.CanvasHeight, selectEvent.Camera.NearPlane, selectEvent.Camera.Frame);
var rayOffset = selectEvent.Camera.Frame.Offset;
var rayDirection = posScene - rayOffset;
var(isintersected, intersection, body) = Scene.GetIntersectionOfRayAndScene(rayOffset, rayDirection);
if (isintersected)
{
selectEvent.Camera.MoveTargetTo(intersection);
}
return(selectEvent.Camera);
}
public ViewRenderTarget(ViewProjection projection, float near, float far,
int width, int height, float fov, float extent)
{
Projection = projection;
this.near = near;
this.far = far;
this.width = width;
this.height = height;
this.fov = fov;
// create matrices
if (projection == ViewProjection.Perspective)
proj = Matrix.PerspectiveLH(width, height, near, far);
else if (projection == ViewProjection.Orthographic)
proj = Matrix.OrthoLH(width, height, near, far);
view = Matrix.LookAtLH(new Vector3(-extent, extent, extent), new Vector3(), new Vector3(0, 1, 0));
}
public void SetInverseCamera(Camera3D camera)
{
if (InverseView != null)
{
InverseView.SetValue(camera.InverseView);
}
if (InverseViewProjection != null)
{
InverseViewProjection.SetValue(camera.InverseViewProjection);
}
if (CameraPosition != null)
{
CameraPosition.SetValue(camera.Position);
}
if (ViewProjection != null)
{
ViewProjection.SetValue(camera.ViewMatrix * camera.ProjectionMatrix);
}
}
public ViewRenderTarget(ViewProjection projection, float near, float far,
int width, int height, float fov, float extent)
{
Projection = projection;
this.near = near;
this.far = far;
this.width = width;
this.height = height;
this.fov = fov;
// create matrices
if (projection == ViewProjection.Perspective)
{
proj = Matrix.PerspectiveLH(width, height, near, far);
}
else if (projection == ViewProjection.Orthographic)
{
proj = Matrix.OrthoLH(width, height, near, far);
}
view = Matrix.LookAtLH(new Vector3(-extent, extent, extent), new Vector3(), new Vector3(0, 1, 0));
}
public static bool IsOrthographic(this ViewProjection viewProjection)
{
return((viewProjection == ViewProjection.Orthographic_Front) || (viewProjection == ViewProjection.Orthographic_Side));
}
private void PlayButton_Click(object sender, EventArgs e)
{
if (!CheckState())
{
return;
}
if (GRBLMachinePlugin.Props.ToolChangeProcess == IgnoreProcessPassOn.Process)
{
string post = CamBamUI.MainUI.ActiveView.CADFile.MachiningOptions.PostProcessor;
if (!string.IsNullOrEmpty(post) && post != "GRBLMachine")
{
switch (MessageBox.Show("The Post Processor in Machining Options is not 'GRBLMachine'.\r\n\r\nSet Post Processor to 'GRBLMachine' and regenerate GCODE ?", "GRBLMachine - Play", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question))
{
case DialogResult.Yes:
CamBamUI.MainUI.ActiveView.CADFile.MachiningOptions.PostProcessor = "GRBLMachine";
CAMUtils.GenerateGCodeOutput(CamBamUI.MainUI.ActiveView);
break;
case DialogResult.Cancel:
return;
case DialogResult.No:
break;
}
}
}
if (GRBLMachinePlugin.Props.TrackMachine == EnabledDisabled.Enabled)
{
CamBamUI ui = CamBamUI.MainUI;
// turn toolpaths et al on
ui.ActiveView.CADFile.ShowToolpaths = true;
ui.ActiveView.CADFile.ShowRapids = true;
ui.ActiveView.CADFile.ShowDirectionVector = true;
ui.ViewContextMenus.RefreshCheckedMenus();
// runs in background, so just start it, we'll do something else in the meanwhile
CAMUtils.GenerateToolpaths(ui.ActiveView);
// fit current drawing and current perspective to fit view
ui.ActiveView.ZoomToFitEx();
// setup ISO-like perspective ( inspired from ViewToolbarAddins (y) )
ViewProjection vp = ui.ActiveView.ViewProjection;
Matrix4x4F mx = Matrix4x4F.Identity;
mx.Scale(vp.ViewMatrix4x4F.GetScale());
mx.RotZ(-Math.PI / 4f); // 90 degrees
mx.RotX(-Math.PI / (4f * (60f / 90f))); // 60 degrees
mx.Translate(vp.ViewMatrix4x4F.m[12], vp.ViewMatrix4x4F.m[13], vp.ViewMatrix4x4F.m[14]);
vp.ViewMatrix4x4F = mx;
// re-zoom, since drawing may now be outside the view
ui.ActiveView.ZoomToFitEx();
// wait until GenerateToolpaths is ready
while (ui.ActiveView.IsThinking)
{
Application.DoEvents();
}
// re-zoom, since toolpaths may be outside the view
ui.ActiveView.ZoomToFitEx();
}
_sendingFileName = FileName.Text;
_writeThread = new Thread(WriteThread);
_writeThread.Name = "GCODE-SenderThread";
_writeThread.IsBackground = true;
PauseButton.Checked = false;
EnableButtons();
FileName.Enabled = false;
BrowseButton.Enabled = false;
LinesSent.Text = LinesTotal.Text = "-";
_pauseEvent.Set();
_fileData.Clear();
_writeThread.Start();
}
