Example #1
0
        private STLModel3D CalcOrientationGizmoPart(float sizeCorrection, SideSelectionType firstSideSelectionType, SideSelectionType secondSideSelectionType, SideSelectionType thirdSideSelectionType, SideSelectionType cornerSelectionType)
        {
            var defaultSize           = 5f * sizeCorrection;
            var defaultOffsetSize     = defaultSize - (1f * sizeCorrection);
            var defaultOffsetSizeHalf = defaultSize + ((1f * sizeCorrection) / 2f);
            var result = new STLModel3D();

            result.Triangles = new TriangleInfoList();

            var cubePoints = new List <Vector3Class>();

            cubePoints.Add(new Vector3Class(0, 0, defaultOffsetSizeHalf));                                  //top
            cubePoints.Add(new Vector3Class(0, -defaultOffsetSize, defaultOffsetSizeHalf));                 //top
            cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
            cubePoints.Add(new Vector3Class(defaultOffsetSize, 0, defaultOffsetSizeHalf));                  //top

            cubePoints.Add(new Vector3Class(0, -defaultOffsetSize, defaultOffsetSizeHalf));                 //top
            cubePoints.Add(new Vector3Class(0, -defaultSize, defaultOffsetSizeHalf));                       //top
            cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));       //top
            cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top

            cubePoints.Add(new Vector3Class(defaultOffsetSize, 0, defaultOffsetSizeHalf));                  //top
            cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
            cubePoints.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));       //top
            cubePoints.Add(new Vector3Class(defaultSize, 0, defaultOffsetSizeHalf));                        //top

            cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
            cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));       //top
            cubePoints.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));       //top

            var cubeColor = new Byte4Class((byte)(int)firstSideSelectionType, 57, 64, 69);

            if (firstSideSelectionType == SelectedSide)
            {
                cubeColor = new Byte4Class((byte)(int)firstSideSelectionType, 255, 0, 0);
            }
            else if (firstSideSelectionType == HighlightedSide)
            {
                cubeColor = new Byte4Class((byte)(int)firstSideSelectionType, 255, 255, 255);
            }

            var cubeIndexes = new List <short[]>
            {
                new short[] { 0, 1, 2 },    //front
                new short[] { 2, 3, 0 },    //front

                new short[] { 4, 5, 6 },    //front
                new short[] { 6, 7, 4 },    //front

                new short[] { 8, 9, 10 },   //front
                new short[] { 10, 11, 8 },  //front

                new short[] { 12, 13, 14 }, //front
            };


            var xAngles = new List <int>()
            {
                0, -90
            };

            foreach (var xAngle in xAngles)
            {
                if (xAngle == -90)
                {
                    if (secondSideSelectionType != SideSelectionType.Bottom)
                    {
                        cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 57, 64, 69);
                    }
                    else
                    {
                        cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 128, 128, 128);
                    }

                    if (secondSideSelectionType == SelectedSide)
                    {
                        cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 255, 0, 0);
                    }
                    else if (secondSideSelectionType == HighlightedSide)
                    {
                        cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 255, 255, 255);
                    }
                }

                var tList    = new List <Triangle>();
                var stlModel = new STLModel3D();
                stlModel.Triangles = new TriangleInfoList();

                foreach (var cubeIndex in cubeIndexes)
                {
                    var triangle = new Triangle();
                    triangle.Vectors[0].Position = cubePoints[cubeIndex[0]];
                    triangle.Vectors[1].Position = cubePoints[cubeIndex[1]];
                    triangle.Vectors[2].Position = cubePoints[cubeIndex[2]];
                    triangle.Vectors[0].Color    = triangle.Vectors[1].Color = triangle.Vectors[2].Color = cubeColor;
                    triangle.CalcNormal();
                    tList.Add(triangle);

                    if (xAngle == -90)
                    {
                        triangle.Flip(true);
                    }
                }

                stlModel.Triangles[0].AddRange(tList);
                stlModel.Rotate(xAngle, 0, 0, RotationEventArgs.TypeAxis.X, updateFaceColor: false);
                if (xAngle == -90)
                {
                    stlModel.MoveModelWithTranslationZ(new Vector3Class(0, -(2 * defaultOffsetSizeHalf), 0));
                }

                result.Triangles[0].AddRange(stlModel.Triangles[0]);
            }
            var tList2    = new List <Triangle>();
            var stlModel2 = new STLModel3D();

            stlModel2.Triangles = new TriangleInfoList();

            cubeColor = new Byte4Class((byte)(int)thirdSideSelectionType, 57, 64, 69);
            if (thirdSideSelectionType == SelectedSide)
            {
                cubeColor = new Byte4Class((byte)(int)thirdSideSelectionType, 255, 0, 0);
            }
            else if (thirdSideSelectionType == HighlightedSide)
            {
                cubeColor = new Byte4Class((byte)(int)thirdSideSelectionType, 255, 255, 255);
            }

            foreach (var cubeIndex in cubeIndexes)
            {
                var triangle = new Triangle();
                triangle.Vectors[0].Position = cubePoints[cubeIndex[0]];
                triangle.Vectors[1].Position = cubePoints[cubeIndex[1]];
                triangle.Vectors[2].Position = cubePoints[cubeIndex[2]];
                triangle.Vectors[0].Color    = triangle.Vectors[1].Color = triangle.Vectors[2].Color = cubeColor;
                triangle.Flip(true);
                tList2.Add(triangle);
            }

            stlModel2.Triangles[0].AddRange(tList2);
            stlModel2.Rotate(0, -90, 0, RotationEventArgs.TypeAxis.Y, updateFaceColor: false);
            stlModel2.MoveModelWithTranslationZ(new Vector3Class((2 * defaultOffsetSizeHalf), 0, 0));

            result.Triangles[0].AddRange(stlModel2.Triangles[0]);

            //highlight parts
            var highlightParts = new List <Vector3Class>();

            highlightParts.Add(new Vector3Class(0, -defaultSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(0, -defaultOffsetSizeHalf, defaultSize));
            highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSizeHalf, defaultSize));

            highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSizeHalf, defaultSize));
            highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(0, -defaultSize, defaultOffsetSizeHalf));

            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultOffsetSize, defaultSize));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, 0f, defaultSize));

            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, 0f, defaultSize));
            highlightParts.Add(new Vector3Class(defaultSize, 0, defaultOffsetSizeHalf));

            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, 0f));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, 0f));

            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, 0f));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, defaultOffsetSize));
            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));

            highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSizeHalf, defaultSize));
            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));

            highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));

            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultOffsetSize, defaultSize));

            highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, defaultOffsetSize));
            highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultOffsetSize, defaultSize));

            var highlightColor = new Byte4Class((byte)(int)cornerSelectionType, 0, 0, 0);

            if (cornerSelectionType == SelectedSide)
            {
                highlightColor = new Byte4Class((byte)(int)cornerSelectionType, 255, 0, 0);
            }
            else if (cornerSelectionType == HighlightedSide)
            {
                highlightColor = new Byte4Class((byte)(int)cornerSelectionType, 255, 255, 255);
            }

            for (var highlightIndex = 0; highlightIndex < highlightParts.Count; highlightIndex += 3)
            {
                var triangle = new Triangle();
                triangle.Vectors[0].Position = highlightParts[highlightIndex];
                triangle.Vectors[1].Position = highlightParts[highlightIndex + 1];
                triangle.Vectors[2].Position = highlightParts[highlightIndex + 2];

                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = highlightColor;
                triangle.CalcNormal();
                result.Triangles[0].Add(triangle);
            }

            return(result);
        }
