Ejemplo n.º 1
0
        private void Form1_Load(object sender, EventArgs e)
        {
            // инициализация библиотеки GLUT
            Glut.glutInit();
            // инициализация режима окна
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);

            // устанавливаем цвет очистки окна
            Gl.glClearColor(255, 255, 255, 1);
            Glu.gluOrtho2D(0.0, AnT.Width, 0.0, AnT.Height);

            // устанавливаем порт вывода, основываясь на размерах элемента управления AnT
            Gl.glViewport(0, 0, AnT.Width, AnT.Height);

            // устанавливаем проекционную матрицу
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            // очищаем ее
            Gl.glLoadIdentity();

            Gl.glMatrixMode(Gl.GL_MODELVIEW);
        }
Ejemplo n.º 2
0
        public static void Run()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_RGB | Glut.GLUT_DEPTH);
            Glut.glutCreateWindow("SurfaceOld");
            Init();
            Glut.glutDisplayFunc(new Glut.DisplayCallback(Display));
            Glut.glutKeyboardFunc(new Glut.KeyboardCallback(Keyboard));
            Glut.glutMotionFunc(new Glut.MotionCallback(Motion));
            Glut.glutMouseFunc(new Glut.MouseCallback(Mouse));
            Glut.glutReshapeFunc(new Glut.ReshapeCallback(Reshape));

            Glut.glutCreateMenu(new Glut.CreateMenuCallback(Menu));
            Glut.glutAddMenuEntry("Show control points", 1);
            Glut.glutAddMenuEntry("Hide control points", 0);
            Glut.glutAddMenuEntry("Solid", 2);
            Glut.glutAddMenuEntry("Wireframe", 3);
            Glut.glutAttachMenu(Glut.GLUT_RIGHT_BUTTON);

            Glut.glutMainLoop();
        }
Ejemplo n.º 3
0
        public Form1()
        {
            InitializeComponent();
            simpleOpenGlControl1.InitializeContexts();

            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Gl.glViewport(0, 0, simpleOpenGlControl1.Width, simpleOpenGlControl1.Height);
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45.0f, (float)simpleOpenGlControl1.Width / (float)simpleOpenGlControl1.Height, 0.1f, 200.0f);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();
            Gl.glEnable(Gl.GL_DEPTH_TEST);

            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glLightModelf(Gl.GL_LIGHT_MODEL_TWO_SIDE, Gl.GL_TRUE); // делаем так, чтобы освещались обе стороны полигона
            Gl.glEnable(Gl.GL_NORMALIZE);                             //делам нормали одинаковой величины во избежание артефактов

            DrawScene();
        }
Ejemplo n.º 4
0
 private void Form1_Load(object sender, EventArgs e)
 {
     // инициализация библиотеки GLUT
     Glut.glutInit();
     // инициализация режима окна
     Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
     // устанавливаем цвет очистки окна
     Gl.glClearColor(255, 255, 255, 1);
     // устанавливаем порт вывода, основываясь на размерах элемента управления AnT
     Gl.glViewport(0, 0, AnT.Width, AnT.Height);
     // устанавливаем проекционную матрицу
     Gl.glMatrixMode(Gl.GL_PROJECTION);
     // очищаем ее
     Gl.glLoadIdentity();
     Glu.gluOrtho2D(0.0, AnT.Width, 0.0, AnT.Height);
     // переходим к объектно-видовой матрице
     Gl.glMatrixMode(Gl.GL_MODELVIEW); ProgrammDrawingEngine = new anEngine(AnT.Width, AnT.Height, AnT.Width, AnT.Height);
     RenderTimer.Start();
     // добавление элемента, отвечающего за управления главным слоем в объект LayersControl
     LayersControl.Items.Add("Главный слой", true);
 }
Ejemplo n.º 5
0
        private void Form1_Load(object sender, EventArgs e)
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);

            Gl.glClearColor(255, 255, 255, 1);
            Gl.glViewport(0, 0, simpleOpenGlControl1.Width, simpleOpenGlControl1.Height);

            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45, (double)simpleOpenGlControl1.Width / (double)simpleOpenGlControl1.Height, 0.1, 200);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);

            Il.ilInit();
            Il.ilEnable(Il.IL_ORIGIN_SET);
        }
