Beispiel #1
0
        public Polyhedron(PolyhedronType type, int len)
        {
            edges = new List <List <int> >();
            Edges = new List <Edge>();
            var ss = SchlafliSymbol.schlafliSymbol[type.ToString()];

            CountVertex   = 4 * ss.Item1 / (4 - (ss.Item1 - 2) * (ss.Item2 - 2));
            CountSegment  = ss.Item2 * CountVertex / 2;
            CountEdge     = ss.Item2 * CountVertex / ss.Item1;
            Type          = type;
            SegmentLength = len;
            vertexes      = new List <Point3D>();
            switch (type)
            {
            case PolyhedronType.Tetrahedron:
                BuildTetrahedron(len);
                break;

            case PolyhedronType.Hexahedron:
                BuildHexahedron(len);
                break;

            case PolyhedronType.Octahedron:
                BuildOctahedron(len);
                break;
            }
        }
Beispiel #2
0
 public SdlWindow(string title, int screenWidth, int screenHeight)
 {
     _title                 = title;
     _screenHeight          = screenHeight;
     _screenWidth           = screenWidth;
     _currenPolyhedronType  = PolyhedronType.ParallelepipedWithHole;
     _visibleFacetDrawer    = new VisibleFacetDrawer(NotVisibleLinesEnabled);
     _notVisibleFacetDrawer = new NotVisibleFacetDrawer(NotVisibleLinesEnabled);
 }
Beispiel #3
0
        public static IPolyhedron3D CreatePolyhedron(
            PolyhedronType type,
            HomogeneousPoint3D geometricCenter,
            HomogeneousPoint3D rotationCenter,
            params double[] args)
        {
            switch (type)
            {
            case PolyhedronType.Parallelepiped:
                return(CreateSingleSimplePolyhedron(
                           args[0], args[0], args[0],
                           geometricCenter,
                           rotationCenter));

            case PolyhedronType.ParallelepipedWithHole:
                return(CreateCompositePolyhedron(
                           args[0], args[0], args[0],
                           geometricCenter,
                           rotationCenter));

            case PolyhedronType.ManyParallelepipeds:
                return(CreateManySimplePolyhedrons(
                           args[0], args[0], args[0],
                           geometricCenter,
                           rotationCenter,
                           50));

            case PolyhedronType.Cubes:
                return(CreateCubes(
                           args[0] / 2, args[0] / 2, args[0] / 2,
                           geometricCenter,
                           rotationCenter));

            default:
                throw new ArgumentException($"No builder for type {type}");
            }
        }
Beispiel #4
0
        /// <summary>
        /// W, S        - Rotate around OX;
        /// A, D        - Rotate around OY;
        /// Q, E        - Rotate around OZ;
        /// Z, X        - Rotate around custom vector;
        /// R, F        - Move observer forward / backwards;
        /// NP_8, NP_2  - Move observer up / down;
        /// NP_4, NP_6  - Move observer left / right;
        /// T, G        - Move display forward / backwards;
        /// M           - Enable / disable invisible lines;
        /// O           - Single object scene (SOS);
        /// P           - Multiple objects scene (MOS).
        /// 1-4         - Switch figures (SOS), add figures (MOS);
        /// </summary>
        private void WindowProcedure()
        {
            bool exit = false;

            while (!exit)
            {
                SDL.SDL_Event sdlEvent;
                SDL.SDL_PollEvent(out sdlEvent);
                switch (sdlEvent.type)
                {
                case SDL.SDL_EventType.SDL_QUIT:
                {
                    exit = true;
                    break;
                }

                case SDL.SDL_EventType.SDL_KEYDOWN:
                {
                    var key = sdlEvent.key;
                    switch (key.keysym.sym)
                    {
                    case SDL.SDL_Keycode.SDLK_w:
                        _scene.RotateAroundAxis(Axis3D.OX, -_rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_s:
                        _scene.RotateAroundAxis(Axis3D.OX, _rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_a:
                        _scene.RotateAroundAxis(Axis3D.OY, _rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_d:
                        _scene.RotateAroundAxis(Axis3D.OY, -_rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_q:
                        _scene.RotateAroundAxis(Axis3D.OZ, -_rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_e:
                        _scene.RotateAroundAxis(Axis3D.OZ, _rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_z:
                        _scene.RotateAroundVector(-_rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_x:
                        _scene.RotateAroundVector(_rotationAngle);
                        break;

                    case SDL.SDL_Keycode.SDLK_r:
                        _scene.MoveObserverTo(new HomogeneousPoint3D(0, 0, _observerMoveStep, 1));
                        break;

                    case SDL.SDL_Keycode.SDLK_f:
                        _scene.MoveObserverTo(new HomogeneousPoint3D(0, 0, -_observerMoveStep, 1));
                        break;

                    case SDL.SDL_Keycode.SDLK_KP_8:
                        _scene.MoveObserverTo(new HomogeneousPoint3D(0, -_observerMoveStep, 0, 1));
                        break;

                    case SDL.SDL_Keycode.SDLK_KP_2:
                        _scene.MoveObserverTo(new HomogeneousPoint3D(0, _observerMoveStep, 0, 1));
                        break;

                    case SDL.SDL_Keycode.SDLK_KP_6:
                        _scene.MoveObserverTo(new HomogeneousPoint3D(_observerMoveStep, 0, 0, 1));
                        break;

                    case SDL.SDL_Keycode.SDLK_KP_4:
                        _scene.MoveObserverTo(new HomogeneousPoint3D(-_observerMoveStep, 0, 0, 1));
                        break;

                    case SDL.SDL_Keycode.SDLK_t:
                        _scene.MoveDisplay(_displayMoveStep);
                        break;

                    case SDL.SDL_Keycode.SDLK_g:
                        _scene.MoveDisplay(-_displayMoveStep);
                        break;

                    case SDL.SDL_Keycode.SDLK_m:
                        _notVisibleFacetDrawer.Enabled             = !_notVisibleFacetDrawer.Enabled;
                        _visibleFacetDrawer.EnabledNotVisibleParts = !_visibleFacetDrawer.EnabledNotVisibleParts;
                        break;

                    case SDL.SDL_Keycode.SDLK_1:
                        _currenPolyhedronType = PolyhedronType.Parallelepiped;
                        AddObjectToScene();
                        break;

                    case SDL.SDL_Keycode.SDLK_2:
                        _currenPolyhedronType = PolyhedronType.ParallelepipedWithHole;
                        AddObjectToScene();
                        break;

                    case SDL.SDL_Keycode.SDLK_3:
                        _currenPolyhedronType = PolyhedronType.ManyParallelepipeds;
                        AddObjectToScene();
                        break;

                    case SDL.SDL_Keycode.SDLK_4:
                        _currenPolyhedronType = PolyhedronType.Cubes;
                        AddObjectToScene();
                        break;

                    case SDL.SDL_Keycode.SDLK_p:
                        InitializeMultipleObjectsScene();
                        break;

                    case SDL.SDL_Keycode.SDLK_o:
                        InitializeSingleObjectScene();
                        break;
                    }
                    break;
                }
                }
                RenderScene();
                Thread.Sleep(_renderLoopTimeoutMs);
            }
        }