Example #2
0
        public void UpdateControl(SceneViewSelectedScaleAxisType selectedMoveTranslationAxis, bool selectedModelChanged)
        {
            if (selectedMoveTranslationAxis != SceneViewSelectedScaleAxisType.Hidden)
            {
                if (selectedMoveTranslationAxis != SelectedScaleAxis || this.Triangles == null || this.Triangles.Count == 0 || selectedModelChanged)
                {
                    this.SelectedScaleAxis = selectedMoveTranslationAxis;

                    var selectedModel = ObjectView.SelectedModel;
                    if (selectedModel != null && !(selectedModel is SupportCone))
                    {
                        var stlModel        = selectedModel;
                        var scaleAxisXColor = new Byte4Class(240, 255, 0, 0);
                        if (this.SelectedScaleAxis == SceneViewSelectedScaleAxisType.X)
                        {
                            scaleAxisXColor = new Byte4Class(240, 255, 255, 255);
                        }
                        var centerLeftSide = new Vector3((stlModel.LeftPoint - stlModel.RightPoint) / 2, stlModel.Center.Y, 0);
                        var leftSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight - centerLeftSide.X, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Red);
                        leftSideCone.Rotate(0, -90, 0, RotationEventArgs.TypeAxis.Y, true);
                        foreach (var triangle in leftSideCone.Triangles[0])
                        {
                            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = scaleAxisXColor;
                        }

                        var centerRightSide = new Vector3((stlModel.RightPoint - stlModel.LeftPoint) / 2, stlModel.Center.Y, 0);
                        var rightSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + centerRightSide.X, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Red);
                        rightSideCone.Rotate(0, 90, 0, Events.RotationEventArgs.TypeAxis.Y, true);
                        foreach (var triangle in rightSideCone.Triangles[0])
                        {
                            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = scaleAxisXColor;
                        }

                        //front back
                        var scaleAxisYColor = new Byte4Class(241, 0, 255, 0);
                        if (this.SelectedScaleAxis == SceneViewSelectedScaleAxisType.Y)
                        {
                            scaleAxisYColor = new Byte4Class(241, 255, 255, 0);
                        }
                        var centerFrontSide = new Vector3(stlModel.Center.X, (stlModel.FrontPoint - stlModel.BackPoint) / 2, 0);
                        var frontSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + centerFrontSide.Y, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Green);
                        frontSideCone.Rotate(90, 0, 0, Events.RotationEventArgs.TypeAxis.X, true);
                        foreach (var triangle in frontSideCone.Triangles[0])
                        {
                            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = scaleAxisYColor;
                        }

                        var centerBackSide = new Vector3Class(stlModel.Center.X, (stlModel.FrontPoint - stlModel.BackPoint) / 2, 0);
                        var backSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + centerBackSide.Y, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Green);
                        backSideCone.Rotate(-90, 0, 0, Events.RotationEventArgs.TypeAxis.X, true);
                        foreach (var triangle in backSideCone.Triangles[0])
                        {
                            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = scaleAxisYColor;
                        }

                        //top bottom
                        var scaleAxisZColor = new Byte4Class(242, 255, 0, 0);
                        if (this.SelectedScaleAxis == SceneViewSelectedScaleAxisType.Z)
                        {
                            scaleAxisZColor = new Byte4Class(242, 255, 255, 255);
                        }
                        var centerTopSide = new Vector3Class(stlModel.Center.X, stlModel.Center.Y, 0);
                        var topSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + ((stlModel.TopPoint - stlModel.BottomPoint) / 2), AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, centerTopSide, Color.Blue);
                        foreach (var triangle in topSideCone.Triangles[0])
                        {
                            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = scaleAxisZColor;
                        }

                        var centerBottomSide = new Vector3Class(stlModel.Center.X, stlModel.Center.Y, 0);
                        var bottomSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + ((stlModel.TopPoint - stlModel.BottomPoint) / 2), AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, centerBottomSide, Color.Blue);
                        bottomSideCone.Rotate(180, 0, 0, Events.RotationEventArgs.TypeAxis.X, true);
                        foreach (var triangle in bottomSideCone.Triangles[0])
                        {
                            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = scaleAxisZColor;
                        }

                        //initialize triangle array
                        this.Triangles = new TriangleInfoList();
                        this.Triangles[0].AddRange(leftSideCone.Triangles[0]);
                        this.Triangles[0].AddRange(rightSideCone.Triangles[0]);
                        this.Triangles[0].AddRange(frontSideCone.Triangles[0]);
                        this.Triangles[0].AddRange(backSideCone.Triangles[0]);
                        this.Triangles[0].AddRange(topSideCone.Triangles[0]);
                        this.Triangles[0].AddRange(bottomSideCone.Triangles[0]);

                        //change all triangles center to center of model
                        if (stlModel.PreviewMoveTranslation.X != 0 || stlModel.PreviewMoveTranslation.Y != 0)
                        {
                            this.MoveTranslation = stlModel.PreviewMoveTranslation + new Vector3Class(0, 0, (stlModel.TopPoint - stlModel.BottomPoint) / 2);
                        }
                        else
                        {
                            this.MoveTranslation = stlModel.MoveTranslation + new Vector3Class(0, 0, (stlModel.TopPoint - stlModel.BottomPoint) / 2);
                        }
                    }
                }
            }
            else
            {
                this.Triangles = new TriangleInfoList();
            }


            if (this.VBOIndexes == null && ObjectView.SelectedModel != null)
            {
                this.BindModel();
            }
            else
            {
                this.UpdateBinding();
            }
        }