Ejemplo n.º 6
0
        static void Main(string[] args)
        {
            Glut.glutInit();
            Glut.glutInitWindowPosition(100, 100);
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Glut.glutInitWindowSize(width, height);
            Glut.glutCreateWindow("OpenGL Less2");
            Init();
            Glut.glutDisplayFunc(DisplayScene);
            Glut.glutIdleFunc(DisplayScene);

            /*Glut.glutDisplayFunc(drawSnowMan);
             * Glut.glutIdleFunc(drawSnowMan);*/
            /*Glut.glutDisplayFunc(Test.RenderWireSphere);
             * Glut.glutIdleFunc(Test.RenderWireSphere);*/
            /*Glut.glutDisplayFunc(Test.Display);
             * Glut.glutIdleFunc(Test.Display);*/
            Glut.glutSpecialFunc(processSpecialKeys);
            Glut.glutKeyboardFunc(processNormalKeys);
            Glut.glutMainLoop();
        }
Ejemplo n.º 7
0
        private void Form1_Load(object sender, EventArgs e)
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH); // инициализация режима экрана

            Il.ilInit();                                                                  // инициализация библиотеки openIL
            Il.ilEnable(Il.IL_ORIGIN_SET);

            Gl.glClearColor(255, 255, 255, 1);                      // установка цвета очистки экрана (RGBA)
            Gl.glViewport(0, 0, glControl.Width, glControl.Height); // установка порта вывода

            Gl.glMatrixMode(Gl.GL_PROJECTION);                      // активация проекционной матрицы
            Gl.glLoadIdentity();                                    // очистка матрицы
            Glu.gluOrtho2D(0, 0, glControl.Width, glControl.Height);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);                       // установка объектно-видовой матрицы
            Gl.glLoadIdentity();

            Gl.glEnable(Gl.GL_DEPTH_TEST);          // начальные настройки OpenGL
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);
        }
Ejemplo n.º 8
0
        //Инициализация
        static void init()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGBA | Glut.GLUT_DOUBLE);//Glut.GLUT_SINGLE
            Glut.glutInitWindowSize(WIDTH, HEIGHT);
            Glut.glutInitWindowPosition(0, 0);
            Glut.glutCreateWindow("Kursovykh");

            Gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            Gl.glShadeModel(Gl.GL_FLAT);


            //myMap.LoadMap(ref arrayOfCoins, ref arrayOfEnemy);
            loadTexture(ref texNormalEnemy, countNormalEnemy, @"materials\sprites\superAndroid\android");
            loadTexture(ref texEasyEnemy, countEasyEnemy, @"materials\sprites\jelly\jelly");
            loadTexture(ref texPlayer, countPlayer, @"materials\sprites\aquamen\aquamen");

            loadTexture(ref textures, textureCount);
            levels  = initLevels(N_levels, ref coins, ref enemies, textures, textureCount);
            player1 = new Player((int)levels[0].begin.X, (int)levels[0].begin.Y, texPlayer, countPlayer);
        }
Ejemplo n.º 9
0
 private void fmMain_Load(object sender, EventArgs e)
 {
     Glut.glutInit();                                                              // ініціалізація бібліотеки GLUT
     Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH); // ініціалізація режима вікна
     Gl.glClearColor(255, 255, 255, 1);                                            // установка кольору очистки вікна
     Gl.glViewport(0, 0, AnT.Width, AnT.Height);                                   // установка порту виведення на основі SimpleOpenGLControl
     Gl.glMatrixMode(Gl.GL_PROJECTION);                                            // установка проекційної матриці
     Gl.glLoadIdentity();                                                          // очистка проекційної матриці
     Glu.gluOrtho2D(0.0, AnT.Width, 0.0, AnT.Height);
     Gl.glMatrixMode(Gl.GL_MODELVIEW);                                             // установка обєктно-видової матриці
     ProgrammDrawingEngine = new anEngine(AnT.Width, AnT.Height, AnT.Width, AnT.Height);
     if (ProgramINI.KeyExists("ColorL", "Options"))
     {
         pnlColor1.BackColor = ColorTranslator.FromHtml(ProgramINI.Read("ColorL", "Options"));
     }
     if (ProgramINI.KeyExists("ColorR", "Options"))
     {
         pnlColor2.BackColor = ColorTranslator.FromHtml(ProgramINI.Read("ColorR", "Options"));
     }
     if (ProgramINI.KeyExists("PicturePath", "Options"))
     {
         MyDocPath = ProgramINI.Read("PicturePath", "Options");
     }
     if (ProgramINI.KeyExists("ViewXY", "Options"))
     {
         ViewXY = ProgramINI.Read("ViewXY", "Options");
     }
     if (ViewXY == "1")
     {
         miViewXY.Checked = true;
     }
     else
     {
         miViewXY.Checked = false;
     }
     mncbLayer.Items.Add("Основа");
     mncbLayer.SelectedIndex = 0;
     this.Text = "myPaint - " + ImgFileName;
     tmRender.Start();
 }
