private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { MyDrawObject.IsEnabled = false; ESRI.ArcGIS.Client.Geometry.Polyline polyline = args.Geometry as ESRI.ArcGIS.Client.Geometry.Polyline; polyline.SpatialReference = MyMap.SpatialReference; Graphic polylineGraphic = new Graphic() { Geometry = polyline }; List<Graphic> polylineList = new List<Graphic>(); polylineList.Add(polylineGraphic); GeometryService geometryService = new GeometryService("http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.AutoCompleteCompleted += GeometryService_AutoCompleteCompleted; geometryService.Failed += GeometryService_Failed; GraphicsLayer graphicsLayer = MyMap.Layers["ParcelsGraphicsLayer"] as GraphicsLayer; List<Graphic> polygonList = new List<Graphic>(); foreach (Graphic g in graphicsLayer.Graphics) { g.Geometry.SpatialReference = MyMap.SpatialReference; polygonList.Add(g); } geometryService.AutoCompleteAsync(polygonList, polylineList); }
public override void Draw(DrawEventArgs e) { if (e.Edited == this) { for (int i = 0; i < _points.Count - 1; ++i) { e.Gr.DrawLine( _boundsPen, _points[i].X, _points[i].Y, _points[i + 1].X, _points[i + 1].Y ); } DrawEventArgs args = new DrawEventArgs(e); args.Draw = true; foreach(GrPoint pnt in _points) pnt.Draw(args); } if (e.Draw || e.Edited == this) { DrawSpline(e.Gr); } }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { args.Geometry.SpatialReference = MyMap.SpatialReference; Graphic graphic = new Graphic(){ Geometry = args.Geometry }; if (args.Geometry is Polyline) graphic.Symbol = LayoutRoot.Resources["DefaultLineSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol; else graphic.Symbol = LayoutRoot.Resources["DefaultMarkerSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol; graphicsLayer.Graphics.Add(graphic); if (graphicsLayer.Graphics.Count == 1) MyDrawObject.DrawMode = DrawMode.Point; else if (graphicsLayer.Graphics.Count == 2) { MyDrawObject.IsEnabled = false; GeometryService geometryService = new GeometryService("http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.DistanceCompleted += GeometryService_DistanceCompleted; geometryService.Failed += GeometryService_Failed; MyDrawObject.DrawMode = DrawMode.Polyline; DistanceParameters distanceParameters = new DistanceParameters() { DistanceUnit = LinearUnit.SurveyMile, Geodesic = true }; geometryService.DistanceAsync(graphicsLayer.Graphics[0].Geometry, graphicsLayer.Graphics[1].Geometry,distanceParameters); ResponseTextBlock.Text = "The distance between geometries is... "; } }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { ESRI.ArcGIS.Client.Geometry.MapPoint point = args.Geometry as ESRI.ArcGIS.Client.Geometry.MapPoint; point.SpatialReference = MyMap.SpatialReference; System.Windows.Point screenPnt = MyMap.MapToScreen(point); // Account for difference between Map and application origin GeneralTransform generalTransform = MyMap.TransformToVisual(null); System.Windows.Point transformScreenPnt = generalTransform.Transform(screenPnt); IEnumerable<Graphic> selected = parcelGraphicsLayer.FindGraphicsInHostCoordinates(transformScreenPnt); foreach (Graphic g in selected) if (g.Selected) { g.UnSelect(); selectedGraphics.Remove(g); } else { g.Select(); selectedGraphics.Add(g); } if (selectedGraphics.Count > 1) { UnionButton.IsEnabled = true; MyDrawObject.IsEnabled = false; } else UnionButton.IsEnabled = false; }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { ESRI.ArcGIS.Client.Geometry.Polygon polygon = args.Geometry as ESRI.ArcGIS.Client.Geometry.Polygon; polygon.SpatialReference = MyMap.SpatialReference; Graphic graphic = new Graphic() { Symbol = LayoutRoot.Resources["DefaultFillSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol, Geometry = polygon, }; GeometryService geometryService = new GeometryService("http://serverapps101.esri.com/arcgis/rest/services/Geometry/GeometryServer"); geometryService.AreasAndLengthsCompleted += GeometryService_AreasAndLengthsCompleted; geometryService.Failed += GeometryService_Failed; GraphicsLayer graphicsLayer = MyMap.Layers["MyGraphicsLayer"] as GraphicsLayer; graphicsLayer.Graphics.Add(graphic); List<Graphic> graphicList = new List<Graphic>(); graphicList.Add(graphic); // Since there are multiple overloads for AreasAndLengthsAsync, make sure to use appropriate signature with correct parameter types. geometryService.AreasAndLengthsAsync(graphicList,null,null, (CalculationType)calculationTypeCombo.SelectedValue ); // GeometryService.AreasAndLengths returns distances and areas in the units of the spatial reference. // The units in the map view's projection is decimal degrees. // Use the Project method to convert graphic points to a projection that uses a measured unit (e.g. meters). // If the map units are in measured units, the call to Project is unnecessary. // Important: Use a projection appropriate for your area of interest. }
void myDrawObject_DrawComplete(object sender, DrawEventArgs e) { _geometryService.CancelAsync(); _queryTask.CancelAsync(); Graphic clickGraphic = new Graphic(); clickGraphic.Symbol = LayoutRoot.Resources["DefaultMarkerSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol; clickGraphic.Geometry = e.Geometry; // Input spatial reference for buffer operation defined by first feature of input geometry array clickGraphic.Geometry.SpatialReference = MyMap.SpatialReference; _pointAndBufferGraphicsLayer.ClearGraphics(); _resultsGraphicsLayer.ClearGraphics(); clickGraphic.SetZIndex(2); _pointAndBufferGraphicsLayer.Graphics.Add(clickGraphic); // If buffer spatial reference is GCS and unit is linear, geometry service will do geodesic buffering ESRI.ArcGIS.Client.Tasks.BufferParameters bufferParams = new ESRI.ArcGIS.Client.Tasks.BufferParameters() { BufferSpatialReference = new SpatialReference(4326), OutSpatialReference = MyMap.SpatialReference, Unit = LinearUnit.Meter, }; bufferParams.Distances.Add(100); bufferParams.Features.Add(clickGraphic); _geometryService.BufferAsync(bufferParams); }
public override void Draw(DrawEventArgs e) { if (Region.Contours.Count == 0 || Region.Contours[0].Points.Count < 3) { base.Draw(e); return; } if (e.Draw || e.Edited == this) { DrawNonOriented(e.Gr); /* if (_isOriented) { DrawOriented(e.Gr); } else { DrawNonOriented(e.Gr); }*/ } if(e.Edited != this) { e.Draw = false; } base.Draw(e); }
void myDrawObject_DrawComplete(object sender, DrawEventArgs e) { myDrawObject.IsEnabled = false; GraphicsLayer graphicsLayer = MyMap.Layers["MyGraphicsLayer"] as GraphicsLayer; graphicsLayer.ClearGraphics(); Graphic graphic = new ESRI.ArcGIS.Client.Graphic() { Geometry = e.Geometry, Symbol = LayoutRoot.Resources["DefaultClickSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol }; graphic.SetZIndex(1); graphicsLayer.Graphics.Add(graphic); GeometryService geometryService = new GeometryService("http://serverapps101.esri.com/arcgis/rest/services/Geometry/GeometryServer"); geometryService.BufferCompleted += GeometryService_BufferCompleted; geometryService.Failed += GeometryService_Failed; BufferParameters bufferParams = new BufferParameters() { Unit = LinearUnit.StatuteMile, OutSpatialReference = MyMap.SpatialReference, Geodesic = true }; bufferParams.Features.Add(graphic); bufferParams.Distances.Add(5); geometryService.BufferAsync(bufferParams); }
private void myDrawingSurface_Draw(object sender, DrawEventArgs e) { game.state.Update(e); game.state.Draw(e); ThreadPool.QueueUserWorkItem(o => { Dispatcher.BeginInvoke(new Action(() => { lScore.Content = Player.Score; })); }); ThreadPool.QueueUserWorkItem(o => { Dispatcher.BeginInvoke(new Action(() => { label1.Content = Player.LivesLeft; })); }); if (Player.LivesLeft == 0) { Dispatcher.BeginInvoke(new Action(() => { this.Content = new GameOver(); })); } e.InvalidateSurface(); }
private void myDrawingSurface_Draw( object sender, DrawEventArgs e ) { // Render scene //sample.Go(); // Let's go for another turn! e.InvalidateSurface(); }
void drawObject_DrawComplete(object sender, DrawEventArgs e) { if (e.Geometry.Extent.Height == 0 | e.Geometry.Extent.Width == 0) { MessageBox.Show("Please click and drag a box to define an extent", "Error", MessageBoxButton.OK); return; } myDrawObject.IsEnabled = false; ESRI.ArcGIS.Client.Graphic graphic = new ESRI.ArcGIS.Client.Graphic() { Geometry = e.Geometry, Symbol = LayoutRoot.Resources["DrawFillSymbol"] as Symbol }; graphicsLayer.Graphics.Add(graphic); ESRI.ArcGIS.Client.Geometry.Envelope aoiEnvelope = e.Geometry as ESRI.ArcGIS.Client.Geometry.Envelope; string SOEurl = "http://sampleserver4.arcgisonline.com/ArcGIS/rest/services/Elevation/ESRI_Elevation_World/MapServer/exts/ElevationsSOE/ElevationLayers/1/GetElevationData?"; SOEurl += string.Format(System.Globalization.CultureInfo.InvariantCulture, "Extent={{\"xmin\" : {0}, \"ymin\" : {1}, \"xmax\" : {2}, \"ymax\" :{3},\"spatialReference\" : {{\"wkid\" : {4}}}}}&Rows={5}&Columns={6}&f=json", aoiEnvelope.XMin, aoiEnvelope.YMin, aoiEnvelope.XMax, aoiEnvelope.YMax, MyMap.SpatialReference.WKID, HeightTextBox.Text, WidthTextBox.Text); webClient.OpenReadAsync(new Uri(SOEurl)); }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { MyDrawObject.IsEnabled = false; ESRI.ArcGIS.Client.Geometry.Polygon polygon = args.Geometry as ESRI.ArcGIS.Client.Geometry.Polygon; polygon.SpatialReference = MyMap.SpatialReference; geometryService.SimplifyAsync(new List<Graphic>() { new Graphic(){ Geometry = polygon} }); }
protected override void PreDrawObjects(DrawEventArgs e) { base.PreDrawObjects(e); var vp = e.Display.Viewport; if (vp.DisplayMode.EnglishName.ToLower() == "wireframe") e.Display.DrawMeshWires(m_mesh, m_color); else e.Display.DrawMeshShaded(m_mesh, m_material); }
private void DrawScene(Scene scene, DrawEventArgs e) { if (_isSoftwareRendered) return; ProcessKeyboardInput(scene); scene.Draw(); // invalidate to get a callback next frame e.InvalidateSurface(); }
public override void Draw(DrawEventArgs e) { if (e.Draw || e.Edited == this) { GrUtil.DrawLine(e.Gr, this.Color, _p1.X, _p1.Y, _p2.X, _p2.Y); } e.Draw = (e.Edited == this); _p1.Draw(e); _p2.Draw(e); }
private void myDrawingSurface_Draw(object sender, DrawEventArgs e) { this.appReference.MainViewModel.Manager.Tick(); // Render scene scene.Draw(); // Let's go for another turn! e.InvalidateSurface(); }
public override void OnPaint(DrawEventArgs pea) { // After all the children have done their drawing into our backing buffer // Display the backing buffer on the screen. int x = pea.ClipRect.Left; int y = pea.ClipRect.Top; int width = pea.ClipRect.Width; int height = pea.ClipRect.Height; // Render our image to the actual screen base.GraphPort.AlphaBlend(x, y, width, height, fBackingBuffer, x, y, width, height, 255); }
private async void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { try { _myDrawObject.IsEnabled = false; if (_cts != null) _cts.Cancel(); _cts = new CancellationTokenSource(); QueryTask queryTask = new QueryTask("http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/TaxParcel/AssessorsParcelCharacteristics/MapServer/1"); Query query = new Query() { Geometry = args.Geometry, ReturnGeometry = true, OutSpatialReference = MyMap.SpatialReference }; QueryResult parcelsToIntersectResult = await queryTask.ExecuteTaskAsync(query, _cts.Token); List<Graphic> graphicList = new List<Graphic>(); graphicList.Add(new Graphic() { Geometry = args.Geometry }); SimplifyResult simplifiedIntersectGeometryResult = await _geometryService.SimplifyTaskAsync(graphicList, _cts.Token); IntersectResult intersectedParcelsResult = await _geometryService.IntersectTaskAsync(parcelsToIntersectResult.FeatureSet.ToList(), simplifiedIntersectGeometryResult.Results[0].Geometry, _cts.Token); Random random = new Random(); foreach (Graphic g in intersectedParcelsResult.Results) { SimpleFillSymbol symbol = new SimpleFillSymbol() { Fill = new System.Windows.Media.SolidColorBrush( System.Windows.Media.Color.FromArgb(255, (byte)random.Next(0, 255), (byte)random.Next(0, 255), (byte)random.Next(0, 255))), BorderBrush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Black), BorderThickness = 1 }; g.Symbol = symbol; _intersectGraphicsLayer.Graphics.Add(g); } } catch (Exception ex) { if (ex is ServiceException) { MessageBox.Show(String.Format("{0}: {1}", (ex as ServiceException).Code.ToString(), (ex as ServiceException).Details[0]), "Error", MessageBoxButton.OK); return; } } }
public override void Draw(DrawEventArgs e) { if (e.Draw || e.Edited == this) { DrawSpline(e.Gr); } if (e.Edited != this) { e.Draw = false; } _line1.Draw(e); _line2.Draw(e); }
void drawObject_DrawComplete(object sender, DrawEventArgs e) { myDrawObject.IsEnabled = false; ESRI.ArcGIS.Client.Geometry.Envelope aoiEnvelope = e.Geometry as ESRI.ArcGIS.Client.Geometry.Envelope; string SOEurl = "http://sampleserver4.arcgisonline.com/ArcGIS/rest/services/Elevation/ESRI_Elevation_World/MapServer/exts/ElevationsSOE/ElevationLayers/1/GetElevationData?"; SOEurl += string.Format("Extent={{\"xmin\" : {0}, \"ymin\" : {1}, \"xmax\" : {2}, \"ymax\" :{3},\"spatialReference\" : {{\"wkid\" : {4}}}}}&Rows={5}&Columns={6}&f=json", aoiEnvelope.XMin, aoiEnvelope.YMin, aoiEnvelope.XMax, aoiEnvelope.YMax, MyMap.SpatialReference.WKID, HeightTextBox.Text, WidthTextBox.Text); webClient.OpenReadAsync(new Uri(SOEurl), aoiEnvelope); }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { MyDrawObject.IsEnabled = false; ESRI.ArcGIS.Client.Geometry.Polyline polyline = args.Geometry as ESRI.ArcGIS.Client.Geometry.Polyline; polyline.SpatialReference = MyMap.SpatialReference; GeometryService geometryService = new GeometryService("http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.CutCompleted += GeometryService_CutCompleted; geometryService.Failed += GeometryService_Failed; geometryService.CutAsync(parcelGraphicsLayer.Graphics.ToList(), polyline); }
public void Draw(DrawEventArgs drawEventArgs, SpriteBatch spriteBatch) { for (int i = 0; i < numY; i++) { for (int j = 0; j < numX ; j++) { Tile currentTile = Grid[j, i]; spriteBatch.Draw(currentTile.texture, currentTile.bounds, Color.White); if (currentTile.coin != null) { Grid[j, i].coin.Draw(drawEventArgs, spriteBatch); } } } }
private void SurfaceOnDraw(object sender, DrawEventArgs args) { var graphicsDevice = GraphicsDeviceManager.Current.GraphicsDevice; graphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0); graphicsDevice.RasterizerState = RasterizerState.CullNone; graphicsDevice.BlendState = BlendState.AlphaBlend; graphicsDevice.DepthStencilState = DepthStencilState.Default; if (this.ApplicationViewModel.Image != null) { this.ApplicationViewModel.Image.Draw(GraphicsDeviceManager.Current.GraphicsDevice, aspectRatio); } args.InvalidateSurface(); }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { outputGraphicsLayer.ClearGraphics(); ESRI.ArcGIS.Client.Geometry.MapPoint point = args.Geometry as ESRI.ArcGIS.Client.Geometry.MapPoint; point.SpatialReference = MyMap.SpatialReference; Graphic graphic = new Graphic() { Symbol = LayoutRoot.Resources["DefaultMarkerSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol, Geometry = point }; inputGraphicsLayer.Graphics.Add(graphic); if (inputGraphicsLayer.Graphics.Count >= 3) ConvexButton.IsEnabled = true; }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { MyDrawObject.IsEnabled = false; if (MyDrawObject.DrawMode == DrawMode.Point) { ESRI.ArcGIS.Client.Geometry.MapPoint point = args.Geometry as ESRI.ArcGIS.Client.Geometry.MapPoint; point.SpatialReference = MyMap.SpatialReference; System.Windows.Point screenPnt = MyMap.MapToScreen(point); // Account for difference between Map and application origin GeneralTransform generalTransform = MyMap.TransformToVisual(Application.Current.RootVisual); System.Windows.Point transformScreenPnt = generalTransform.Transform(screenPnt); IEnumerable<Graphic> selected = parcelGraphicsLayer.FindGraphicsInHostCoordinates(transformScreenPnt); if (selected.ToArray().Length <= 0) { MyDrawObject.IsEnabled = true; return; } selectedGraphic = selected.ToList()[0] as Graphic; selectedGraphic.Select(); MyDrawObject.DrawMode = DrawMode.Polyline; MyDrawObject.IsEnabled = true; InfoTextBlock.Text = LayoutRoot.Resources["EndText"] as string; } else { ESRI.ArcGIS.Client.Geometry.Polyline polyline = args.Geometry as ESRI.ArcGIS.Client.Geometry.Polyline; polyline.SpatialReference = MyMap.SpatialReference; GeometryService geometryService = new GeometryService("http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.ReshapeCompleted += GeometryService_ReshapeCompleted; geometryService.Failed += GeometryService_Failed; geometryService.ReshapeAsync(selectedGraphic.Geometry, polyline); } }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { MyDrawObject.IsEnabled = false; offsetGraphicsLayer.ClearGraphics(); ESRI.ArcGIS.Client.Geometry.MapPoint point = args.Geometry as ESRI.ArcGIS.Client.Geometry.MapPoint; point.SpatialReference = MyMap.SpatialReference; System.Windows.Point screenPnt = MyMap.MapToScreen(point); // Account for difference between Map and application origin GeneralTransform generalTransform = MyMap.TransformToVisual(null); System.Windows.Point transformScreenPnt = generalTransform.Transform(screenPnt); IEnumerable<Graphic> selected = parcelGraphicsLayer.FindGraphicsInHostCoordinates(transformScreenPnt); List<Graphic> graphicsList = new List<Graphic>(); foreach (Graphic g in selected) { graphicsList.Add(g); } if (graphicsList.Count < 1) { MyDrawObject.IsEnabled = true; return; } geometryService = new GeometryService("http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.OffsetCompleted += GeometryService_OffsetCompleted; geometryService.Failed += GeometryService_Failed; OffsetParameters offsetParameters = new OffsetParameters() { BevelRatio = 1.1, OffsetDistance = -30, OffsetHow = GeometryOffset.Bevelled, OffsetUnit = LinearUnit.Meter, Simplify = true }; geometryService.OffsetAsync(graphicsList, offsetParameters); }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { ESRI.ArcGIS.Client.Geometry.Polyline polyline = args.Geometry as ESRI.ArcGIS.Client.Geometry.Polyline; polyline.SpatialReference = MyMap.SpatialReference; Graphic graphic = new Graphic() { Symbol = LayoutRoot.Resources["DefaultLineSymbol"] as ESRI.ArcGIS.Client.Symbols.Symbol, Geometry = polyline }; GeometryService geometryService = new GeometryService("http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.LengthsCompleted += GeometryService_LengthsCompleted; geometryService.Failed += GeometryService_Failed; GraphicsLayer graphicsLayer = MyMap.Layers["MyGraphicsLayer"] as GraphicsLayer; graphicsLayer.Graphics.Add(graphic); geometryService.LengthsAsync(graphicsLayer.Graphics.ToList(), LinearUnit.SurveyMile, CalculationType.Geodesic, null); }
public override void Draw(DrawEventArgs e) { if (e.Draw) { Point pnt = GetObjectToWorldTransform().Apply(0, 0); Rectangle rect = new Rectangle( pnt.X - _width / 2, pnt.Y - _height / 2, _width - 1, _height - 1 ); e.Gr.FillEllipse( Brushes.Blue, rect ); } }
protected override void PreDrawObjects(DrawEventArgs e) { base.PreDrawObjects(e); var c_plane = e.Display.Viewport.ConstructionPlane(); var x_color = Rhino.ApplicationSettings.AppearanceSettings.GridXAxisLineColor; var y_color = Rhino.ApplicationSettings.AppearanceSettings.GridYAxisLineColor; var z_color = Rhino.ApplicationSettings.AppearanceSettings.GridZAxisLineColor; e.Display.PushDepthWriting(false); e.Display.PushDepthTesting(false); e.Display.DrawPoint(c_plane.Origin, System.Drawing.Color.White); e.Display.DrawArrow(new Line(c_plane.Origin, new Vector3d(c_plane.XAxis) * 10.0), x_color); e.Display.DrawArrow(new Line(c_plane.Origin, new Vector3d(c_plane.YAxis) * 10.0), y_color); e.Display.DrawArrow(new Line(c_plane.Origin, new Vector3d(c_plane.ZAxis) * 10.0), z_color); e.Display.PopDepthWriting(); e.Display.PopDepthTesting(); }
private void MyDrawObject_DrawComplete(object sender, DrawEventArgs args) { MyDrawObject.IsEnabled = false; resultsLayer.ClearGraphics(); Polyline polyline = args.Geometry as Polyline; polyline.SpatialReference = MyMap.SpatialReference; geometryService = new GeometryService("http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer"); geometryService.TrimExtendCompleted += GeometryService_TrimExtendCompleted; geometryService.Failed += GeometryService_Failed; List<Polyline> polylineList = new List<Polyline>(); foreach (Graphic g in polylineLayer.Graphics) polylineList.Add(g.Geometry as Polyline); geometryService.TrimExtendAsync(polylineList, polyline, CurveExtension.DefaultCurveExtension); }
public void DrawEditor(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { layer.World.RenderDirectionAxis(Axis, this.WorldMatrix(), 30); }
public static void UpdateContext(DrawEventArgs args) { _hglrc = OpenGL.wglGetCurrentContext(); _viewSerialNumber = args.Display.Viewport.ParentView.RuntimeSerialNumber; }
private void DrawObject(IObject3D object3D, List <Object3DView> transparentMeshes, bool parentSelected, DrawEventArgs e) { foreach (var item in object3D.VisibleMeshes()) { // check for correct persistable rendering if (MeshViewerWidget.ViewOnlyTexture != null && item.Mesh.Faces.Count > 0) { ImageBuffer faceTexture = null; item.Mesh.FaceTexture.TryGetValue((item.Mesh.Faces[0], 0), out faceTexture); bool hasPersistableTexture = faceTexture == MeshViewerWidget.ViewOnlyTexture; if (item.WorldPersistable()) { if (hasPersistableTexture) { // make sure it does not have the view only texture item.Mesh.RemoveTexture(ViewOnlyTexture, 0); } } else { if (!hasPersistableTexture) { // make sure it does have the view only texture var aabb = item.Mesh.GetAxisAlignedBoundingBox(); var matrix = Matrix4X4.CreateScale(.5, .5, 1); matrix *= Matrix4X4.CreateRotationZ(MathHelper.Tau / 8); item.Mesh.PlaceTexture(ViewOnlyTexture, matrix); } } } Color drawColor = GetItemColor(item); bool isDebugItem = (item == scene.DebugItem); if (!sceneContext.ViewState.ModelView) { if (modelRenderStyle == ModelRenderStyle.WireframeAndSolid) { drawColor = gCodeMeshColor; } else if (modelRenderStyle == ModelRenderStyle.Wireframe) { drawColor = new Color(gCodeMeshColor, 1); } else if (modelRenderStyle == ModelRenderStyle.None) { drawColor = Color.Transparent; } } if ((drawColor.alpha == 255 && !item.Mesh.FaceTexture.Where((ft) => ft.Value.HasTransparency).Any()) || isDebugItem) { // Render as solid GLHelper.Render(item.Mesh, drawColor, item.WorldMatrix(), sceneContext.ViewState.RenderType, item.WorldMatrix() * World.ModelviewMatrix, darkWireframe); } else if (drawColor != Color.Transparent) { // Queue for transparency transparentMeshes.Add(new Object3DView(item, drawColor)); } var selectedItem = scene.SelectedItem; bool isSelected = selectedItem != null && (selectedItem.DescendantsAndSelf().Any((i) => i == item) || selectedItem.Parents <ModifiedMeshObject3D>().Any((mw) => mw == item)); if (isSelected && scene.DrawSelection) { var frustum = World.GetClippingFrustum(); var selectionColor = Color.White; double secondsSinceSelectionChanged = (UiThread.CurrentTimerMs - lastSelectionChangedMs) / 1000.0; if (secondsSinceSelectionChanged < .5) { var accentColor = Color.LightGray; if (secondsSinceSelectionChanged < .25) { selectionColor = Color.White.Blend(accentColor, Quadratic.InOut(secondsSinceSelectionChanged * 4)); } else { selectionColor = accentColor.Blend(Color.White, Quadratic.InOut((secondsSinceSelectionChanged - .25) * 4)); } Invalidate(); } RenderSelection(item, frustum, selectionColor); } #if DEBUG if (isDebugItem) { var frustum = World.GetClippingFrustum(); var aabb = object3D.GetAxisAlignedBoundingBox(Matrix4X4.Identity); World.RenderAabb(aabb, Matrix4X4.Identity, debugBorderColor, 1); if (item.Mesh != null) { GLHelper.Render(item.Mesh, debugBorderColor, item.WorldMatrix(), RenderTypes.Wireframe, item.WorldMatrix() * World.ModelviewMatrix); } } #endif // RenderNormals(renderData); // turn lighting back on after rendering selection outlines GL.Enable(EnableCap.Lighting); } }
void IInternalGameModule.Draw(DrawEventArgs e) { Draw(); _updater.Drawing = false; }
public void DrawEditor(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { var child = this.Children.FirstOrDefault(); if (child is IPathObject pathObject) { // draw the line that is the rotation point var aabb = this.GetAxisAlignedBoundingBox(); var vertexSource = this.VertexSource.Transform(Matrix); var bounds = vertexSource.GetBounds(); var lineX = bounds.Left + AxisPosition.Value(this); var start = new Vector3(lineX, aabb.MinXYZ.Y, aabb.MinXYZ.Z); var end = new Vector3(lineX, aabb.MaxXYZ.Y, aabb.MinXYZ.Z); layer.World.Render3DLine(start, end, Color.Red, true); layer.World.Render3DLine(start, end, Color.Red.WithAlpha(20), false); } }
/// <summary> /// Allows the game to run logic such as updating the world, /// checking for collisions, gathering input, and playing audio. /// </summary> public void Update(DrawEventArgs drawEventArgs) { HandleInput(); level.Update(drawEventArgs); }
public void DrawEditor(InteractionLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e, ref bool suppressNormalDraw) { if (layer.Scene.SelectedItem != null && layer.Scene.SelectedItem.DescendantsAndSelf().Where((i) => i == this).Any()) { layer.World.RenderAxis(ScaleAbout, this.WorldMatrix(), 30, 1); } }
public void DrawEditor(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { var parentOfSourceItems = this.SourceContainer.DescendantsAndSelfMultipleChildrenFirstOrSelf(); var sourceItems = parentOfSourceItems.Children.ToList(); foreach (var paintItem in sourceItems) { var paintItemResults = this.Children.Where(i => i.OwnerID == paintItem.ID); var wasSelected = ComputedChildren.Contains(paintItem.ID); var currentlySelected = SelectedChildren.Contains(paintItem.ID); if (currentlySelected) { // if this is selected always paint a transparent source foreach (var item in paintItem.VisibleMeshes()) { transparentMeshes.Add(new Object3DView(item, new Color(item.WorldColor(this.SourceContainer), 80))); } // if it was also selected in before (the results are right) if (wasSelected) { // paint solid results if (paintItemResults != null) { foreach (var paintItemResult in paintItemResults) { foreach (var item in paintItemResult.VisibleMeshes()) { GLHelper.Render(item.Mesh, item.WorldColor(), item.WorldMatrix(), RenderTypes.Outlines, item.WorldMatrix() * layer.World.ModelviewMatrix); } } } } } else if (wasSelected) { // it is not selected now but was selected before (changed state) // pant the solid source foreach (var item in paintItem.VisibleMeshes()) { GLHelper.Render(item.Mesh, item.WorldColor(), item.WorldMatrix(), RenderTypes.Outlines, item.WorldMatrix() * layer.World.ModelviewMatrix); } } else // it is not selected now and was not before (same state) { // paint the results if (paintItemResults != null && paintItemResults.Count() > 0) { foreach (var paintItemResult in paintItemResults) { foreach (var item in paintItemResult.VisibleMeshes()) { GLHelper.Render(item.Mesh, item.WorldColor(), item.WorldMatrix(), RenderTypes.Outlines, item.WorldMatrix() * layer.World.ModelviewMatrix); } } } else // we don't have any results yet { foreach (var item in paintItem.VisibleMeshes()) { GLHelper.Render(item.Mesh, item.WorldColor(), item.WorldMatrix(), RenderTypes.Outlines, item.WorldMatrix() * layer.World.ModelviewMatrix); } } } } }
public void DrawEditor(Object3DControlsLayer layer, DrawEventArgs e) { this.DrawPath(); }
public void AddEditorTransparents(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { }
public override void Reset(DrawEventArgs args) { }
public void DrawEditor(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { var aabb = this.WorldAxisAlignedBoundingBox(); layer.World.RenderCylinderOutline(Matrix4X4.Identity, aabb.Center, Diameter, aabb.ZSize, 90, Color.Red); // layer.World.RenderCylinderOutline(Matrix4X4.Identity, Vector3.Zero, Diameter, aabb.ZSize, 30, Color.Green); }
private void DrawMouse(object drawingWidget, DrawEventArgs e) { automationRunner.RenderMouse(windowToDrawSimulatedMouseOn, e.graphics2D); }
private void xrCheckBox2_Draw(object sender, DrawEventArgs e) { }
private void Form_Drawn(object sender, DrawEventArgs e) { // draw the tiles and camera rectangle DrawMapTiles(e.SpriteBatch); DrawCameraRect(e.SpriteBatch); }
/// <summary> /// Draws a gem in the appropriate color. /// </summary> public void Draw(DrawEventArgs drawEventArgs, SpriteBatch spriteBatch) { spriteBatch.Draw(texture, Position, null, Color, 0.0f, origin, 1.0f, SpriteEffects.None, 0.0f); }
public void DrawEditor(InteractionLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e, ref bool suppressNormalDraw) { var sourceAabb = this.SourceContainer.GetAxisAlignedBoundingBox(); var center = sourceAabb.Center + new Vector3(RotationOffset); // render the top and bottom rings layer.World.RenderCylinderOutline(this.WorldMatrix(), center, 1, sourceAabb.ZSize, 15, Color.Red, Color.Red, 5); // turn the lighting back on GL.Enable(EnableCap.Lighting); }
public void DrawEditor(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { var sourceAabb = this.SourceContainer.GetAxisAlignedBoundingBox(); var distance = Diameter / 2 + sourceAabb.YSize / 2; var center = sourceAabb.Center + new Vector3(0, BendCcw ? distance : -distance, 0); center.X -= sourceAabb.XSize / 2 - (StartPercent / 100.0) * sourceAabb.XSize; // render the top and bottom rings layer.World.RenderCylinderOutline(this.WorldMatrix(), center, Diameter, sourceAabb.ZSize, 100, Color.Red, Color.Transparent); // render the split lines var radius = Diameter / 2; var circumference = MathHelper.Tau * radius; var xxx = sourceAabb.XSize * (StartPercent / 100.0); var startAngle = MathHelper.Tau * 3 / 4 - xxx / circumference * MathHelper.Tau; layer.World.RenderCylinderOutline(this.WorldMatrix(), center, Diameter, sourceAabb.ZSize, (int)Math.Max(0, Math.Min(100, this.MinSidesPerRotation)), Color.Transparent, Color.Red, phase: startAngle); // turn the lighting back on GL.Enable(EnableCap.Lighting); }
protected virtual DrawEventArgs OnBeforeDraw(DrawEventArgs arg) { return(this.BeforeDraw?.Invoke(arg)); }
private void Draw_GlTransparentContent(object sender, DrawEventArgs e) { var gcodeOptions = sceneContext.RendererOptions; switch (gcodeOptions.GCodeModelView) { case "Wireframe": modelRenderStyle = ModelRenderStyle.Wireframe; break; case "Semi-Transparent": modelRenderStyle = ModelRenderStyle.WireframeAndSolid; break; default: modelRenderStyle = ModelRenderStyle.None; break; } // Draw solid objects, extract transparent var transparentMeshes = new List <Object3DView>(); foreach (var object3D in scene.Children) { if (object3D.Visible) { DrawObject(object3D, transparentMeshes, false, e); } } transparentMeshes.Sort(BackToFrontXY); var bedNormalInViewSpace = Vector3.TransformNormal(Vector3.UnitZ, World.ModelviewMatrix).GetNormal(); var pointOnBedInViewSpace = Vector3.Transform(new Vector3(10, 10, 0), World.ModelviewMatrix); var lookingDownOnBed = Vector3.Dot(bedNormalInViewSpace, pointOnBedInViewSpace) < 0; if (lookingDownOnBed) { RenderBedMesh(lookingDownOnBed); } var wireColor = Color.Transparent; switch (modelRenderStyle) { case ModelRenderStyle.Wireframe: wireColor = darkWireframe; break; case ModelRenderStyle.WireframeAndSolid: wireColor = lightWireframe; break; } // Draw transparent objects foreach (var item in transparentMeshes) { var object3D = item.Object3D; GLHelper.Render( object3D.Mesh, item.Color, object3D.WorldMatrix(), RenderTypes.Outlines, object3D.WorldMatrix() * World.ModelviewMatrix, wireColor); } if (!lookingDownOnBed) { RenderBedMesh(lookingDownOnBed); } // we don't want to render the bed or build volume before we load a model. if (scene.HasChildren() || AllowBedRenderingWhenEmpty) { if (false) // this is code to draw a small axis indicator { double big = 10; double small = 1; Mesh xAxis = PlatonicSolids.CreateCube(big, small, small); GLHelper.Render(xAxis, Color.Red); Mesh yAxis = PlatonicSolids.CreateCube(small, big, small); GLHelper.Render(yAxis, Color.Green); Mesh zAxis = PlatonicSolids.CreateCube(small, small, big); GLHelper.Render(zAxis, Color.Blue); } } DrawInteractionVolumes(e); if (scene.DebugItem?.Mesh != null) { var debugItem = scene.DebugItem; GLHelper.Render(debugItem.Mesh, debugBorderColor, debugItem.WorldMatrix(), RenderTypes.Wireframe, debugItem.WorldMatrix() * World.ModelviewMatrix); } }
private void DrawGlContent(DrawEventArgs e) { var gcodeOptions = sceneContext.RendererOptions; if (gcodeOptions.GCodeModelView) { modelRenderStyle = ModelRenderStyle.WireframeAndSolid; } else { modelRenderStyle = ModelRenderStyle.None; } foreach (var drawable in drawables.Where(d => d.DrawStage == DrawStage.First)) { if (drawable.Enabled) { drawable.Draw(this, e, Matrix4X4.Identity, this.World); } } GLHelper.SetGlContext(this.World, renderSource.TransformToScreenSpace(renderSource.LocalBounds), lighting); foreach (var drawable in drawables.Where(d => d.DrawStage == DrawStage.OpaqueContent)) { if (drawable.Enabled) { drawable.Draw(this, e, Matrix4X4.Identity, this.World); } } // Draw solid objects, extract transparent var transparentMeshes = new List <Object3DView>(); var selectedItem = scene.SelectedItem; bool suppressNormalDraw = false; if (selectedItem != null) { // Invoke existing IEditorDraw when iterating items if (selectedItem is IEditorDraw editorDraw) { // TODO: Putting the drawing code in the IObject3D means almost certain bindings to MatterControl in IObject3D. If instead // we had a UI layer object that used binding to register scene drawing hooks for specific types, we could avoid the bindings editorDraw.DrawEditor(this, transparentMeshes, e, ref suppressNormalDraw); } } foreach (var item in scene.Children) { if (item.Visible && (item != selectedItem || suppressNormalDraw == false)) { DrawObject(item, transparentMeshes, e); } } if (sceneContext.Printer?.Connection?.serialPort is PrinterEmulator.Emulator emulator) { void NozzlePositionChanged(object s, EventArgs e2) { // limit max number of updates per second to 10 if (UiThread.CurrentTimerMs > lastEmulatorDrawMs + 100) { UiThread.RunOnIdle(Invalidate); // set it to now lastEmulatorDrawMs = UiThread.CurrentTimerMs; } } var matrix = Matrix4X4.CreateTranslation(emulator.CurrentPosition + new Vector3(.5, .5, 5)); GLHelper.Render(emulatorNozzleMesh, MaterialRendering.Color(emulator.ExtruderIndex), matrix, RenderTypes.Shaded, matrix * World.ModelviewMatrix); if (!emulatorHooked) { emulator.DestinationChanged += NozzlePositionChanged; emulatorHooked = true; } Closed += (s, e3) => emulator.DestinationChanged -= NozzlePositionChanged; } transparentMeshes.Sort(BackToFrontXY); var bedNormalInViewSpace = Vector3Ex.TransformNormal(Vector3.UnitZ, World.ModelviewMatrix).GetNormal(); var pointOnBedInViewSpace = Vector3Ex.Transform(new Vector3(10, 10, 0), World.ModelviewMatrix); var lookingDownOnBed = Vector3Ex.Dot(bedNormalInViewSpace, pointOnBedInViewSpace) < 0; floorDrawable.LookingDownOnBed = lookingDownOnBed; if (lookingDownOnBed) { floorDrawable.Draw(this, e, Matrix4X4.Identity, this.World); } var wireColor = Color.Transparent; switch (modelRenderStyle) { case ModelRenderStyle.Wireframe: wireColor = darkWireframe; break; case ModelRenderStyle.WireframeAndSolid: wireColor = lightWireframe; break; } // Draw transparent objects foreach (var item in transparentMeshes) { var object3D = item.Object3D; GLHelper.Render( object3D.Mesh, item.Color, object3D.WorldMatrix(), RenderTypes.Outlines, object3D.WorldMatrix() * World.ModelviewMatrix, wireColor, allowBspRendering: transparentMeshes.Count < 1000); } if (!lookingDownOnBed) { floorDrawable.Draw(this, e, Matrix4X4.Identity, this.World); } DrawInteractionVolumes(e); foreach (var drawable in drawables.Where(d => d.DrawStage == DrawStage.TransparentContent)) { if (drawable.Enabled) { drawable.Draw(this, e, Matrix4X4.Identity, this.World); } } GLHelper.UnsetGlContext(); // Invoke DrawStage.Last item drawables foreach (var item in scene.Children) { // HACK: Consider how shared code in DrawObject can be reused to prevent duplicate execution bool isSelected = selectedItem != null && selectedItem.DescendantsAndSelf().Any((i) => i == item); foreach (var itemDrawable in itemDrawables.Where(d => d.DrawStage == DrawStage.Last && d.Enabled)) { itemDrawable.Draw(this, item, isSelected, e, Matrix4X4.Identity, this.World); } } // Invoke DrawStage.Last scene drawables foreach (var drawable in drawables.Where(d => d.DrawStage == DrawStage.Last)) { if (drawable.Enabled) { drawable.Draw(this, e, Matrix4X4.Identity, this.World); } } }
protected override void OnDraw(object sender, DrawEventArgs args) { var canvas = args.Canvas; canvas.ClipPath(clipPath); count = (count + 1) % fps; using (var paint = new SKPaint()) { paint.Color = SkyColor; paint.Style = SKPaintStyle.Fill; canvas.DrawPaint(paint); } var start = Resource.Background.Width / fps * count; canvas.DrawImage(Resource.Background, new SKRect(start, 0, Resource.Background.Width, Resource.Background.Height), new SKRect(0, 0, Geometry.Right - start, Geometry.Bottom)); if (start > 0) { canvas.DrawImage(Resource.Background, new SKRect(0, 0, start, Resource.Background.Height), new SKRect(Geometry.Right - start, 0, Geometry.Right, Geometry.Bottom)); } if (isStarted) { foreach (var child in pipes.ToArray()) { child.Move(-1); if (child.Geometry.Right <= 0) { Children.Remove(child); pipes.Remove(child); } /* * if (child.Geometry.Left < butterCat.Geometry.Right && * child.Geometry.Right > butterCat.Geometry.Left && * child.Geometry.Top < butterCat.Geometry.Bottom && * child.Geometry.Bottom > butterCat.Geometry.Top) * { * EndGame(); * } */ if (child.Geometry.IntersectsWith(butterCat.Geometry)) { EndGame(); } } int r; if (lastPipeTime++ > 80) { distance.Distance++; if ((r = random.Next(0, 101)) % 30 < 5) { var pipe = new Pipe(this, random.Next(50, 80), r > 30); pipes.Add(pipe); if (r > 60) { var pipe2 = new Pipe(this, random.Next(50, 120), false); pipes.Add(pipe2); } } lastPipeTime = 0; } } }
private void DrawObject(IObject3D object3D, List <Object3DView> transparentMeshes, DrawEventArgs e) { var selectedItem = scene.SelectedItem; foreach (var item in object3D.VisibleMeshes()) { // check for correct protection rendering ValidateViewOnlyTexturing(item); Color drawColor = this.GetItemColor(item, selectedItem); bool hasTransparentTextures = item.Mesh.FaceTextures.Any(ft => ft.Value.image.HasTransparency); if ((drawColor.alpha == 255 && !hasTransparentTextures) || (item == scene.DebugItem)) { // Render as solid GLHelper.Render(item.Mesh, drawColor, item.WorldMatrix(), sceneContext.ViewState.RenderType, item.WorldMatrix() * World.ModelviewMatrix, darkWireframe, () => Invalidate()); } else if (drawColor != Color.Transparent) { // Queue for transparency transparentMeshes.Add(new Object3DView(item, drawColor)); } bool isSelected = selectedItem != null && (item == selectedItem || item.Ancestors().Any(p => p == selectedItem)); // Invoke all item Drawables foreach (var drawable in itemDrawables.Where(d => d.DrawStage != DrawStage.Last && d.Enabled)) { drawable.Draw(this, item, isSelected, e, Matrix4X4.Identity, this.World); } // turn lighting back on after rendering selection outlines GL.Enable(EnableCap.Lighting); } }
internal void FireDrawControl(DrawEventArgs args) { OnDrawControl(args); }
public DrawGlContentEventArgs(bool zBuffered, DrawEventArgs e) : base(e.Graphics2D) { ZBuffered = zBuffered; }
public void DrawEditor(InteractionLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e, ref bool suppressNormalDraw) { if (layer.Scene.SelectedItem != null && layer.Scene.SelectedItem == this) { suppressNormalDraw = true; var removeObjects = this.SourceContainer.VisibleMeshes() .Where((i) => SelectedChildren.Contains(i.Name)).ToList(); var keepObjects = this.SourceContainer.VisibleMeshes() .Where((i) => !SelectedChildren.Contains(i.Name)).ToList(); foreach (var item in removeObjects) { transparentMeshes.Add(new Object3DView(item, new Color(item.WorldColor(SourceContainer), 128))); } foreach (var item in keepObjects) { var subtractChild = this.Children.Where(i => i.Name == item.Name).FirstOrDefault(); if (subtractChild != null) { GLHelper.Render(subtractChild.Mesh, subtractChild.Color, subtractChild.WorldMatrix(), RenderTypes.Outlines, subtractChild.WorldMatrix() * layer.World.ModelviewMatrix); } else { GLHelper.Render(item.Mesh, item.WorldColor(SourceContainer), item.WorldMatrix(), RenderTypes.Outlines, item.WorldMatrix() * layer.World.ModelviewMatrix); } } } }
public static uiAreaDrawParams ToLibuiAreaDrawParams(DrawEventArgs args) => throw new NotSupportedException("This conversion is not supported.");
public void Render3D(GCodeRenderInfo renderInfo, DrawEventArgs e) { if (renderInfo == null) { return; } if (layerVertexBuffer == null) { layerVertexBuffer = new List <GCodeVertexBuffer>(gCodeFileToDraw.LayerCount); for (int layerIndex = 0; layerIndex < gCodeFileToDraw.LayerCount; layerIndex++) { layerVertexBuffer.Add(null); featureStartIndex.Add(new List <int>()); featureEndIndex.Add(new List <int>()); } } for (int layerIndex = 0; layerIndex < gCodeFileToDraw.LayerCount; layerIndex++) { CreateFeaturesForLayerIfRequired(layerIndex); } if (lastRenderType != renderInfo.CurrentRenderType) { Clear3DGCode(); lastRenderType = renderInfo.CurrentRenderType; } if (renderFeatures.Count > 0) { for (int i = renderInfo.EndLayerIndex - 1; i >= renderInfo.StartLayerIndex; i--) { // If its the first render or we change what we are trying to render then create vertex data. if (layerVertexBuffer.Count > i && layerVertexBuffer[i] == null) { layerVertexBuffer[i] = Create3DDataForLayer(i, renderInfo); } } GL.Disable(EnableCap.Texture2D); GL.PushAttrib(AttribMask.EnableBit); GL.DisableClientState(ArrayCap.TextureCoordArray); GL.Enable(EnableCap.PolygonSmooth); if (renderInfo.EndLayerIndex - 1 > renderInfo.StartLayerIndex) { for (int i = renderInfo.StartLayerIndex; i < renderInfo.EndLayerIndex - 1; i++) { int featuresOnLayer = renderFeatures[i].Count; if (featuresOnLayer > 1 && layerVertexBuffer[i] != null) { layerVertexBuffer[i].RenderRange(0, featureEndIndex[i][featuresOnLayer - 1]); } } } // draw the partial layer of end-1 from startRatio to endRatio { int layerIndex = renderInfo.EndLayerIndex - 1; int featuresOnLayer = renderFeatures[layerIndex].Count; int startFeature = (int)(featuresOnLayer * renderInfo.FeatureToStartOnRatio0To1 + .5); startFeature = Math.Max(0, Math.Min(startFeature, featuresOnLayer)); int endFeature = (int)(featuresOnLayer * renderInfo.FeatureToEndOnRatio0To1 + .5); endFeature = Math.Max(0, Math.Min(endFeature, featuresOnLayer)); // try to make sure we always draw at least one feature if (endFeature <= startFeature) { endFeature = Math.Min(startFeature + 1, featuresOnLayer); } if (startFeature >= endFeature) { // This can only happen if the start and end are set to the last feature // Try to set the start feature to one from the end startFeature = Math.Max(endFeature - 1, 0); } if (endFeature > startFeature && layerVertexBuffer[layerIndex] != null) { int ellementCount = featureEndIndex[layerIndex][endFeature - 1] - featureStartIndex[layerIndex][startFeature]; layerVertexBuffer[layerIndex].RenderRange(featureStartIndex[layerIndex][startFeature], ellementCount); } } GL.PopAttrib(); } }
public void DrawEditor(Object3DControlsLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e) { this.DrawPath(); }
public void DrawEditor(InteractionLayer layer, List <Object3DView> transparentMeshes, DrawEventArgs e, ref bool suppressNormalDraw) { ImageToPathObject3D.DrawPath(this); }