Example #3
0
        public Sphere(float radius, Vector3 offset, eSubdivisions subdivs, eDir[] sides, Vector3Class position, Byte4Class color)
        {
            float Diameter = radius;

            PrimitiveMode = OpenTK.Graphics.OpenGL.PrimitiveType.Triangles;

            if (sides[0] == eDir.All)
            {
                sides = new eDir[] { eDir.FrontTopRight,
                                     eDir.FrontBottomRight,
                                     eDir.FrontBottomLeft,
                                     eDir.FrontTopLeft,
                                     eDir.BackTopRight,
                                     eDir.BackBottomRight,
                                     eDir.BackBottomLeft,
                                     eDir.BackTopLeft, };
            }

            VertexArray = new Vertex[sides.Length * 3];
            IndexArray  = new uint[sides.Length * 3];

            uint counter = 0;

            foreach (eDir s in sides)
            {
                GetDefaultVertices(s, Diameter, out VertexArray[counter + 0], out VertexArray[counter + 1], out VertexArray[counter + 2]);
                IndexArray[counter + 0] = counter + 0;
                IndexArray[counter + 1] = counter + 1;
                IndexArray[counter + 2] = counter + 2;
                counter += 3;
            }

            if (subdivs != eSubdivisions.Zero)
            {
                for (int s = 0; s < (int)subdivs; s++)
                {
                    #region Assemble Chunks and convert to Arrays
                    List <Chunk> AllChunks = new List <Chunk>();
                    for (uint i = 0; i < IndexArray.Length; i += 3)
                    {
                        Chunk chu;
                        Subdivide(Diameter,
                                  ref VertexArray[IndexArray[i + 0]],
                                  ref VertexArray[IndexArray[i + 1]],
                                  ref VertexArray[IndexArray[i + 2]],
                                  out chu);
                        AllChunks.Add(chu);
                    }

                    Chunk.GetArray(ref AllChunks, out VertexArray, out IndexArray);
                    AllChunks.Clear();
                    #endregion Assemble Chunks and convert to Arrays
                }
            }

            this.Triangles = new TriangleInfoList();
            for (int i = 0; i < IndexArray.Length; i += 3)
            {
                //   Vector3.Add(ref VertexArray[i].Position, ref offset, out VertexArray[i].Position);
                // }
                var vertex   = VertexArray[IndexArray[i]];
                var triangle = new Triangle();
                triangle.Vectors[0].Position = new Vector3Class(VertexArray[IndexArray[i]].Position);
                triangle.Vectors[1].Position = new Vector3Class(VertexArray[IndexArray[i + 1]].Position);
                triangle.Vectors[2].Position = new Vector3Class(VertexArray[IndexArray[i + 2]].Position);
                triangle.CalcNormal();
                triangle.Vectors[0].Position += position;
                triangle.Vectors[1].Position += position;
                triangle.Vectors[2].Position += position;
                triangle.Vectors[2].Color     = triangle.Vectors[1].Color = triangle.Vectors[0].Color = color;
                this.Triangles[0].Add(triangle);
            }
        }
Example #4
0
        internal void UpdateFaceText(float sizeCorrection)
        {
            var defaultFontSize  = 7.5f;
            var defaultFontColor = new Byte4Class((int)SideSelectionType.Top, 196, 196, 196);

            this.FaceText = new List <Triangle>();

            if (OSProvider.IsWindows)
            {
                // front
                defaultFontColor.A = (int)SideSelectionType.Front;
                var faceText = new OrientationGizmoFaceText();
                faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("F", FontStyle.Regular, defaultFontSize * sizeCorrection);
                faceText.RotateText(-90, 0, 0, RotationEventArgs.TypeAxis.X);
                faceText.UpdateBoundries();
                faceText.UpdateDefaultCenter();
                faceText.MoveModelWithTranslationZ(new Vector3Class(0, -(sizeCorrection * 5) - (sizeCorrection / 2) - 0.01f, -(faceText.TopPoint / 2)));
                var faceTextClone = (STLModel3D)faceText.Clone(false);
                faceText.Triangles[0].Clear();
                foreach (var triangle in faceTextClone.Triangles[0])
                {
                    triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = defaultFontColor;
                    triangle.Flip();
                    faceText.Triangles[0].Add(triangle);
                }

                this.FaceText.AddRange(faceText.Triangles[0]);

                //left
                defaultFontColor   = new Byte4Class((int)SideSelectionType.Left, 196, 196, 196);
                faceText           = new OrientationGizmoFaceText();
                faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("L", FontStyle.Regular, defaultFontSize * sizeCorrection);
                faceText.RotateText(-90, 0, 0, RotationEventArgs.TypeAxis.X);
                faceText.RotateText(-90, 0, -90, RotationEventArgs.TypeAxis.Z);
                faceText.UpdateBoundries();
                faceText.UpdateDefaultCenter();
                faceText.MoveModelWithTranslationZ(new Vector3Class(-(sizeCorrection * 5) - (sizeCorrection / 2) - 0.01f, 0, -(faceText.TopPoint / 2)));
                faceTextClone = (STLModel3D)faceText.Clone(false);
                faceText.Triangles[0].Clear();
                foreach (var triangle in faceTextClone.Triangles[0])
                {
                    triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = defaultFontColor;
                    triangle.Flip();
                    faceText.Triangles[0].Add(triangle);
                }

                this.FaceText.AddRange(faceText.Triangles[0]);

                //right
                defaultFontColor   = new Byte4Class((int)SideSelectionType.Right, 196, 196, 196);
                faceText           = new OrientationGizmoFaceText();
                faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("R", FontStyle.Regular, defaultFontSize * sizeCorrection);
                faceText.RotateText(-90, 0, 0, RotationEventArgs.TypeAxis.X);
                faceText.RotateText(-90, 0, 90, RotationEventArgs.TypeAxis.Z);
                faceText.UpdateBoundries();
                faceText.UpdateDefaultCenter();
                faceText.MoveModelWithTranslationZ(new Vector3Class((sizeCorrection * 5) + (sizeCorrection / 2) + 0.01f, 0, -(faceText.TopPoint / 2)));
                faceTextClone = (STLModel3D)faceText.Clone(false);
                faceText.Triangles[0].Clear();
                foreach (var triangle in faceTextClone.Triangles[0])
                {
                    triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = defaultFontColor;
                    triangle.Flip();
                    faceText.Triangles[0].Add(triangle);
                }

                this.FaceText.AddRange(faceText.Triangles[0]);

                //back
                defaultFontColor   = new Byte4Class((int)SideSelectionType.Back, 196, 196, 196);
                defaultFontColor.A = (int)SideSelectionType.Back;
                faceText           = new OrientationGizmoFaceText();
                faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("B", FontStyle.Regular, defaultFontSize * sizeCorrection);
                faceText.RotateText(-90, 0, 0, RotationEventArgs.TypeAxis.X);
                faceText.RotateText(-90, 0, 180, RotationEventArgs.TypeAxis.Z);
                faceText.UpdateBoundries();
                faceText.UpdateDefaultCenter();
                faceText.MoveModelWithTranslationZ(new Vector3Class(0, (sizeCorrection * 5) + (sizeCorrection / 2) + 0.01f, -(faceText.TopPoint / 2)));
                faceTextClone = (STLModel3D)faceText.Clone(false);
                faceText.Triangles[0].Clear();
                foreach (var triangle in faceTextClone.Triangles[0])
                {
                    triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = defaultFontColor;
                    triangle.Flip();
                    faceText.Triangles[0].Add(triangle);
                }

                this.FaceText.AddRange(faceText.Triangles[0]);

                //top
                defaultFontColor   = new Byte4Class((int)SideSelectionType.Top, 196, 196, 196);
                faceText           = new OrientationGizmoFaceText();
                faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("T", FontStyle.Regular, defaultFontSize * sizeCorrection);
                faceText.RotateText(180, 0, 0, RotationEventArgs.TypeAxis.X);
                //faceText.RotateText(0, 0, 180, RotationEventArgs.TypeAxis.Z);
                faceText.UpdateBoundries();
                faceText.UpdateDefaultCenter();
                faceText.MoveModelWithTranslationZ(new Vector3Class(0, 0, (sizeCorrection * 5) + (sizeCorrection / 2) + 0.01f));
                faceTextClone = (STLModel3D)faceText.Clone(false);
                faceText.Triangles[0].Clear();
                foreach (var triangle in faceTextClone.Triangles[0])
                {
                    triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = defaultFontColor;
                    triangle.Flip();

                    faceText.Triangles[0].Add(triangle);
                }

                this.FaceText.AddRange(faceText.Triangles[0]);

                //bottom
                defaultFontColor   = new Byte4Class((int)SideSelectionType.Bottom, 196, 196, 196);
                faceText           = new OrientationGizmoFaceText();
                faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("B", FontStyle.Regular, defaultFontSize * sizeCorrection);
                faceText.RotateText(0, 0, 0, RotationEventArgs.TypeAxis.Z);
                faceText.UpdateBoundries();
                faceText.UpdateDefaultCenter();
                faceText.MoveModelWithTranslationZ(new Vector3Class(0, 0, -(sizeCorrection * 5) - (sizeCorrection / 2) - 0.01f));
                faceTextClone = (STLModel3D)faceText.Clone(false);
                faceText.Triangles[0].Clear();
                foreach (var triangle in faceTextClone.Triangles[0])
                {
                    triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = defaultFontColor;
                    triangle.Flip();
                    faceText.Triangles[0].Add(triangle);
                }

                this.FaceText.AddRange(faceText.Triangles[0]);
            }
        }