Ejemplo n.º 10
0
        private void CastleForm_Load(object sender, EventArgs e)
        {
            // инициализация библиотеки glut
            Glut.glutInit();
            // инициализация режима экрана
            Glut.glutInitDisplayMode(Glut.GLUT_RGBA | Glut.GLUT_SINGLE | Glut.GLUT_DEPTH);
            // установка цвета очистки экрана (RGBA)
            Gl.glClearColor(255, 255, 255, 1);

            // инициализация библиотеки openIL
            Il.ilInit();
            Il.ilEnable(Il.IL_ORIGIN_SET);

            // настройка проекции
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45, (float)glWindow.Width / glWindow.Height, 0.1, 200);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();


            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);
            Gl.glEnable(Gl.GL_COLOR_MATERIAL);

            var ambient        = new[] { 0.5882f, 0.5882f, 0.5882f };
            var diffuse        = new[] { 0.5882f, 0.5882f, 0.5882f };
            var specular       = new[] { 0.0f, 0.0f, 0.0f, 0.0f };
            var position       = new[] { 0.0f, 3.0f, 2.0f, 0.0f };
            var lmodel_ambient = new[] { 0.4f, 0.4f, 0.4f, 1.0f };
            var local_view     = new[] { 0.0f };

            Gl.glShadeModel(Gl.GL_SMOOTH);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambient);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, diffuse);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, position);
            Gl.glLightModelfv(Gl.GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
            Gl.glLightModelfv(Gl.GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);
        }
Ejemplo n.º 11
0
        private void Form1_Load(object sender, EventArgs e)
        {
            // виклик бібліотеки
            Glut.glutInit();
            // ініціалізація режиму екрана
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE);

            // встановлення кольору очистки екрана
            Gl.glClearColor(255, 255, 255, 1);

            // встановлення порту виводу
            Gl.glViewport(0, 0, AnT.Width, AnT.Height);

            // активація проекційної матриціі
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            // очистка матриці
            Gl.glLoadIdentity();

            // визначення параметрів налаштувань  проекції в залежності від розмірів сторін елемента AnT.
            if ((float)AnT.Width <= (float)AnT.Height)
            {
                ScreenW = 30.0;
                ScreenH = 30.0 * (float)AnT.Height / (float)AnT.Width;
                Glu.gluOrtho2D(0.0, ScreenW, 0.0, ScreenH);
            }
            else
            {
                ScreenW = 30.0 * (float)AnT.Width / (float)AnT.Height;
                ScreenH = 30.0;
                Glu.gluOrtho2D(0.0, 15.0 * (float)AnT.Width / (float)AnT.Height, 0.0, 30.0);
            }

            // збереження коефіціентів, які нам необхідні для переведення вказівника в віконній системі в координати,
            // прийняті в OpenGL сцені
            devX = (float)ScreenW / (float)AnT.Width;
            devY = (float)ScreenH / (float)AnT.Height;

            // установка обєктно-видової матриці
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
        }
Ejemplo n.º 12
0
        public static void Main()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Glut.glutInitWindowSize(DefaultWidth, DefaultHeight);
            Glut.glutCreateWindow("OpenGL Toutorial");

            Camera camera = new Camera();

            Glut.glutIdleFunc(OnRenderFrame);
            Glut.glutDisplayFunc(OnDisplay);
            Glut.glutCloseFunc(OnClose);
            Glut.glutKeyboardFunc(OnKeyboardDown);
            Glut.glutKeyboardUpFunc(OnKeyboardUp);
            Glut.glutReshapeFunc(camera.OnReshape);

            Gl.Enable(EnableCap.DepthTest);

            Texture1 = new Texture("Grass1.jpg");
            Cube     = new VBO <Vector3>(new Vector3[] {
                new Vector3(1, 1, -1), new Vector3(-1, 1, -1), new Vector3(-1, 1, 1), new Vector3(1, 1, 1),     //top
                new Vector3(1, -1, 1), new Vector3(-1, -1, 1), new Vector3(-1, -1, -1), new Vector3(1, -1, -1), //bottom
                new Vector3(1, 1, 1), new Vector3(-1, 1, 1), new Vector3(-1, -1, 1), new Vector3(1, -1, 1),     //front face
                new Vector3(1, -1, -1), new Vector3(-1, -1, -1), new Vector3(-1, 1, -1), new Vector3(1, 1, -1), //back face
                new Vector3(-1, 1, 1), new Vector3(-1, 1, -1), new Vector3(-1, -1, -1), new Vector3(-1, -1, 1), //left face
                new Vector3(1, 1, -1), new Vector3(1, 1, 1), new Vector3(1, -1, 1), new Vector3(1, -1, -1)
            });                                                                                                 //right face
            CubeUV = new VBO <Vector2>(new Vector2[] {
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1),
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1)
            });
            CubeQuads = new VBO <int>(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 }, BufferTarget.ElementArrayBuffer);

            Glut.glutMainLoop();
        }
