Beispiel #1
0
        public override void OnRender(Graphics.Graphics graphics, BaseViewport viewport)
        {
            BaseViewportCamera   camera    = viewport.Camera;
            Matrix4              vpMatrix4 = camera.GetViewMatrix() * camera.GetProjMatrix();
            SolidRenderOperation render    = new SolidRenderOperation
            {
                Viewport = viewport,
                Graphics = graphics
            };

            // Draw all solids
            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                GL.Enable(EnableCap.DepthTest);
            }

            graphics.BeginDraw(vpMatrix4);

            foreach (MapObject mapObject in controller.SceneDocument)
            {
                if (mapObject.Selected)
                {
                    continue;
                }

                mapObject.PerformOperation(render);
            }

            controller.Selection?.PerformOperation(render);

            graphics.EndDraw();

            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                GL.Disable(EnableCap.DepthTest);
            }

            // Draw white wireframesolid on top of selection
            // only in Solid rendermode
            graphics.BeginDraw(vpMatrix4);
            if (viewport.RenderMode == BaseViewport.RenderModes.SOLID || viewport.RenderMode == BaseViewport.RenderModes.TEXTURED)
            {
                Color color = viewport.RenderMode == BaseViewport.RenderModes.TEXTURED ? Color.Yellow : Color.White;
                DoSolidAction(controller.Selection, (solid) =>
                {
                    graphics.DrawWireframeSolid(solid, color);
                });
            }
            graphics.EndDraw();

            // draw handles and blanket on top of everything else
            RenderAllVertexHandles(graphics, viewport);
            RenderBlanket(graphics, viewport);
        }
Beispiel #2
0
        private void RenderCrosshair(Graphics.Graphics graphics)
        {
            // render cross if captured the mouse
            if (CapturedMouse)
            {
                graphics.BeginDraw(MathExtensions.CreateOrthographicLH(mWidth, mHeight, 0, 1.0f));

                graphics.DrawSolidRectangle(Vector3.UnitX * -CROSS_SIZE + -Vector3.UnitY, Vector3.UnitX * CROSS_SIZE + -Vector3.UnitY,
                                            Vector3.UnitX * CROSS_SIZE + Vector3.UnitY, Vector3.UnitX * -CROSS_SIZE + Vector3.UnitY, Color.White);
                graphics.DrawSolidRectangle(Vector3.UnitY * -CROSS_SIZE + -Vector3.UnitX, Vector3.UnitY * -CROSS_SIZE + Vector3.UnitX,
                                            Vector3.UnitY * CROSS_SIZE + Vector3.UnitX, Vector3.UnitY * CROSS_SIZE + -Vector3.UnitX, Color.White);

                graphics.EndDraw();
            }
        }
Beispiel #3
0
        /// <summary>
        /// Renders a overlay for the viewport
        /// </summary>
        /// <param name="graphics"></param>
        protected virtual void RenderOverlay(Graphics.Graphics graphics)
        {
            Color   overlayColor = SystemColors.Control;
            Vector3 pointOne     = new Vector3(OVERLAY_GAP, OVERLAY_GAP, 0);
            Vector3 pointTwo     = new Vector3(mWidth - OVERLAY_GAP, OVERLAY_GAP, 0);
            Vector3 pointThree   = new Vector3(mWidth - OVERLAY_GAP, mHeight - OVERLAY_GAP, 0);
            Vector3 pointFour    = new Vector3(OVERLAY_GAP, mHeight - OVERLAY_GAP, 0);

            graphics.BeginDraw(Matrix4.CreateOrthographicOffCenter(0, mWidth, mHeight, 0, 0, 1));

            graphics.DrawLine(pointOne, pointTwo, Graphics.Graphics.LineType.LineNormal, overlayColor);
            graphics.DrawLine(pointTwo, pointThree, Graphics.Graphics.LineType.LineNormal, overlayColor);
            graphics.DrawLine(pointThree, pointFour, Graphics.Graphics.LineType.LineNormal, overlayColor);
            graphics.DrawLine(pointFour, pointOne, Graphics.Graphics.LineType.LineNormal, overlayColor);

            graphics.EndDraw();
        }