Example #5
0
        public void UpdateControl(SceneViewSelectedRotationAxisType selectedRotationAxis)
        {
            this.SelectedObject = (STLModel3D)ObjectView.SelectedModel;
            if (SelectedObject != null)
            {
                if (this.SelectedObject.LinkedClones.Count > 1 && SceneView.CurrentViewMode == SceneView.ViewMode.ModelRotation)
                {
                    this.Hidden = true;
                    SceneControlToolbarManager.ShowRotationSelectedModelContainsLinkedClonesToolTip();
                }
                else
                {
                    this.Hidden = false;
                    if (selectedRotationAxis != SceneViewSelectedRotationAxisType.Hidden)
                    {
                        this.SelectedRotationAxis = selectedRotationAxis;

                        if (this.SelectedObject != null && !(this.SelectedObject is SupportCone))
                        {
                            //diameter equals front bottom --> back top distance
                            _modelDiameter      = (new Vector3(this.SelectedObject.LeftPoint, this.SelectedObject.FrontPoint, 0) - (new Vector3(this.RightPoint, this.BackPoint, this.TopPoint))).Length;
                            _selectedModelIndex = this.SelectedObject.Index;

                            //initialize triangle array
                            this.Triangles = new TriangleInfoList();

                            //create axis X
                            var rotationAxisXColor = new Byte4Class(240, 255, 0, 0);
                            if (this.SelectedRotationAxis == SceneViewSelectedRotationAxisType.X)
                            {
                                rotationAxisXColor = new Byte4Class(240, 255, 255, 255);
                            }
                            var rotationAxisX = new Torus(_modelDiameter, TORUSOUTSIDERINGDIAMETER, TORUSSEGMENTCOUNT, TORUSSEGMENTBANDCOUNT);
                            foreach (var triangle in rotationAxisX.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = rotationAxisXColor;
                            }


                            //add triangle to stl model
                            rotationAxisX.Rotate(0, 45, 0, Events.RotationEventArgs.TypeAxis.Y, true, false);
                            this.Triangles[0].AddRange(rotationAxisX.Triangles[0]);

                            //create axis Y
                            var rotationAxisY      = new Torus(_modelDiameter, TORUSOUTSIDERINGDIAMETER, TORUSSEGMENTCOUNT, TORUSSEGMENTBANDCOUNT);
                            var rotationAxisYColor = new Byte4Class(241, 0, 255, 0);
                            if (this.SelectedRotationAxis == SceneViewSelectedRotationAxisType.Y)
                            {
                                rotationAxisYColor = new Byte4Class(241, 255, 255, 255);
                            }

                            foreach (var triangle in rotationAxisY.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = rotationAxisYColor;
                            }

                            //add triangle to stl model
                            rotationAxisY.Rotate(45, 0, 0, Events.RotationEventArgs.TypeAxis.X, true, false);
                            this.Triangles[0].AddRange(rotationAxisY.Triangles[0]);

                            //create z rotation axis
                            var rotationAxisZ      = new Torus(_modelDiameter, TORUSOUTSIDERINGDIAMETER, TORUSSEGMENTCOUNT, TORUSSEGMENTBANDCOUNT);
                            var rotationAxisZColor = new Byte4Class(242, 0, 0, 255);
                            if (this.SelectedRotationAxis == SceneViewSelectedRotationAxisType.Z)
                            {
                                rotationAxisZColor = new Byte4Class(242, 255, 255, 255);
                            }
                            foreach (var triangle in rotationAxisZ.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = rotationAxisZColor;
                            }

                            this.Triangles[0].AddRange(rotationAxisZ.Triangles[0]);

                            foreach (var triangle in this.Triangles[0])
                            {
                                triangle.CalcNormal();
                            }

                            //change all triangles center to center of model
                            this.MoveTranslation  = this.SelectedObject.MoveTranslation;
                            this.MoveTranslation += new Vector3Class(0, 0, (this.SelectedObject.TopPoint - this.SelectedObject.BottomPoint) / 2);
                        }
                    }
                    else
                    {
                        //reset bindings
                        this.Triangles = new TriangleInfoList();
                    }

                    if (this.SelectedRotationAxis == SceneViewSelectedRotationAxisType.None)
                    {
                        UpdateSelectedAngleOverlay(this.SelectedObject, RotationEventArgs.TypeAxis.None);
                    }

                    if (this.VBOIndexes == null)
                    {
                        this.BindModel();
                    }
                    else
                    {
                        this.UpdateBinding();
                    }
                }

                this.PreviousSelectedObject = this.SelectedObject;
            }
        }