Ejemplo n.º 13
0
        public static void InitDefaultGraphicContext(int width, int hegith, string header)
        {
            MonitorWidth       = width;
            MonitorHeight      = hegith;
            _monitorHeader     = header;
            Close              = true;
            GameObjectsArray   = new List <GameObject>();
            BackendObjectArray = new List <GameObject>();

            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Glut.glutInitWindowSize(MonitorWidth, MonitorHeight);
            Glut.glutSetOption(Glut.GLUT_ACTION_ON_WINDOW_CLOSE, Glut.GLUT_ACTION_CONTINUE_EXECUTION);


            Glut.glutCreateWindow(_monitorHeader);



            CreateProjectionMatrix();
            InitDefaultCallbacks();
        }
Ejemplo n.º 14
0
        private void Form1_Load(object sender, EventArgs e)
        {
            // инициализация библиотеки glut
            Glut.glutInit();
            // инициализация режима экрана
            Glut.glutInitDisplayMode(Glut.GLUT_RGBA | Glut.GLUT_SINGLE | Glut.GLUT_DEPTH);
            // установка цвета очистки экрана (RGBA)
            Gl.glClearColor(255, 255, 255, 1);

            // настройка проекции
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45, (float)glWindow.Width / glWindow.Height, 0.1, 200);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            // настройка параметров OpenGL для визуализации
            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);
            Gl.glEnable(Gl.GL_COLOR_MATERIAL);
        }
Ejemplo n.º 15
0
        private void openGLControl_Loaded(object sender, RoutedEventArgs e)
        {
            OpenGL gl = openGLControl.OpenGL;

            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);   // установка режима отображения

            gl.ClearColor(0.0f, 0.02f, 0.05f, 0f);

            gl.Enable(OpenGL.GL_DEPTH_TEST);
            gl.Enable(OpenGL.GL_COLOR_MATERIAL);
            gl.Enable(OpenGL.GL_LIGHTING);
            gl.Enable(OpenGL.GL_LIGHT0);

            float[] pos = new float[4] {
                -100.0f, 1.0f, -19.0f, 0.9f
            };
            float[] pos1 = new float[3] {
                -1.0f, -1.0f, -1.0f
            };
            float[] material = new float[4] {
                0.0f, 0.1f, 0.3f, 1.0f
            };
            float[] global_ambient = new float[4] {
                0f, 0.3f, 0.3f, 1.0f
            };

            gl.LightModel(OpenGL.GL_LIGHT_MODEL_AMBIENT, global_ambient);

            gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_POSITION, pos);
            gl.Light(OpenGL.GL_LIGHT0, OpenGL.GL_SPOT_DIRECTION, pos1);

            gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SPECULAR, material);
            gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SHININESS, 128);

            gl.MatrixMode(OpenGL.GL_PROJECTION);
            gl.LoadIdentity();
            gl.Perspective(70, (float)Width / (float)Height, 0.01, 100.0);
        }