Beispiel #4
0
        /// <summary>
        /// Only draw for the current viewport that is doing the action
        /// </summary>
        /// <param name="graphics"></param>
        /// <param name="viewport"></param>
        private void RenderBlanket(Graphics.Graphics graphics, BaseViewport viewport)
        {
            if (viewport.ViewportType != BaseViewport.ViewportTypes.PERSPECTIVE &&
                coverBlanket.HasVolume2D && currentActionViewport == viewport.ViewportType)
            {
                Vector3 bottomLeft  = new Vector3(coverBlanket.Min.X, coverBlanket.Min.Y, 0);
                Vector3 bottomRight = new Vector3(coverBlanket.Max.X, coverBlanket.Min.Y, 0);
                Vector3 topRight    = new Vector3(coverBlanket.Max.X, coverBlanket.Max.Y, 0);
                Vector3 topLeft     = new Vector3(coverBlanket.Min.X, coverBlanket.Max.Y, 0);

                graphics.BeginDraw(Matrix4.CreateOrthographicOffCenter(0, viewport.Width, viewport.Height, 0, 0, 1));

                //Color blanketColor = Color.FromArgb(64, Color.LightSkyBlue);
                //renderer.DrawSolidRectangle(topLeft, topRight, bottomRight, bottomLeft, blanketColor); // TODO FIX winding....??!?!?!?
                graphics.DrawRectangle(bottomLeft, bottomRight, topRight, topLeft, Graphics.Graphics.LineType.LineDashed, Color.DeepSkyBlue);
                graphics.EndDraw();
            }
        }
Beispiel #5
0
        public override void OnRender(Graphics.Graphics graphics, BaseViewport viewport)
        {
            BaseViewportCamera   camera = viewport.Camera;
            SolidRenderOperation render = new SolidRenderOperation
            {
                Viewport = viewport,
                Graphics = graphics
            };

            // Draw all solid
            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                GL.Enable(EnableCap.DepthTest);
            }

            graphics.BeginDraw(camera.GetViewMatrix() * camera.GetProjMatrix());

            foreach (MapObject mapObject in controller.SceneDocument)
            {
                if (mapObject.Selected)
                {
                    continue;
                }

                mapObject.PerformOperation(render);
            }

            controller.Selection?.PerformOperation(render);

            graphics.EndDraw();

            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                GL.Disable(EnableCap.DepthTest);
            }
        }