Example #6
0
        public void UpdateControl(SceneViewSelectedMoveTranslationAxisType selectedMoveTranslationAxis, bool selectedModelChanged)
        {
            if (selectedMoveTranslationAxis != SceneViewSelectedMoveTranslationAxisType.Hidden)
            {
                if (selectedMoveTranslationAxis != SelectedMoveTranslationAxis || this.Triangles == null || this.Triangles.Count == 0 || selectedModelChanged || this.SelectedObject.LinkedClones.Count > 1)
                {
                    this.SelectedMoveTranslationAxis = selectedMoveTranslationAxis;
                    this.SelectedObject = (STLModel3D)ObjectView.SelectedModel;

                    if (SelectedObject != null)
                    {
                        if (SceneView.CurrentViewMode == SceneView.ViewMode.ModelRotation && this.SelectedObject.LinkedClones.Count > 1)
                        {
                            this.Hidden = true;
                            SceneControlToolbarManager.ShowRotationSelectedModelContainsLinkedClonesToolTip();
                        }
                        else
                        {
                            LinkedClone selectedLinkedClone = null;
                            for (var i = 0; i < SelectedObject.LinkedClones.Count; i++)
                            {
                                if (SelectedObject.LinkedClones[i].Selected)
                                {
                                    selectedLinkedClone = SelectedObject.LinkedClones[i];
                                    break;
                                }
                            }

                            var stlModel = SelectedObject;
                            var moveTranslationAxisXColor = new Byte4Class(240, 255, 0, 0);
                            if (this.SelectedMoveTranslationAxis == SceneViewSelectedMoveTranslationAxisType.X)
                            {
                                moveTranslationAxisXColor = new Byte4Class(240, 255, 255, 255);
                            }
                            var centerLeftSide = new Vector3((stlModel.LeftPoint - stlModel.RightPoint) / 2, stlModel.Center.Y, 0);
                            var leftSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight - centerLeftSide.X, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Red);
                            leftSideCone.Rotate(0, -90, 0, Events.RotationEventArgs.TypeAxis.Y, true);
                            foreach (var triangle in leftSideCone.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = moveTranslationAxisXColor;
                            }

                            var centerRightSide = new Vector3((stlModel.RightPoint - stlModel.LeftPoint) / 2, stlModel.Center.Y, 0);
                            var rightSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + centerRightSide.X, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Red);
                            rightSideCone.Rotate(0, 90, 0, Events.RotationEventArgs.TypeAxis.Y, true);
                            foreach (var triangle in rightSideCone.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = moveTranslationAxisXColor;
                            }

                            //front back
                            var moveTranslationAxisYColor = new Byte4Class(241, 0, 255, 0);
                            if (this.SelectedMoveTranslationAxis == SceneViewSelectedMoveTranslationAxisType.Y)
                            {
                                moveTranslationAxisYColor = new Byte4Class(241, 255, 255, 255);
                            }
                            var centerFrontSide = new Vector3(stlModel.Center.X, (stlModel.FrontPoint - stlModel.BackPoint) / 2, 0);
                            var frontSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + centerFrontSide.Y, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Green);
                            frontSideCone.Rotate(90, 0, 0, Events.RotationEventArgs.TypeAxis.X, true);
                            foreach (var triangle in frontSideCone.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = moveTranslationAxisYColor;
                            }

                            var centerBackSide = new Vector3(stlModel.Center.X, (stlModel.FrontPoint - stlModel.BackPoint) / 2, 0);
                            var backSideCone   = new SceneMoveTranslationGizmoCone(AxisConeHeight + centerBackSide.Y, AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Green);
                            backSideCone.Rotate(-90, 0, 0, Events.RotationEventArgs.TypeAxis.X, true);
                            foreach (var triangle in backSideCone.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = moveTranslationAxisYColor;
                            }

                            //top bottom
                            var moveTranslationAxisZColor = new Byte4Class(242, 0, 0, 255);
                            if (this.SelectedMoveTranslationAxis == SceneViewSelectedMoveTranslationAxisType.Z)
                            {
                                moveTranslationAxisZColor = new Byte4Class(242, 255, 255, 255);
                            }
                            var topSideCone = new SceneMoveTranslationGizmoCone(AxisConeHeight + ((stlModel.TopPoint - stlModel.BottomPoint) / 2), AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Blue);
                            foreach (var triangle in topSideCone.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = moveTranslationAxisZColor;
                            }

                            var bottomSideCone = new SceneMoveTranslationGizmoCone(AxisConeHeight + ((stlModel.TopPoint - stlModel.BottomPoint) / 2), AxisConeTopHeight, AxisConeTopRadius, AxisConeMiddleRadius, 10, new Vector3Class(), Color.Blue);
                            bottomSideCone.Rotate(180, 0, 0, Events.RotationEventArgs.TypeAxis.X, true);
                            foreach (var triangle in bottomSideCone.Triangles[0])
                            {
                                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = moveTranslationAxisZColor;
                            }

                            //initialize triangle array
                            this.Triangles = new TriangleInfoList();
                            this.Triangles[0].AddRange(leftSideCone.Triangles[0]);
                            this.Triangles[0].AddRange(rightSideCone.Triangles[0]);
                            this.Triangles[0].AddRange(frontSideCone.Triangles[0]);
                            this.Triangles[0].AddRange(backSideCone.Triangles[0]);

                            if (SelectedObject != null && SelectedObject is SupportCone)
                            {
                                var selectedSupportCone = SelectedObject as SupportCone;
                                var moveTranslation     = new Vector3Class(selectedSupportCone.Center.X, selectedSupportCone.Center.Y, 0);
                                foreach (var triangle in this.Triangles[0])
                                {
                                    triangle.Vectors[0].Position += moveTranslation;
                                    triangle.Vectors[1].Position += moveTranslation;
                                    triangle.Vectors[2].Position += moveTranslation;
                                }

                                this.MoveTranslation = selectedSupportCone.MoveTranslation + new Vector3Class(selectedSupportCone.Model.MoveTranslation.X, selectedSupportCone.Model.MoveTranslation.Y, ((selectedSupportCone.TopPoint - selectedSupportCone.BottomPoint) / 2) + selectedSupportCone.BottomPoint);
                            }
                            else if (selectedLinkedClone != null)
                            {
                                this.Triangles[0].AddRange(topSideCone.Triangles[0]);
                                this.Triangles[0].AddRange(bottomSideCone.Triangles[0]);

                                this.MoveTranslation = selectedLinkedClone.Translation + new Vector3Class(0, 0, ((stlModel.TopPoint - stlModel.BottomPoint) / 2) + stlModel.BottomPoint);
                            }
                            else
                            {
                                this.Triangles[0].AddRange(topSideCone.Triangles[0]);
                                this.Triangles[0].AddRange(bottomSideCone.Triangles[0]);

                                //change all triangles center to center of model
                                if (stlModel.PreviewMoveTranslation.X != 0 || stlModel.PreviewMoveTranslation.Y != 0)
                                {
                                    this.MoveTranslation = stlModel.PreviewMoveTranslation + new Vector3Class(0, 0, (stlModel.TopPoint - stlModel.BottomPoint) / 2);
                                }
                                else
                                {
                                    this.MoveTranslation = stlModel.MoveTranslation + new Vector3Class(0, 0, (stlModel.TopPoint - stlModel.BottomPoint) / 2);
                                }
                            }

                            this.PreviousSelectedObject = SelectedObject;
                        }
                    }
                }
            }
            else
            {
                this.Triangles = new TriangleInfoList();
            }


            if (this.VBOIndexes == null && ObjectView.SelectedModel != null)
            {
                this.BindModel();
            }
            else
            {
                this.UpdateBinding();
            }
        }