Ejemplo n.º 16
0
        public static void Main(string[] args)
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DEPTH | Glut.GLUT_DOUBLE | Glut.GLUT_MULTISAMPLE | Glut.GLUT_RGBA);
            Glut.glutInitWindowSize(800, 600);
            Glut.glutInitWindowPosition(50, 50);
            Glut.glutCreateWindow("Maiden");

            Glut.glutDisplayFunc(new Glut.DisplayCallback(Display));
            Glut.glutKeyboardFunc(new Glut.KeyboardCallback(Keyboard));
            Glut.glutIdleFunc(new Glut.IdleCallback(Idle));
            Glut.glutReshapeFunc(new Glut.ReshapeCallback(Reshape));
            Glut.glutSpecialFunc(new Glut.SpecialCallback(Special));

            Glut.glutCreateMenu(new Glut.CreateMenuCallback(Menu));
            Glut.glutAddMenuEntry("Toggle texture mapping", (int)'t');
            Glut.glutAddMenuEntry("Toggle texture mode", (int)'m');
            Glut.glutAddMenuEntry("Toggle filter mode", (int)'f');
            Glut.glutAddMenuEntry("Toggle performance", (int)'p');
            Glut.glutAddMenuEntry("Toggle background", (int)'b');
            Glut.glutAddMenuEntry("Toggle animation", (int)' ');
            Glut.glutAddMenuEntry("Toggle culling", (int)'c');
            Glut.glutAddMenuEntry("Toggle stars", (int)'*');
            Glut.glutAddMenuEntry("Time full frame (no swap)", (int)'n');
            Glut.glutAddMenuEntry("Print pixels/frame", (int)'r');
            Glut.glutAddMenuEntry("", 0);
            Glut.glutAddMenuEntry("> and < keys change # of textures", 0);
            Glut.glutAddMenuEntry("Arrows up/down change level of detail", 0);
            Glut.glutAddMenuEntry("Arrows right/left change # of spheres", 0);
            Glut.glutAddMenuEntry("1-4 keys change background image", 0);
            Glut.glutAddMenuEntry("", 0);
            Glut.glutAddMenuEntry("Quit", (int)'r');
            Glut.glutAttachMenu(Glut.GLUT_RIGHT_BUTTON);

            Init();
            LoadTextures();

            Glut.glutMainLoop();
        }
Ejemplo n.º 17
0
        static void Main()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Glut.glutInitWindowSize(Width, Height);

            ScreenWidth  = Glut.glutGet(Glut.GLUT_SCREEN_WIDTH);
            ScreenHeight = Glut.glutGet(Glut.GLUT_SCREEN_HEIGHT);

            Glut.glutInitWindowPosition((ScreenWidth - Width) / 2, (ScreenHeight - Height) / 2);
            Glut.glutCreateWindow("");
            //Glut.glutGameModeString(Width+"x"+Height+":32@60");

            Glut.glutSetOption(Glut.GLUT_ACTION_ON_WINDOW_CLOSE, Glut.GLUT_ACTION_CONTINUE_EXECUTION);
            Gl.Viewport(0, 0, Width, Height);
            Glut.glutDisplayFunc(delegate() { });
            Glut.glutIdleFunc(MainGameLoop);

            Init();

            Glut.glutMainLoop();
        }
Ejemplo n.º 18
0
        // событие загрузки формы
        private void Form1_Load(object sender, EventArgs e)
        {
            // инициализация бибилиотеки glut
            Glut.glutInit();
            // инициализация режима экрана
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE);

            // инициализация библиотеки openIL
            Il.ilInit();
            Il.ilEnable(Il.IL_ORIGIN_SET);

            // установка цвета очистки экрана (RGBA)
            Gl.glClearColor(255, 255, 255, 1);

            // установка порта вывода
            Gl.glViewport(0, 0, AnT.Width, AnT.Height);


            // активация проекционной матрицы
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            // очистка матрицы
            Gl.glLoadIdentity();

            // установка перспективы
            Glu.gluPerspective(30, AnT.Width / AnT.Height, 1, 100);

            // установка объектно-видовой матрицы
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            // начальные настройки OpenGL
            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);

            // активация таймера
            RenderTimer.Start();
        }
Ejemplo n.º 19
0
        static void Main(string[] args)
        {
            // create an OpenGL window
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Glut.glutInitWindowSize(width, height);
            Glut.glutCreateWindow("OpenGL Tutorial");

            // provide the Glut callbacks that are necessary for running this tutorial
            Glut.glutIdleFunc(OnRenderFrame);
            Glut.glutDisplayFunc(OnDisplay);
            Glut.glutCloseFunc(OnClose);

            // enable depth testing to ensure correct z-ordering of our fragments
            Gl.Enable(EnableCap.DepthTest);

            // compile the shader program
            program = new ShaderProgram(VertexShader, FragmentShader);

            // set the view and projection matrix, which are static throughout this tutorial
            program.Use();
            program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
            program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, new Vector3(0, 1, 0)));

            // create a triangle with vertices and colors
            triangle         = new VBO <Vector3>(new Vector3[] { new Vector3(0, 1, 0), new Vector3(-1, -1, 0), new Vector3(1, -1, 0) });
            triangleColor    = new VBO <Vector3>(new Vector3[] { new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1) });
            triangleElements = new VBO <uint>(new uint[] { 0, 1, 2 }, BufferTarget.ElementArrayBuffer);

            // create a square with vertices an colors
            square         = new VBO <Vector3>(new Vector3[] { new Vector3(-1, 1, 0), new Vector3(1, 1, 0), new Vector3(1, -1, 0), new Vector3(-1, -1, 0) });
            squareElements = new VBO <uint>(new uint[] { 0, 1, 2, 3 }, BufferTarget.ElementArrayBuffer);
            squareColor    = new VBO <Vector3>(new Vector3[] { new Vector3(0.5f, 0.5f, 1), new Vector3(0.5f, 0.5f, 1), new Vector3(0.5f, 0.5f, 1), new Vector3(0.5f, 0.5f, 1) });

            watch = System.Diagnostics.Stopwatch.StartNew();

            Glut.glutMainLoop();
        }