Beispiel #6
0
        /// <summary>
        /// Renders the grid on the viewport
        /// </summary>
        /// <param name="graphics"></param>
        private void DrawGrid(Graphics.Graphics graphics)
        {
            Matrix4 translationViewMatrix = mCamera.GetViewMatrix().ClearRotation();
            Matrix4 viewProjMatrix        = translationViewMatrix * mCamera.GetProjMatrix();

            // get info from the settings
            Color minorGridColor  = controller.EditorSettings.GetColor("minorGridColor");
            Color majorGridColor  = controller.EditorSettings.GetColor("majorGridColor");
            Color originGridColor = controller.EditorSettings.GetColor("originGridColor");
            int   hideLinesLower  = controller.EditorSettings.HideLinesLower;
            int   majorLineEvery  = controller.EditorSettings.MajorLineEvery;

            int gridDim = 1 << 14; // 16384 dimensions

            float[]   bounds       = { float.MaxValue, float.MaxValue, -float.MaxValue, -float.MaxValue };
            Vector3[] worldExtends = new Vector3[4];

            // hide lines if grid is smaller than specified number
            int gridSize = mGridSizeInPixels;

            while ((gridSize / mCamera.Zoom) < hideLinesLower)
            {
                gridSize *= majorLineEvery;
            }

            // get the 4 world space corner points
            if (!ViewportToGridPlane(0, 0, GetGridPlane(), ref worldExtends[0]))
            {
                return;
            }
            if (!ViewportToGridPlane(mWidth, 0, GetGridPlane(), ref worldExtends[1]))
            {
                return;
            }
            if (!ViewportToGridPlane(mWidth, mHeight, GetGridPlane(), ref worldExtends[2]))
            {
                return;
            }
            if (!ViewportToGridPlane(0, mHeight, GetGridPlane(), ref worldExtends[3]))
            {
                return;
            }

            // get bounding box
            for (int i = 0; i < 4; i++)
            {
                // convert to default space (x,y)
                Matrix4 fromGridMatrix = mCamera.GetViewMatrix().ClearTranslation();
                worldExtends[i] = worldExtends[i].TransformL(fromGridMatrix);

                if (worldExtends[i].X < bounds[0])
                {
                    bounds[0] = worldExtends[i].X;
                }
                if (worldExtends[i].Y < bounds[1])
                {
                    bounds[1] = worldExtends[i].Y;
                }
                if (worldExtends[i].X > bounds[2])
                {
                    bounds[2] = worldExtends[i].X;
                }
                if (worldExtends[i].Y > bounds[3])
                {
                    bounds[3] = worldExtends[i].Y;
                }
            }

            float gridWidth  = bounds[2] - bounds[0]; // max.x - min.x
            float gridHeight = bounds[3] - bounds[1]; // max.y - min.y

            int gridCountX = (int)gridWidth / gridSize + 4;
            int gridCountY = (int)gridHeight / gridSize + 4;
            int gridStartX = (int)bounds[0] / gridSize - 1;
            int gridStartY = (int)bounds[1] / gridSize - 1;

            // Set line start and line end in world space coordinates
            float lineStartX = gridStartX * gridSize;
            float lineStartY = gridStartY * gridSize;
            float lineEndX   = (gridStartX + (gridCountX - 1)) * gridSize;
            float lineEndY   = (gridStartY + (gridCountY - 1)) * gridSize;

            // keep line start and line end inside the grid dimensions
            lineStartX = (lineStartX < -gridDim) ? -gridDim : lineStartX;
            lineStartY = (lineStartY < -gridDim) ? -gridDim : lineStartY;
            lineEndX   = (lineEndX > gridDim) ? gridDim : lineEndX;
            lineEndY   = (lineEndY > gridDim) ? gridDim : lineEndY;

            // make sure we have anything to render
            if (gridCountX + gridCountY <= 0)
            {
                return;
            }

            // start drawing the grid
            graphics.BeginDraw(viewProjMatrix);

            // the grid lines are ordered as minor, major, origin
            for (int lineType = 0; lineType < 3; lineType++)
            {
                Color lineColor = minorGridColor;
                if (lineType == 1)
                {
                    lineColor = majorGridColor;
                }
                else if (lineType == 2)
                {
                    lineColor = originGridColor;
                }

                // draw horizontal lines first
                for (int i = gridStartY; i < gridStartY + gridCountY; ++i)
                {
                    // skip lines that are out of bound
                    if (i * gridSize < -gridDim || i * gridSize > gridDim)
                    {
                        continue;
                    }

                    // skip any line that don't match the line type we're adding
                    if (lineType == 0 && (i == 0 || (i % majorLineEvery) == 0))
                    {
                        continue;
                    }
                    else if (lineType == 1 && (i == 0 || (i % majorLineEvery) != 0))
                    {
                        continue;
                    }
                    else if (lineType == 2 && i != 0)
                    {
                        continue;
                    }

                    // draw the line
                    graphics.DrawLine(new Vector3(lineStartX, (float)i * gridSize, 0.0f),
                                      new Vector3(lineEndX, (float)i * gridSize, 0.0f), Graphics.Graphics.LineType.LineNormal,
                                      lineColor);
                }

                // draw horizontal lines first
                for (int i = gridStartX; i < gridStartX + gridCountX; ++i)
                {
                    // skip lines that are out of bound
                    if (i * gridSize < -gridDim || i * gridSize > gridDim)
                    {
                        continue;
                    }

                    // skip any line that don't match the line type we're adding
                    if (lineType == 0 && (i == 0 || (i % majorLineEvery) == 0))
                    {
                        continue;
                    }
                    else if (lineType == 1 && (i == 0 || (i % majorLineEvery) != 0))
                    {
                        continue;
                    }
                    else if (lineType == 2 && i != 0)
                    {
                        continue;
                    }

                    // draw the line
                    graphics.DrawLine(new Vector3((float)i * gridSize, lineStartY, 0.0f),
                                      new Vector3((float)i * gridSize, lineEndY, 0.0f), Graphics.Graphics.LineType.LineNormal,
                                      lineColor);
                }
            }

            graphics.EndDraw();
        }
        public override void OnRender(Graphics.Graphics graphics, BaseViewport viewport)
        {
            BaseViewportCamera   camera     = viewport.Camera;
            RubberBand           rubberband = controller.RubberBand;
            SolidRenderOperation render     = new SolidRenderOperation
            {
                Viewport = viewport,
                Graphics = graphics
            };

            // Draw all solids
            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                GL.Enable(EnableCap.DepthTest);
            }

            graphics.BeginDraw(camera.GetViewMatrix() * camera.GetProjMatrix());

            foreach (MapObject mapObject in controller.SceneDocument)
            {
                if (mapObject.Selected)
                {
                    continue;
                }

                mapObject.PerformOperation(render);
            }

            controller.Selection?.PerformOperation(render);

            // only in orthographic viewport
            if (viewport.ViewportType != BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                // draw rubberband
                if (rubberband.Bounds.HasVolume2D)
                {
                    graphics.DrawWireframeAabb(rubberband.Bounds, Graphics.Graphics.LineType.LineDashed, rubberband.Color, rubberband.Transformation, viewport.Zoom);
                }
                else
                {
                    // draw "rubberband" for the selection
                    graphics.DrawWireframeAabb(controller.Selection?.Bounds, Graphics.Graphics.LineType.LineDashed,
                                               viewport.RenderMode == BaseViewport.RenderModes.SOLID ? Color.Yellow : Color.Red,
                                               Matrix4.Identity, viewport.Zoom);
                }

                // draw grabhandles for selection
                if (controller.RubberBand.ShowGrabhandles)
                {
                    SolidGrabHandles handles        = controller.RubberBand.Handles;
                    Matrix4          viewportMatrix = viewport.Camera.GetWorldMatrix().ClearTranslation();
                    handles.CreateHandles(controller.Selection, viewportMatrix, viewport.Zoom);
                    handles.Render(graphics);
                }
            }

            graphics.EndDraw();

            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                GL.Disable(EnableCap.DepthTest);
            }
        }