Example #7
0
        internal void UpdateGroundPane(float xLength, float yHeight, float zDepth)
        {
            this.Triangles = new TriangleInfoList();

            //front face
            var triangle = new Triangle();

            triangle.Normal     = Vector3Class.UnitZ;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, 0)
            };
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitZ;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, 0)
            };
            this.Triangles[0].Add(triangle);

            //back face
            triangle            = new Triangle();
            triangle.Normal     = -Vector3Class.UnitZ;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, -zDepth)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, -zDepth)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = -Vector3Class.UnitZ;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, -zDepth)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, -zDepth)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            //left face
            triangle            = new Triangle();
            triangle.Normal     = -Vector3Class.UnitX;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, -zDepth)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = -Vector3Class.UnitX;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, -zDepth)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, 0)
            };
            this.Triangles[0].Add(triangle);

            //right face
            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitX;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, -zDepth)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitX;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, -zDepth)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, 0)
            };
            this.Triangles[0].Add(triangle);

            //bottom face
            triangle            = new Triangle();
            triangle.Normal     = -Vector3Class.UnitY;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = -Vector3Class.UnitY;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(0, 0, -zDepth)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, 0, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            //top face
            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitY;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, 0)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitY;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, -zDepth)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(0, yHeight, 0)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xLength, yHeight, -zDepth)
            };
            this.Triangles[0].Add(triangle);

            for (var vertexIndex = 0; vertexIndex < this.Triangles[0].Count; vertexIndex++)
            {
                this.Triangles[0][vertexIndex].Vectors[0].Position.X -= xLength / 2;
                this.Triangles[0][vertexIndex].Vectors[1].Position.X -= xLength / 2;
                this.Triangles[0][vertexIndex].Vectors[2].Position.X -= xLength / 2;
                this.Triangles[0][vertexIndex].Vectors[0].Position.Y -= yHeight / 2;
                this.Triangles[0][vertexIndex].Vectors[1].Position.Y -= yHeight / 2;
                this.Triangles[0][vertexIndex].Vectors[2].Position.Y -= yHeight / 2;

                this.Triangles[0][vertexIndex].Vectors[0].Color = this.Triangles[0][vertexIndex].Vectors[1].Color = this.Triangles[0][vertexIndex].Vectors[2].Color = new Byte4Class(200, Properties.Settings.Default.SceneGroundColor.R, Properties.Settings.Default.SceneGroundColor.G, Properties.Settings.Default.SceneGroundColor.B);
                this.Triangles[0][vertexIndex].CalcMinMaxX();
                this.Triangles[0][vertexIndex].CalcMinMaxY();
                this.Triangles[0][vertexIndex].CalcMinMaxZ();
            }

            //grid column coloring
            var xPosition     = 0f;
            var yPosition     = (yHeight / 2f);
            var zPosition     = 0.02f;
            var lineThinkness = 0.2f;
            var gridLineColor = new Byte4Class(200, 0, 0, 0);

            for (var gridLineColumnIndex = 1; gridLineColumnIndex < 16; gridLineColumnIndex++)
            {
                xPosition = ((xLength / 16f / 10) * gridLineColumnIndex * 10) - (xLength / 2f) - (lineThinkness / 2f);
                var gridColumnIndexZero = 36 + ((gridLineColumnIndex - 1) * 6);
                triangle            = new Triangle();
                triangle.Normal     = Vector3Class.UnitY;
                triangle.Vectors[0] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition, yPosition, zPosition)
                };
                triangle.Vectors[1] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition, -yPosition, zPosition)
                };
                triangle.Vectors[2] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition + lineThinkness, yPosition, zPosition)
                };
                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = gridLineColor;
                this.Triangles[0].Add(triangle);

                triangle            = new Triangle();
                triangle.Normal     = Vector3Class.UnitY;
                triangle.Vectors[0] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition, -yPosition, zPosition)
                };
                triangle.Vectors[1] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition + lineThinkness, -yPosition, zPosition)
                };
                triangle.Vectors[2] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition + lineThinkness, yPosition, zPosition)
                };
                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = gridLineColor;
                this.Triangles[0].Add(triangle);
            }

            //grid row coloring
            xPosition = (xLength / 2f);

            yPosition = -(yHeight / 2);
            for (var gridLineRowIndex = 1; gridLineRowIndex < 10; gridLineRowIndex++)
            {
                yPosition += (yHeight / 10);

                triangle            = new Triangle();
                triangle.Normal     = Vector3Class.UnitY;
                triangle.Vectors[0] = new VertexClass()
                {
                    Position = new Vector3Class(-xPosition, yPosition, zPosition)
                };
                triangle.Vectors[1] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition, yPosition, zPosition)
                };
                triangle.Vectors[2] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition, yPosition + lineThinkness, zPosition)
                };
                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = gridLineColor;
                this.Triangles[0].Add(triangle);

                triangle            = new Triangle();
                triangle.Normal     = Vector3Class.UnitY;
                triangle.Vectors[0] = new VertexClass()
                {
                    Position = new Vector3Class(-xPosition, yPosition, zPosition)
                };
                triangle.Vectors[1] = new VertexClass()
                {
                    Position = new Vector3Class(xPosition, yPosition + lineThinkness, zPosition)
                };
                triangle.Vectors[2] = new VertexClass()
                {
                    Position = new Vector3Class(-xPosition, yPosition + lineThinkness, zPosition)
                };
                triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = gridLineColor;
                this.Triangles[0].Add(triangle);
            }

            //front text
            var defaultFontSize = 15f;
            var sizeCorrection  = 4f;
            var faceText        = new OrientationGizmoFaceText();

            faceText.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("front", FontStyle.Regular, defaultFontSize * sizeCorrection);
            faceText.RotateText(180, 0, 0, RotationEventArgs.TypeAxis.X);
            faceText._scaleFactorX = faceText._scaleFactorY = faceText._scaleFactorZ = 1;
            faceText.Scale(0.15f, 0.15f, 0.15f, ScaleEventArgs.TypeAxis.ALL, false);
            faceText.UpdateBoundries();
            faceText.UpdateDefaultCenter();
            faceText.MoveModelWithTranslationZ(new Vector3Class(0, -(yHeight / 2) + sizeCorrection + sizeCorrection, 0.02f));

            var faceTextColor = new Byte4Class(200, Properties.Settings.Default.SceneGroundFrontTextColor.R, Properties.Settings.Default.SceneGroundFrontTextColor.G, Properties.Settings.Default.SceneGroundFrontTextColor.B);

            foreach (var triangleText in faceText.Triangles[0])
            {
                triangleText.Vectors[0].Color = triangleText.Vectors[1].Color = triangleText.Vectors[2].Color = faceTextColor;
                triangleText.Flip();
            }

            this.Triangles[0].AddRange(faceText.Triangles[0]);

            //line below front text
            xPosition = xLength / 2f;
            yPosition = yHeight / 2f;
            zPosition = 0.02f;

            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitY;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(-xPosition, -yPosition, zPosition)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xPosition, -yPosition, zPosition)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(xPosition, -yPosition + lineThinkness, zPosition)
            };
            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = faceTextColor;
            this.Triangles[0].Add(triangle);

            triangle            = new Triangle();
            triangle.Normal     = Vector3Class.UnitY;
            triangle.Vectors[0] = new VertexClass()
            {
                Position = new Vector3Class(-xPosition, -yPosition, zPosition)
            };
            triangle.Vectors[1] = new VertexClass()
            {
                Position = new Vector3Class(xPosition, -yPosition + lineThinkness, zPosition)
            };
            triangle.Vectors[2] = new VertexClass()
            {
                Position = new Vector3Class(-xPosition, -yPosition + lineThinkness, zPosition)
            };
            triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = faceTextColor;
            this.Triangles[0].Add(triangle);
        }