Ejemplo n.º 20
0
        static void Main(string[] args)
        {
            _starfield  = new StarField(150);
            _blackfog   = new BlackFog();
            _scrolltext = new ScrollText(
                "FTGL 2.1.3: A NEW VERSION\n"
                + "\n"
                + "FTGL is a free cross-platform Open Source library that "
                + "uses Freetype2 to simplify rendering fonts in OpenGL "
                + "applications. FTGL supports bitmap, pixmap, texture map, "
                + "outline, polygon mesh, and extruded polygon rendering "
                + "modes.\n"
                + "\n"
                + "FTGL offers both a C++ and a plain C programming interface. "
                + "Various bindings exist for other languages such as Python or "
                + "Ruby. This program was done in C# using FTGL's .NET "
                + "language bindings.\n"
                + "\n"
                + "It's time to press ESC because this is the end of the "
                + "scrolltext."
                + "\n\n\n\n\n\n\n\n\n\n\n\n\n"
                + "No, really.\n"
                + "\n\n\n\n\n\n\n\n\n\n\n\n\n"
                + "It's over.\n"
                + "\n\n\n\n\n\n\n\n\n\n\n\n\n"
                + "Please let go now!");

            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DEPTH | Glut.GLUT_RGB | Glut.GLUT_DOUBLE);
            Glut.glutInitWindowPosition(50, 50);
            Glut.glutInitWindowSize(480, 270);
            Glut.glutCreateWindow("FTGL scrolltext");
            Glut.glutDisplayFunc(Display);
            Glut.glutKeyboardFunc(Parsekey);
            Glut.glutReshapeFunc(Reshape);
            Glut.glutIdleFunc(Idle);
            Glut.glutMainLoop();
        }
Ejemplo n.º 21
0
        static void Main(string[] args)
        {
            t1.Start();
            t1.IsBackground = true;

            t2.Start();
            t2.IsBackground = true;

            //getserialport();


            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_RGB);         // Setup display mode to double buffer and RGB color
            Glut.glutInitWindowSize(800, 800);                                  // Set the screen size
            Glut.glutCreateWindow("OpenGL 3D Navigation Program With Tao");
            init();
            Glut.glutReshapeFunc(reshape);
            Glut.glutDisplayFunc(display);
            Glut.glutSpecialFunc(new Glut.SpecialCallback(specialKey));      // set window's to specialKey callback
            TimerFunction(0);
            //TimerFunction2(0);
            Glut.glutMainLoop();
        }
Ejemplo n.º 22
0
 public static void Execute(int i = 1)
 {
     Glut.glutInit();
     Glut.glutInitWindowPosition(100, 100);
     Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_RGBA | Glut.GLUT_DEPTH);
     Glut.glutInitWindowSize(width, height);
     Glut.glutCreateWindow("OpenGL Task2");
     if (i == 1)
     {
         Glut.glutDisplayFunc(RenderTriangle);
     }
     if (i == 2)
     {
         Glut.glutDisplayFunc(RenderQuads);
     }
     if (i == 3)
     {
         isColor = true;
         Glut.glutDisplayFunc(RenderTriangle);
     }
     Init();
     Glut.glutMainLoop();
 }
Ejemplo n.º 23
0
        private void Form1_Load(object sender, EventArgs e)
        {
            // инициализация Glut
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);

            // очитка окна
            Gl.glClearColor(255, 255, 255, 1);

            // установка порта вывода в соотвествии с размерами элемента anT
            Gl.glViewport(0, 0, AnT.Width, AnT.Height);


            // настройка проекции
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45, (float)AnT.Width / (float)AnT.Height, 0.1, 200);
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            // настройка параметров OpenGL для визуализации
            Gl.glEnable(Gl.GL_DEPTH_TEST);
        }