Beispiel #8
0
        private void RenderAllVertexHandles(Graphics.Graphics graphics, BaseViewport viewport)
        {
            int nearDepth = 1;
            int farDepth  = 0;

            //TODO check why this is neccessary
            if (viewport.ViewportType == BaseViewport.ViewportTypes.PERSPECTIVE)
            {
                nearDepth = 0;
                farDepth  = 1;
            }

            // handle vertices are already in NDC space when send to the graphicscard
            GL.Clear(ClearBufferMask.DepthBufferBit);
            GL.DepthRange(nearDepth, farDepth);
            GL.Enable(EnableCap.DepthTest);

            graphics.BeginDraw(Matrix4.Identity);

            Vector3       handleDimensions = new Vector3((float)HandleSize / viewport.Width, (float)HandleSize / viewport.Height, 0.0f);
            Matrix4       vpMatrix         = viewport.Camera.GetViewMatrix() * viewport.Camera.GetProjMatrix();
            Handle        handle           = new Handle();
            List <Handle> selectedHandles  = new List <Handle>();

            // create handles and draw non selected handles
            DoSolidAction(controller.Selection, (solid) =>
            {
                int index = 0;
                foreach (Vector3 position in solid.VertexPositions)
                {
                    Vector4 vec4Pos = new Vector4(position, 1.0f) * vpMatrix;
                    Vector3 pos     = vec4Pos.Xyz / vec4Pos.W;

                    handle.BottomLeft  = pos + (-Vector3.UnitX - Vector3.UnitY) * handleDimensions;
                    handle.BottomRight = pos + (Vector3.UnitX - Vector3.UnitY) * handleDimensions;
                    handle.TopRight    = pos + (Vector3.UnitX + Vector3.UnitY) * handleDimensions;
                    handle.TopLeft     = pos + (-Vector3.UnitX + Vector3.UnitY) * handleDimensions;

                    if (solid.SelectedVertices.Contains(index))
                    {
                        selectedHandles.Add(handle);
                        index++;
                        continue;
                    }
                    index++;

                    graphics.DrawSolidRectangle(handle.BottomLeft, handle.BottomRight,
                                                handle.TopRight, handle.TopLeft, Color.White);

                    graphics.DrawRectangle(handle.BottomLeft, handle.BottomRight,
                                           handle.TopRight, handle.TopLeft, Graphics.Graphics.LineType.LineNormal, Color.Black);
                }
            });

            graphics.EndDraw();

            GL.Clear(ClearBufferMask.DepthBufferBit);
            graphics.BeginDraw(Matrix4.Identity);

            //draw selected handles
            foreach (Handle selectedHandle in selectedHandles)
            {
                graphics.DrawSolidRectangle(selectedHandle.BottomLeft, selectedHandle.BottomRight,
                                            selectedHandle.TopRight, selectedHandle.TopLeft, Color.Red);

                graphics.DrawRectangle(selectedHandle.BottomLeft, selectedHandle.BottomRight,
                                       selectedHandle.TopRight, selectedHandle.TopLeft, Graphics.Graphics.LineType.LineNormal, Color.Black);
            }
            graphics.EndDraw();

            GL.Disable(EnableCap.DepthTest);
            GL.DepthRange(farDepth, nearDepth);
        }