Example #8
0
        static void DrawGradient(Controls.OpenGL.GLControl glControl)
        {
            if (SceneBackground == null)
            {
                SceneBackground           = new STLModel3D();
                SceneBackground.Triangles = new TriangleInfoList();

                var gradientColor1 = new Byte4Class(255, 19, 20, 21);
                var gradientColor2 = new Byte4Class(255, 39, 42, 61);

                var triangle = new Triangle();
                triangle.Vectors[0].Position = new Vector3Class(-1f, -1f, 0f);
                triangle.Vectors[0].Color    = gradientColor2;
                triangle.Vectors[1].Position = new Vector3Class(1f, 1f, 0);
                triangle.Vectors[1].Color    = gradientColor1;
                triangle.Vectors[2].Position = new Vector3Class(-1f, 1f, 0);
                triangle.Vectors[2].Color    = gradientColor1;

                SceneBackground.Triangles[0].Add(triangle);

                triangle = new Triangle();
                triangle.Vectors[0].Position = new Vector3Class(-1f, -1f, 0f);
                triangle.Vectors[0].Color    = gradientColor2;
                triangle.Vectors[1].Position = new Vector3Class(1f, -1f, 0);
                triangle.Vectors[1].Color    = gradientColor2;
                triangle.Vectors[2].Position = new Vector3Class(1f, 1f, 0);
                triangle.Vectors[2].Color    = gradientColor1;

                SceneBackground.Triangles[0].Add(triangle);

                SceneBackground.Loaded = true;
                SceneBackground.BindModel();
                SceneBackground.UpdateBinding();
            }

            GL.Viewport(0, 0, glControl.Width, glControl.Height);
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadIdentity();
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
            GL.Disable(EnableCap.DepthTest);
            GL.Disable(EnableCap.Lighting);
            GL.PolygonMode(MaterialFace.Front, PolygonMode.Fill);

            GL.EnableClientState(ArrayCap.ColorArray);
            GL.EnableClientState(ArrayCap.VertexArray);

            foreach (var vboIndex in SceneBackground.VBOIndexes)
            {
                GL.BindBuffer(BufferTarget.ArrayBuffer, vboIndex);
                GL.ColorPointer(4, ColorPointerType.UnsignedByte, Vertex.Stride, new IntPtr(0));
                GL.VertexPointer(3, VertexPointerType.Float, Vertex.Stride, 4);
                GL.DrawArrays(PrimitiveType.Triangles, 0, SceneBackground.Triangles[0].Count * 3);
            }

            GL.DisableClientState(ArrayCap.ColorArray);
            GL.DisableClientState(ArrayCap.VertexArray);

            GL.Enable(EnableCap.DepthTest);
            GL.Enable(EnableCap.Lighting);
        }
        internal void UpdatAngle(float innerRadius, float outerRadius, int torusSegmentCount, int torusSegmentBandCount, float angle, RotationEventArgs.TypeAxis rotationAxis)
        {
            //var selectionTorusOverlay = new Torus(innerRadius, outerRadius, torusSegmentCount, torusSegmentBandCount, angle);
            var selectionTorusOverlayColor = new Byte4Class(128, Properties.Settings.Default.RotationGizmoAngleSelectionOverlay.R, Properties.Settings.Default.RotationGizmoAngleSelectionOverlay.G, Properties.Settings.Default.RotationGizmoAngleSelectionOverlay.B);
            //foreach (var triangle in selectionTorusOverlay.Triangles[0])
            //{
            //    triangle.Vectors[0].Color = selectionTorusOverlayColor;
            //    triangle.Vectors[1].Color = selectionTorusOverlayColor;
            //    triangle.Vectors[2].Color = selectionTorusOverlayColor;
            //}

            //if (angle < 0)
            //{
            //    foreach (var triangle in selectionTorusOverlay.Triangles[0])
            //    {
            //        triangle.Flip();
            //    }
            //}

            //prepare angle infill

            var rotationAngleOutlinePoints = VectorHelper.GetCircleOutlinePoints(0, innerRadius, torusSegmentCount, new Vector3Class(), angle);
            //convert outlinepoints to triangles
            var rotationAngleModel       = new STLModel3D();
            var rotationAngleModelMirror = new STLModel3D();

            rotationAngleModel.Triangles       = new TriangleInfoList();
            rotationAngleModelMirror.Triangles = new TriangleInfoList();
            for (var rotationAngleOutlinePointIndex = 0; rotationAngleOutlinePointIndex < rotationAngleOutlinePoints.Count - 1; rotationAngleOutlinePointIndex++)
            {
                var triangle = new Triangle();
                triangle.Vectors[0].Position = new Vector3Class();
                triangle.Vectors[0].Color    = selectionTorusOverlayColor;
                triangle.Vectors[1].Color    = selectionTorusOverlayColor;
                triangle.Vectors[1].Position = rotationAngleOutlinePoints[rotationAngleOutlinePointIndex];

                triangle.Vectors[2].Color = selectionTorusOverlayColor;
                if (rotationAngleOutlinePointIndex == rotationAngleOutlinePoints.Count - 1)
                {
                    triangle.Vectors[2].Position = rotationAngleOutlinePoints[0];
                }
                else
                {
                    triangle.Vectors[2].Position = rotationAngleOutlinePoints[rotationAngleOutlinePointIndex + 1];
                }

                triangle.CalcNormal();
                rotationAngleModel.Triangles[0].Add(triangle);
                var flipClone = (Triangle)triangle.Clone();
                flipClone.Flip();
                rotationAngleModelMirror.Triangles[0].Add(flipClone);
            }

            //switch (rotationAxis)
            //{
            //    case RotationEventArgs.TypeAxis.X:
            //        selectionTorusOverlay.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
            //        selectionTorusOverlay.Rotate(0, 0, 90, RotationEventArgs.TypeAxis.Z, false, false);
            //        break;
            //    case RotationEventArgs.TypeAxis.Y:
            //        selectionTorusOverlay.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
            //        break;
            //}


            switch (rotationAxis)
            {
            case RotationEventArgs.TypeAxis.X:
                //          selectionTorusOverlay.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
                //          selectionTorusOverlay.Rotate(0, 0, 90, RotationEventArgs.TypeAxis.Z, false, false);

                rotationAngleModel.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
                rotationAngleModel.Rotate(0, 0, 90, RotationEventArgs.TypeAxis.Z, false, false);

                rotationAngleModelMirror.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
                rotationAngleModelMirror.Rotate(0, 0, 90, RotationEventArgs.TypeAxis.Z, false, false);
                break;

            case RotationEventArgs.TypeAxis.Y:
                //         selectionTorusOverlay.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
                rotationAngleModel.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
                rotationAngleModelMirror.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
                break;
            }

            //    this.Triangles = selectionTorusOverlay.Triangles;
            //remove last torus triangles
            this.Triangles = new TriangleInfoList();
            //this.Triangles[0].RemoveRange(0, torusSegmentBandCount * 2);
            this.Triangles[0].AddRange(rotationAngleModel.Triangles[0]);
            this.Triangles[0].AddRange(rotationAngleModelMirror.Triangles[0]);



            ////add end tag
            //var startTag = new Box(outerRadius * 4, 0.05f, outerRadius * 2, true);
            //var endTag = new Box(outerRadius * 4, 0.05f, outerRadius * 2, true);

            //var selectionTagColor = new Byte4Class(255,255,255,255);
            //var startPosition = this.Triangles[0][0].Points[2];
            //var endPosition = this.Triangles[0][3560].Points[0];

            //switch (rotationAxis)
            //{
            //    case RotationEventArgs.TypeAxis.X:
            //        endTag.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
            //        endTag.Rotate(0, 0, 90, RotationEventArgs.TypeAxis.Z, false, false);
            //        endTag.UpdateDefaultCenter();
            //        endTag.Rotate(angle + 90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);

            //        startTag.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
            //        startTag.UpdateDefaultCenter();
            //        startTag.Rotate(0, 0, 90, RotationEventArgs.TypeAxis.Z, false, false);

            //        endPosition.X -= (outerRadius);
            //        startPosition.X = endPosition.X;
            //        break;
            //    case RotationEventArgs.TypeAxis.Y:
            //        endTag.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
            //        endTag.Rotate(0, -angle, 0, RotationEventArgs.TypeAxis.Y, false, false);

            //        startPosition.X -= outerRadius;
            //        endPosition.Y += (2 * outerRadius);
            //        startPosition.Y = endPosition.Y;

            //        startTag.Rotate(90, 0, 0, RotationEventArgs.TypeAxis.X, false, false);
            //        break;
            //    case RotationEventArgs.TypeAxis.Z:
            //        startPosition.Z = -endTag.Height / 2;
            //        foreach (var triangle in endTag.Triangles[0])
            //        {
            //            triangle.Vectors[0].Position -= new Vector3Class(0, 0, endTag.Height);
            //            triangle.Vectors[1].Position -= new Vector3Class(0, 0, endTag.Height);
            //            triangle.Vectors[2].Position -= new Vector3Class(0, 0, endTag.Height);
            //        }

            //        endTag.Rotate(0, 0, angle, RotationEventArgs.TypeAxis.Z, false, false);

            //        break;
            //}

            //foreach (var triangle in endTag.Triangles[0])
            //{
            //    triangle.Vectors[0].Position += endPosition;
            //    triangle.Vectors[0].Color = selectionTagColor;
            //    triangle.Vectors[1].Position += endPosition;
            //    triangle.Vectors[1].Color = selectionTagColor;
            //    triangle.Vectors[2].Position += endPosition;
            //    triangle.Vectors[2].Color = selectionTagColor;
            //}

            //this.Triangles[0].AddRange(endTag.Triangles[0]);

            ////add start tag
            //foreach (var triangle in startTag.Triangles[0])
            //{
            //    triangle.Vectors[0].Position += startPosition;
            //    triangle.Vectors[0].Color = selectionTagColor;
            //    triangle.Vectors[1].Position += startPosition;
            //    triangle.Vectors[1].Color = selectionTagColor;
            //    triangle.Vectors[2].Position += startPosition;
            //    triangle.Vectors[2].Color = selectionTagColor;
            //}

            //this.Triangles[0].AddRange(startTag.Triangles[0]);



            //////textline
            ////var textLineVector = new Box(10f, 0.05f, 0.05f, false);
            //////textLineVector.Rotate(0, 0, angle - 30, Events.RotationEventArgs.TypeAxis.Z, true, false);
            ////var textLineOffsetVector = new Vector3(endTag.Triangles[0][1].Points[2].X, endTag.Triangles[0][1].Points[2].Y, 0);
            ////textLineOffsetVector.Scale(new Vector3(1.1f));
            ////foreach (var triangle in textLineVector.Triangles[0])
            ////{
            ////    triangle.Vectors[0].Position += new Vector3(textLineOffsetVector.X, textLineOffsetVector.Y, -outerRadius);
            ////    triangle.Vectors[0].Color = selectionTagColor;
            ////    triangle.Vectors[1].Position += new Vector3(textLineOffsetVector.X, textLineOffsetVector.Y, -outerRadius);
            ////    triangle.Vectors[1].Color = selectionTagColor;
            ////    triangle.Vectors[2].Position += new Vector3(textLineOffsetVector.X, textLineOffsetVector.Y, -outerRadius);
            ////    triangle.Vectors[2].Color = selectionTagColor;
            ////}

            ////this.Triangles[0].AddRange(textLineVector.Triangles[0]);

            //////angle text
            ////var fontSize = 5.7f;
            ////var textAsTriangles = FontTessellationEngine.ConvertStringToTriangles(angle.ToString(), FontStyle.Regular, fontSize);
            ////var textColor = new Byte4(new[] { (byte)0, (byte)Properties.Settings.Default.SceneControlFontColor.R, (byte)Properties.Settings.Default.SceneControlFontColor.G, (byte)Properties.Settings.Default.SceneControlFontColor.B });
            ////foreach (var textTriangle in textAsTriangles[0])
            ////{
            ////    textTriangle.Vectors[0].Position += new Vector3(textLineOffsetVector.X, textLineOffsetVector.Y, -outerRadius);
            ////    textTriangle.Vectors[0].Color = selectionTagColor;
            ////    textTriangle.Vectors[1].Position += new Vector3(textLineOffsetVector.X, textLineOffsetVector.Y, -outerRadius);
            ////    textTriangle.Vectors[1].Color = selectionTagColor;
            ////    textTriangle.Vectors[2].Position += new Vector3(textLineOffsetVector.X, textLineOffsetVector.Y, -outerRadius);
            ////    textTriangle.Vectors[2].Color = selectionTagColor;

            ////}

            ////this.Triangles[0].AddRange(textAsTriangles[0]);

            if (this.VBOIndexes == null)
            {
                this.BindModel();
            }
            else
            {
                this.UpdateBinding();
            }
        }