Ejemplo n.º 24
0
        public Form1()
        {
            InitializeComponent();

            AnT.InitializeContexts();
            // инициализация Glut
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);

            Gl.glClearColor(0, 0, 0, 1); // отчитка окна
            //Gl.glViewport(0, 0, AnT.Width, AnT.Height); // установка порта вывода в соответствии с размерами элемента anT
            //Gl.glViewport(-10f, 10f, 20f, 20f);

            // настройка проекции
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();

            //Glu.gluOrtho2D(0.0, (float)AnT.Width, (float)AnT.Height, 0);
            Glu.gluOrtho2D(-5f, 5f, -0.0005f, 0.0005f);

            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();
        }
Ejemplo n.º 25
0
 static void Main(string[] args)
 //programos vykdymo pradžia
 {                                                                      //
     Glut.glutInit();                                                   //inicializuojama GLUT aplinka
     Glut.glutInitDisplayMode(Glut.GLUT_SINGLE | Glut.GLUT_RGB);        //nustatomi vaizdavimo parametrai
     Glut.glutInitWindowSize(400, 400);                                 //nustatomas programos lango dydis
     Glut.glutInitWindowPosition(400, 300);                             //nustatoma lango pozicija
     Glut.glutCreateWindow("NIF06020");                                 //sukuriamas langas
     Init();                                                            //papildomi OpenGL būsenų nustatymai
     Glut.glutDisplayFunc(new Glut.DisplayCallback(Figura));            //vaizdavimo metodo uzregistravimas
     Glut.glutKeyboardFunc(new Glut.KeyboardCallback(Klaviatura1));     //metodo klaviatura1 uzregistravimas
     Glut.glutSpecialFunc(new Glut.SpecialCallback(Klaviatura2));       //metodo klaviatura2 uzregistravimas
     Glut.glutMouseFunc(new Glut.MouseCallback(Pele));                  //metodo pele uzregistravimas
     Glut.glutCreateMenu(new Glut.CreateMenuCallback(Meniu));           //metodo meniu uzregistravimas
     Glut.glutAddMenuEntry("Pirmas punktas", '1');                      //i kontekstini meniu itraukiamas pirmas pasirinkimas
     Glut.glutAddMenuEntry("Antras punktas", '2');                      //i kontekstini meniu itraukiamas antras pasirinkimas
     Glut.glutAddMenuEntry("Trecias punktas", '3');                     //i kontekstini meniu itraukiamas trecias pasirinkimas
     Glut.glutAddMenuEntry("Ketvirtas punktas", '4');                   //i kontekstini meniu itraukiamas ketvirtas pasirinkimas
     Glut.glutAddMenuEntry("Penktas punktas", '5');                     //i kontekstini meniu itraukiamas penktas pasirinkimas
     Glut.glutAddMenuEntry("Progamos pabaiga", '6');                    //i kontekstini meniu itraukiamas sestas pasirinkimas
     Glut.glutAttachMenu(Glut.GLUT_RIGHT_BUTTON);                       //uzregistuojamas iskleidziamas meniu
     Glut.glutMainLoop();                                               //pradedamas vykdyti grafines programos ciklas
 }                                                                      //
Ejemplo n.º 26
0
        static void Main(string[] args)
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DEPTH | Glut.GLUT_DOUBLE);
            Glut.glutInitWindowSize(width, height);
            Glut.glutInitWindowPosition(pos_x, pos_y);
            Glut.glutCreateWindow(window_Title);
            Glut.glutIdleFunc(onRenderFrame);
            Glut.glutDisplayFunc(onDisplay);

            SHprogram = new ShaderProgram(VertexShader, FragmentShader);
            SHprogram.Use();
            SHprogram["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 10000f));
            SHprogram["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 10), Vector3.Zero, Vector3.Up));

            triangle     = new VBO <Vector3>(new Vector3[] { new Vector3(-1, -1, 0), new Vector3(1, -1, 0), new Vector3(0, 1, 0) });
            triangle_el  = new VBO <int>(new int[] { 0, 1, 2 }, BufferTarget.ElementArrayBuffer);
            triangle_col = new VBO <Vector3>(new Vector3[] { new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1) });

            watch = System.Diagnostics.Stopwatch.StartNew();

            Glut.glutMainLoop();
        }
