Beispiel #1
0
        private static void DrawBigWheel(OpenGL gl)
        {
            // половинки колеса
            gl.Repeat(() =>
            {
                // внешняя часть
                gl.DrawCylinder(BigWheelOuterRadius, WheelPartWidth, partsCount: Roundness);
                gl.DrawCylinder(BigWheelInnerRadius, WheelPartWidth, partsCount: Roundness);

                // задняя стенка
                gl.Color(.24f, .25f, .22f);
                gl.DrawCircle(BigWheelOuterRadius, Roundness);

                // шайбы в середине
                gl.DrawCylinder(BigWheelInnerPartRadius1, BigWheelInnerPartWidth, partsCount: Roundness);
                gl.DoTranslate(Vector3.UnitZ * BigWheelInnerPartWidth, true);
                gl.DrawCircle(BigWheelInnerPartRadius1, Roundness);
                gl.DrawCylinder(BigWheelInnerPartRadius2, BigWheelInnerPartWidth, partsCount: Roundness);
                gl.DoTranslate(Vector3.UnitZ * BigWheelInnerPartWidth, true);
                gl.DrawCircle(BigWheelInnerPartRadius2, Roundness);

                // закрывашка внешненей части (между цилиндрами)
                gl.UndoTranslation(2);
                gl.DoTranslate(Vector3.UnitZ * WheelPartWidth, true);
                gl.DrawDisk(BigWheelInnerRadius, BigWheelOuterRadius, Roundness);

                gl.UndoTranslation();
            }, 2, Vector3.UnitZ * -WheelConnectorWidth, Vector3.UnitY * 180);

            // соединитель
            gl.DrawCylinder(BigWheelConnectorRadius, -WheelConnectorWidth, partsCount: Roundness);
        }
Beispiel #2
0
        public static void DrawSmallWheel(OpenGL gl)
        {
            gl.Repeat(() =>
            {
                // внешняя часть
                gl.DrawCylinder(SmallWheelOuterRadius, WheelPartWidth, partsCount: Roundness);
                gl.DrawCylinder(SmallWheelInnerRadius, WheelPartWidth, partsCount: Roundness);
                // задняя стенка
                gl.DrawCircle(SmallWheelOuterRadius, Roundness);
                // крышка внешней части
                gl.DoTranslate(Vector3.UnitZ * WheelPartWidth, true);
                gl.DrawDisk(SmallWheelInnerRadius, SmallWheelOuterRadius, Roundness);

                gl.UndoTranslation();
                // кольцо в середине
                gl.DrawCylinder(SmallWheelRingRadius1, SmallWheelRingWidth, partsCount: Roundness);
                gl.DrawCylinder(SmallWheelRingRadius2, SmallWheelRingWidth, partsCount: Roundness);
                gl.DoTranslate(Vector3.UnitZ * SmallWheelRingWidth, true);
                gl.DrawDisk(SmallWheelRingRadius1, SmallWheelRingRadius2, Roundness);
                gl.UndoTranslation();
            }, 2, Vector3.UnitZ * -WheelConnectorWidth, Vector3.UnitY * 180);

            // соединитель
            gl.DrawCylinder(BigWheelConnectorRadius, -WheelConnectorWidth, partsCount: Roundness);
        }