Ejemplo n.º 27
0
        void OpenGlInit()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGBA | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Gl.glClearColor(255, 255, 255, 1);
            Gl.glViewport(0, 0, Scene.Width, Scene.Height);
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glLoadIdentity();
            Glu.gluPerspective(45, (float)Scene.Width / Scene.Height, 1, 2 * distance);

            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glLoadIdentity();

            Gl.glEnable(Gl.GL_DEPTH_TEST);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glEnable(Gl.GL_LIGHT0);

            Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
            Gl.glHint(Gl.GL_LINE_SMOOTH_HINT, Gl.GL_NICEST);
            Gl.glEnable(Gl.GL_BLEND);
            Gl.glEnable(Gl.GL_LINE_SMOOTH);
            Gl.glLineWidth(1.0f);
        }
Ejemplo n.º 28
0
        static void Main(string[] args)
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);
            Glut.glutInitWindowSize(width, height);
            Glut.glutCreateWindow("3D Car Particle");

            Glut.glutIdleFunc(OnRenderFrame);
            Glut.glutDisplayFunc(OnDisplay);

            Glut.glutKeyboardFunc(OnKeyboardDown);
            Glut.glutKeyboardUpFunc(OnKeyboardUp);
            Glut.glutMouseWheelFunc(MouseWheel);

            Glut.glutCloseFunc(OnClose);
            Glut.glutReshapeFunc(OnReshape);

            Gl.Disable(EnableCap.DepthTest);
            Gl.Enable(EnableCap.Blend);
            Gl.Enable(EnableCap.ProgramPointSize);
            Gl.Enable(EnableCap.Multisample);
            Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);

            program = new ShaderProgram(VertexShader, FragmentShader);

            program.Use();
            program["projection_matrix"].SetValue(Matrix4.CreatePerspectiveFieldOfView(0.45f, (float)width / height, 0.1f, 1000f));
            program["view_matrix"].SetValue(Matrix4.LookAt(new Vector3(0, 0, 6), new Vector3(1.2f, 0.2f, 0f), new Vector3(0, 1, 0)));

            program["light_direction"].SetValue(new Vector3(0, 0, 1));
            program["enable_lighting"].SetValue(lighting);

            carmodel = new CarModel();
            watch    = System.Diagnostics.Stopwatch.StartNew();

            Glut.glutMainLoop();
        }
Ejemplo n.º 29
0
        private void Form1_Load(object sender, EventArgs e)
        {
            FI = ToRad(180 + FI0);
            W0 = -(float)Math.Sqrt(G / L);
            if (K == 0)
            {
                B = 0;
            }
            else
            {
                B = K / (2 * M);
            }
            //B = K / (2*M);
            //B = K;
            Ws = -(float)Math.Sqrt((Math.Pow(W0, 2) - Math.Pow(B, 2)));


            X = (float)Math.Sin(FI) * L;
            V = (float)Math.Sin(FI) * G;


            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE);
            Gl.glClearColor(255, 255, 255, 1);

            AnT_Load();
            Graph_Load();
            Diagram_Load();

            textBox1.Text = L.ToString();
            textBox2.Text = M.ToString();
            textBox3.Text = FI0.ToString();
            textBox4.Text = XS.ToString();
            textBox5.Text = K.ToString();

            comboBox1.SelectedIndex = 0;
        }
Ejemplo n.º 30
0
        public static void Run()
        {
            // initialize GLUT
            Glut.glutInit();
            // double buffer, use rgb color, enable depth buffer
            Glut.glutInitDisplayMode(Glut.GLUT_DOUBLE | Glut.GLUT_RGB | Glut.GLUT_DEPTH);
            // initialize the window size
            Glut.glutInitWindowSize(windowWidth, windowHeight);
            // set the window postion
            Glut.glutInitWindowPosition(100, 100);
            // create the window
            Glut.glutCreateWindow("Shadow");

            // set the display function - called when redrawing
            Glut.glutDisplayFunc(new Glut.DisplayCallback(Display));
            // set the idle function - called when idle
            if (isRotating)
            {
                Glut.glutIdleFunc(new Glut.IdleCallback(Idle));
            }
            else
            {
                Glut.glutIdleFunc(null);
            }
            // set the keyboard function - called on keyboard events
            Glut.glutKeyboardFunc(new Glut.KeyboardCallback(Keyboard));
            // set the mouse function - called on mouse stuff
            Glut.glutMouseFunc(new Glut.MouseCallback(Mouse));
            // set the reshape function - called when client area changes
            Glut.glutReshapeFunc(new Glut.ReshapeCallback(Reshape));

            // do our own initialization
            Init();

            // let GLUT handle the current thread from here
            Glut.glutMainLoop();
        }