Beispiel #3
0
        private static void DrawTurret(OpenGL gl, Texture hatchTexture)
        {
            gl.DoTranslate(-CabinetSlopeLength - 6, CabinetHeight, 0, true);

            // основа башни
            gl.Rotate(Vector3.UnitX * -90, true);
            gl.DrawCylinder(TurretBaseRadius, TurretBaseHeight, partsCount: 10, withEdges: true);
            gl.UndoRotation();

            // башня
            gl.DoTranslate(Vector3.UnitY * TurretBaseHeight, true);

            gl.Repeat(() =>
            {
                // боковая средняя пластина
                gl.Draw(BeginMode.Polygon, () =>
                {
                    gl.Vertex(TurretMiddleWidth, 0, TurretBottomMiddleWidth / 2);
                    gl.Vertex(-TurretMiddleWidth, 0, TurretBottomMiddleWidth / 2);
                    gl.Vertex(-TurretMiddleWidth, TurretHeight, TurretTopMiddleWidth / 2);
                    gl.Vertex(TurretMiddleWidth, TurretHeight, TurretTopMiddleWidth / 2);
                });

                // боковая передняя пластина
                gl.Draw(BeginMode.Polygon, () =>
                {
                    gl.Vertex(TurretMiddleWidth, 0, TurretBottomMiddleWidth / 2);
                    gl.Vertex(TurretMiddleWidth, TurretHeight, TurretTopMiddleWidth / 2);
                    gl.Vertex(TurretLength, TurretHeight, TurretTopFrontWidth / 2);
                    gl.Vertex(TurretLength, 0, TurretBottomFrontWidth / 2);
                });

                // боковая задняя пластина
                gl.Draw(BeginMode.Polygon, () =>
                {
                    gl.Vertex(-TurretMiddleWidth, 0, TurretBottomMiddleWidth / 2);
                    gl.Vertex(-TurretLength, 0, TurretBottomFrontWidth / 2);
                    gl.Vertex(-TurretLength, TurretHeight, TurretTopFrontWidth / 2);
                    gl.Vertex(-TurretMiddleWidth, TurretHeight, TurretTopMiddleWidth / 2);
                });
            }, 2, Vector3.Zero, Vector3.UnitY * 180);

            // передняя пластина

            gl.Repeat(() =>
            {
                gl.Draw(BeginMode.Polygon, () =>
                {
                    gl.Vertex(TurretLength, 0, TurretBottomFrontWidth / 2);
                    gl.Vertex(TurretLength, TurretHeight, TurretTopFrontWidth / 2);
                    gl.Vertex(TurretLength, TurretHeight, -TurretTopFrontWidth / 2);
                    gl.Vertex(TurretLength, 0, -TurretBottomFrontWidth / 2);
                });
            }, 2, Vector3.Zero, Vector3.UnitY * 180);

            // крышка
            gl.Draw(BeginMode.Polygon, () =>
            {
                gl.Vertex(TurretLength, TurretHeight, TurretTopFrontWidth / 2);
                gl.Vertex(TurretMiddleWidth, TurretHeight, TurretTopMiddleWidth / 2);
                gl.Vertex(-TurretMiddleWidth, TurretHeight, TurretTopMiddleWidth / 2);
                gl.Vertex(-TurretLength, TurretHeight, TurretTopFrontWidth / 2);

                gl.Vertex(-TurretLength, TurretHeight, -TurretTopFrontWidth / 2);
                gl.Vertex(-TurretMiddleWidth, TurretHeight, -TurretTopMiddleWidth / 2);
                gl.Vertex(TurretMiddleWidth, TurretHeight, -TurretTopMiddleWidth / 2);
                gl.Vertex(TurretLength, TurretHeight, -TurretTopFrontWidth / 2);
            }, true);

            // люк
            gl.DoTranslate(-TurretLength / 2, TurretHeight, -TurretTopFrontWidth / 2, true);

            DrawHatch(gl, hatchTexture);

            gl.UndoTranslation(2);

            //основа ствола
            gl.DoTranslate(Vector3.UnitX * TurretLength, true);

            // нижняя и верхняя пластина
            gl.Repeat(() =>
            {
                gl.Draw(BeginMode.Polygon, () =>
                {
                    gl.Vertex(BarrelBaseLength, 0, BarrelBaseWidth / 2);
                    gl.Vertex(BarrelBaseLength, 0, -BarrelBaseWidth / 2);
                    gl.Vertex(0, 0, -BarrelBaseWidth / 2);
                    gl.Vertex(0, 0, BarrelBaseWidth / 2);
                });
            }, 2, Vector3.UnitY * BarrelBaseHeight, Vector3.Zero);

            //боковые части
            gl.Repeat(() =>
            {
                gl.Draw(BeginMode.Quads, () =>
                {
                    gl.Vertex(Vector3.UnitZ * BarrelBaseWidth / 2);
                    gl.Vertex(0, BarrelBaseHeight, BarrelBaseWidth / 2);
                    gl.Vertex(BarrelBaseLength, BarrelBaseHeight, BarrelBaseWidth / 2);
                    gl.Vertex(BarrelBaseLength, 0, BarrelBaseWidth / 2);
                });
            }, 2, Vector3.UnitX * BarrelBaseLength, Vector3.UnitY * 180);

            // передняя крышка
            gl.Draw(BeginMode.Quads, () =>
            {
                gl.Vertex(BarrelBaseLength, 0, BarrelBaseWidth / 2);
                gl.Vertex(BarrelBaseLength, BarrelBaseHeight, BarrelBaseWidth / 2);
                gl.Vertex(BarrelBaseLength, BarrelBaseHeight, -BarrelBaseWidth / 2);
                gl.Vertex(BarrelBaseLength, 0, -BarrelBaseWidth / 2);
            });

            // дуло
            gl.DoTranslate(BarrelBaseLength, BarrelBaseHeight / 2, 0, true);

            gl.Rotate(Vector3.UnitZ * -90, true);
            gl.Rotate(Vector3.UnitX * -90, true);

            gl.SetColor(Color.DarkSlateGray);
            gl.DrawCylinder(BarrelRadius, BarrelLength, partsCount: Roundness);

            gl.UndoRotation(2);
        }