docs/ja-jp/source/usingopengl.txt

   1 .. index::
   2         single: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); はじめに
   3
   4 ===========================================================
   5 RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス)
   6 ===========================================================
   7
   8
   9 RingOpenGL と RingFreeGLUT の用法を学びます。
  10
  11
  12 .. index::
  13         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); サンプルソース (作者)
  14
  15 サンプルソース (作者)
  16 =====================
  17
  18 この C チュートリアルを参考に本章のサンプルを記述しました。
  19
  20 出典元:
  21
  22 (1) http://www.lighthouse3d.com/tutorials/glut-tutorial/
  23
  24 (2) http://www.wikihow.com/Make-a-Cube-in-OpenGL
  25
  26
  27 .. index::
  28         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); RingOpenGL とは？
  29
  30 RingOpenGL とは？
  31 =================
  32
  33 RingOpenGL は Ring 付属の OpenGL ライブラリのバインディングです。
  34
  35 こちらから OpenGL について学べます : https://www.opengl.org/
  36
  37 RingOpenGL は下記のバージョンに対応しています。
  38
  39 * OpenGL 1.1
  40 * OpenGL 1.2
  41 * OpenGL 1.3
  42 * OpenGL 1.4
  43 * OpenGL 1.5
  44 * OpenGL 2.0
  45 * OpenGL 2.1
  46 * OpenGL 3.0
  47 * OpenGL 3.2
  48 * OpenGL 3.3
  49 * OpenGL 4.0
  50 * OpenGL 4.1
  51 * OpenGL 4.2
  52 * OpenGL 4.3
  53 * OpenGL 4.4
  54 * OpenGL 4.5
  55 * OpenGL 4.6
  56
  57 OpenGL 2.1 の場合は RingOpenGL 2.1 ライブラリを読み込みます。
  58
  59 .. code-block:: ring
  60
  61         load "opengl21lib.ring"
  62
  63
  64 .. index::
  65         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); RingFreeGLUT とは？
  66
  67 RingFreeGLUT とは？
  68 ===================
  69
  70 RingFreeGLUT は Ring 付属の FreeGLUT ライブラリのバインディングです。
  71
  72 このサイトで FreeGLUT について学べます : http://freeglut.sourceforge.net/
  73
  74 RingFreeGLUT の使用前に freeglut.ring ライブラリを読み込みます。
  75
  76 .. code-block:: ring
  77
  78         load "freeglut.ring"
  79
  80
  81 .. index::
  82         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); RingFreeGLUT によるはじめてのウィンドウ
  83
  84 RingFreeGLUT によるはじめてのウィンドウ
  85 =======================================
  86
  87 用例:
  88
  89 .. code-block:: ring
  90
  91         load "freeglut.ring"
  92
  93         func main
  94                 glutInit()
  95                 glutInitDisplayMode(GLUT_SINGLE)
  96                 glutInitWindowSize(800, 600)
  97                 glutInitWindowPosition(100, 10)
  98                 glutCreateWindow("RingFreeGLUT - Test 1")
  99                 glutDisplayFunc(:displayCode)
 100                 glutMainLoop()
 101
 102         func displaycode
 103
 104 スクリーンショット:
 105
 106 .. image:: freeglutshot1.png
 107         :alt: RingFreeGLUT
 108
 109
 110 .. index::
 111         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); RingOpenGL での描画
 112
 113
 114 RingOpenGL での描画
 115 ===================
 116
 117 用例:
 118
 119 .. code-block:: ring
 120
 121         load "freeglut.ring"
 122         load "opengl21lib.ring"
 123
 124
 125         func main
 126                 glutInit()
 127                 glutInitDisplayMode(GLUT_SINGLE)
 128                 glutInitWindowSize(800, 600)
 129                 glutInitWindowPosition(100, 10)
 130                 glutCreateWindow("RingFreeGLUT - Test 2")
 131                 glutDisplayFunc(:displayCode)
 132                 glutMainLoop()
 133
 134         func displaycode
 135                 glClear(GL_COLOR_BUFFER_BIT)
 136                 glColor3f(0,255,0)
 137                 glBegin(GL_POLYGON)
 138                         glVertex3f(0.0, 0.0, 0.0)
 139                         glVertex3f(0.5, 0.0, 0.0)
 140                         glVertex3f(0.5, 0.5, 0.0)
 141                         glVertex3f(0.0, 0.5, 0.0)
 142                 glEnd()
 143                 glColor3f(255,0,0)
 144                 glBegin(GL_POLYGON)
 145                         glVertex3f(0.0, 0.0, 0.0)
 146                         glVertex3f(0.5, 0.0, 0.0)
 147                         glVertex3f(-0.5,- 1, 0.0)
 148                         glVertex3f(0.0, -1, 0.0)
 149                 glEnd()
 150                 glColor3f(0,0,255)
 151                 glBegin(GL_POLYGON)
 152                        glVertex3f(0.0, 0.0, 0.0)
 153                         glVertex3f(-0.5, 0.0, 0.0)
 154                         glVertex3f(-0.5,- 0.5, 0.0)
 155                         glVertex3f(0.0, -0.5, 0.0)
 156                 glEnd()
 157
 158                 glFlush()
 159
 160 スクリーンショット:
 161
 162 .. image:: freeglutshot2.png
 163         :alt: RingFreeGLUT
 164
 165
 166 .. index::
 167         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); はじめての三角形
 168
 169
 170 はじめての三角形
 171 ================
 172
 173 用例:
 174
 175 .. code-block:: ring
 176
 177         load "freeglut.ring"
 178         load "opengl21lib.ring"
 179
 180         func main
 181                 glutInit()
 182                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
 183                 glutInitWindowSize(320,320)
 184                 glutInitWindowPosition(100, 10)
 185                 glutCreateWindow("RingFreeGLUT - Test 3")
 186                 glutDisplayFunc(:renderScene)
 187                 glutMainLoop()
 188
 189         func renderScene
 190
 191                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 192
 193                 glBegin(GL_TRIANGLES)
 194                         glVertex3f(-0.5,-0.5,0.0)
 195                         glVertex3f(0.5,0.0,0.0)
 196                         glVertex3f(0.0,0.5,0.0)
 197                 glEnd()
 198
 199                 glutSwapBuffers()
 200
 201
 202 スクリーンショット:
 203
 204 .. image:: freeglutshot3.png
 205         :alt: RingFreeGLUT
 206
 207 .. index::
 208         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); ウィンドウの大きさ変更イベント
 209
 210 ウィンドウの大きさ変更イベント
 211 ==============================
 212
 213 用例:
 214
 215 .. code-block:: ring
 216
 217         load "freeglut.ring"
 218         load "opengl21lib.ring"
 219
 220         func main
 221
 222                 // GLUT の初期化とウィンドウの作成
 223                 glutInit()
 224                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
 225                 glutInitWindowPosition(100,100)
 226                 glutInitWindowSize(320,320)
 227                 glutCreateWindow("RingFreeGLUT - Test 4")
 228
 229                 glutDisplayFunc(:renderScene)
 230                 glutReshapeFunc(:changeSize)
 231
 232                 glutMainLoop()
 233
 234         func renderScene
 235
 236                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 237
 238                 glBegin(GL_TRIANGLES)
 239                         glVertex3f(-2,-2,-5.0)
 240                         glVertex3f(2,0.0,-5.0)
 241                         glVertex3f(0.0,2,-5.0)
 242                 glEnd()
 243
 244                 glutSwapBuffers()
 245
 246         func changesize
 247
 248                 h = glutEventHeight()
 249                 w = glutEventWidth()
 250
 251                         // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
 252                 // (幅 0 のウィンドウは作成できません)
 253                 if (h = 0)
 254                         h = 1
 255                 ok
 256
 257                 ratio =  w * 1.0 / h
 258
 259                 // 投射行列の使用
 260                 glMatrixMode(GL_PROJECTION)
 261
 262                 // 行列のリセット
 263                 glLoadIdentity()
 264
 265                 // ウィンドウ全体のビューポートを設定します。
 266                 glViewport(0, 0, w, h)
 267
 268                  // 正しい遠近法の設定
 269                 gluPerspective(45,ratio,1,100)
 270
 271                 // Modelview の復帰
 272                 glMatrixMode(GL_MODELVIEW)
 273
 274 .. index::
 275         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); 三角形の回転
 276
 277 三角形の回転
 278 ============
 279
 280 用例:
 281
 282 .. code-block:: ring
 283
 284         load "freeglut.ring"
 285         load "opengl21lib.ring"
 286
 287         angle = 0
 288
 289         func main
 290
 291                 // GLUT の初期化とウィンドウの作成
 292                 glutInit()
 293                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
 294                 glutInitWindowPosition(100,100)
 295                 glutInitWindowSize(320,320)
 296                 glutCreateWindow("RingFreeGLUT - Test 5")
 297
 298                 glutDisplayFunc(:renderScene)
 299                 glutReshapeFunc(:changeSize)
 300                 glutIdleFunc(:renderScene)
 301
 302                 glutMainLoop()
 303
 304         func renderScene
 305
 306                 // 配色と深度バッファの消去
 307                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 308
 309                 // 変換のリセット
 310                 glLoadIdentity()
 311                 // カメラの設定
 312                 gluLookAt(      0.0, 0.0, 10.0,
 313                                         0.0, 0.0,  0.0,
 314                                         0.0, 1.0,  0.0)
 315
 316                 glRotatef(angle, 0.0, 1.0, 0.0)
 317
 318                 glBegin(GL_TRIANGLES)
 319                         glVertex3f(-2.0,-2.0, 0.0)
 320                         glVertex3f( 2.0, 0.0, 0.0)
 321                         glVertex3f( 0.0, 2.0, 0.0)
 322                 glEnd()
 323
 324                 angle+=0.1
 325
 326                 glutSwapBuffers();
 327
 328         func changesize
 329
 330                 h = glutEventHeight()
 331                 w = glutEventWidth()
 332
 333                         // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
 334                 // (幅 0 のウィンドウは作成できません)
 335                 if (h = 0)
 336                         h = 1
 337                 ok
 338
 339                 ratio =  w * 1.0 / h
 340
 341                 // 投射行列の使用
 342                 glMatrixMode(GL_PROJECTION)
 343
 344                 // 行列のリセット
 345                 glLoadIdentity()
 346
 347                 // ウィンドウ全体のビューポートを設定します。
 348                 glViewport(0, 0, w, h)
 349
 350                  // 正しい遠近法の設定
 351                 gluPerspective(45,ratio,1,100)
 352
 353                 // Modelview の復帰
 354                 glMatrixMode(GL_MODELVIEW)
 355
 356
 357 スクリーンショット:
 358
 359 .. image:: freeglutshot4.png
 360         :alt: RingFreeGLUT
 361
 362
 363 .. index::
 364         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); キーボードイベントと配色
 365
 366 キーボードイベントと配色
 367 ========================
 368
 369 用例:
 370
 371 .. code-block:: ring
 372
 373
 374         load "freeglut.ring"
 375         load "opengl21lib.ring"
 376
 377         angle = 0
 378
 379         red=1.0
 380         blue=1.0
 381         green=1.0
 382
 383         func main
 384
 385                 // GLUT の初期化とウィンドウの作成
 386                 glutInit()
 387                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
 388                 glutInitWindowPosition(100,100)
 389                 glutInitWindowSize(320,320)
 390                 glutCreateWindow("RingFreeGLUT - Test 6")
 391
 392                 glutDisplayFunc(:renderScene)
 393                 glutReshapeFunc(:changeSize)
 394                 glutIdleFunc(:renderScene)
 395
 396                 // これは新しいエントリーです。
 397                 glutKeyboardFunc(:processNormalKeys)
 398                 glutSpecialFunc(:processSpecialKeys)
 399
 400                 glutMainLoop()
 401
 402         func renderScene
 403
 404                 // 配色と深度バッファの消去
 405                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 406
 407                 // 変換のリセット
 408                 glLoadIdentity()
 409                 // カメラの設定
 410                 gluLookAt(      0.0, 0.0, 10.0,
 411                                         0.0, 0.0,  0.0,
 412                                         0.0, 1.0,  0.0)
 413
 414                 glRotatef(angle, 0.0, 1.0, 0.0)
 415
 416
 417                 glColor3f(red,green,blue);
 418
 419                 glBegin(GL_TRIANGLES)
 420                         glVertex3f(-2.0,-2.0, 0.0)
 421                         glVertex3f( 2.0, 0.0, 0.0)
 422                         glVertex3f( 0.0, 2.0, 0.0)
 423                 glEnd()
 424
 425                 angle+=0.1
 426
 427                 glutSwapBuffers();
 428
 429         func changesize
 430
 431                 h = glutEventHeight()
 432                 w = glutEventWidth()
 433
 434                         // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
 435                 // (幅 0 のウィンドウは作成できません)
 436                 if (h = 0)
 437                         h = 1
 438                 ok
 439
 440                 ratio =  w * 1.0 / h
 441
 442                 // 投射行列の使用
 443                 glMatrixMode(GL_PROJECTION)
 444
 445                 // 行列のリセット
 446                 glLoadIdentity()
 447
 448                 // ウィンドウ全体のビューポートを設定します。
 449                 glViewport(0, 0, w, h)
 450
 451                  // 正しい遠近法の設定
 452                 gluPerspective(45,ratio,1,100)
 453
 454                 // Modelview の復帰
 455                 glMatrixMode(GL_MODELVIEW)
 456
 457         func processNormalKeys
 458                 key = GLUTEventKey()
 459                 if key = 27
 460                         shutdown()
 461                 ok
 462
 463         func processSpecialKeys
 464
 465                 key = GLUTEventKey()
 466
 467                 switch key
 468                         on GLUT_KEY_F1
 469                                         red = 1.0
 470                                         green = 0.0
 471                                         blue = 0.0
 472                         on GLUT_KEY_F2
 473                                         red = 0.0
 474                                         green = 1.0
 475                                         blue = 0.0
 476                         on GLUT_KEY_F3
 477                                         red = 0.0
 478                                         green = 0.0
 479                                         blue = 1.0
 480                 off
 481
 482 スクリーンショット:
 483
 484 .. image:: freeglutshot5.png
 485         :alt: RingFreeGLUT
 486
 487
 488
 489 .. index::
 490         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); カメラ
 491
 492 カメラ
 493 ======
 494
 495 用例:
 496
 497 .. code-block:: ring
 498
 499         load "freeglut.ring"
 500         load "opengl21lib.ring"
 501
 502         // カメラ方向の回転角度
 503         angle=0.0
 504         // 実際のベクトルはカメラ方向を表しています。
 505         lx=0.0
 506         lz=-1.0
 507         // カメラの XZ 位置
 508         x=0.0
 509         z=5.0
 510
 511         func drawSnowMan
 512
 513                 glColor3f(1.0, 1.0, 1.0)
 514
 515         // 体の描画
 516                 glTranslatef(0.0 ,0.75, 0.0)
 517                 glutSolidSphere(0.75,20,20)
 518
 519         // 頭の描画
 520                 glTranslatef(0.0, 1.0, 0.0)
 521                 glutSolidSphere(0.25,20,20)
 522
 523         // 目の描画
 524                 glPushMatrix()
 525                 glColor3f(0.0,0.0,0.0)
 526                 glTranslatef(0.05, 0.10, 0.18)
 527                 glutSolidSphere(0.05,10,10)
 528                 glTranslatef(-0.1, 0.0, 0.0)
 529                 glutSolidSphere(0.05,10,10)
 530
 531                 glPopMatrix()
 532
 533         // 鼻の描画
 534                 glColor3f(1.0, 0.5 , 0.5)
 535                 glutSolidCone(0.08,0.5,10,2)
 536
 537
 538         func changeSize
 539                 w = glutEventWidth()
 540                 h = glutEventHeight()
 541
 542                 // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
 543                 // (幅 0 のウィンドウは作成できません)
 544                 if h = 0
 545                         h = 1
 546                 ok
 547
 548                 ratio =  w * 1.0  / h
 549
 550                         // 投射行列の使用
 551                 glMatrixMode(GL_PROJECTION)
 552
 553                         // 行列のリセット
 554                 glLoadIdentity()
 555
 556
 557                 // ウィンドウ全体のビューポートを設定します。
 558                 glViewport(0, 0, w, h)
 559
 560                  // 正しい遠近法の設定
 561                 gluPerspective(45.0, ratio, 0.1, 100.0);
 562
 563                 // Modelview の復帰
 564                 glMatrixMode(GL_MODELVIEW)
 565
 566
 567         func processNormalKeys
 568                 key = glutEventKey()
 569
 570                 if key = 27
 571                         shutdown()
 572                 ok
 573
 574
 575
 576         func renderScene
 577
 578                 // 配色と深度バッファの消去
 579
 580                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 581
 582                 // 変換のリセット
 583                 glLoadIdentity()
 584                 // カメラの設定
 585                 gluLookAt(      x, 1.0, z,
 586                                 x+lx, 1.0,  z+lz,
 587                                 0.0, 1.0,  0.0)
 588
 589                         // 地面の描画
 590
 591                 glColor3f(0.9, 0.9, 0.9)
 592                 glBegin(GL_QUADS)
 593                         glVertex3f(-100.0, 0.0, -100.0)
 594                         glVertex3f(-100.0, 0.0,  100.0)
 595                         glVertex3f( 100.0, 0.0,  100.0)
 596                         glVertex3f( 100.0, 0.0, -100.0)
 597                 glEnd()
 598
 599                         // 36 体の雪だるまを描画
 600                 for i = -3 to 2
 601                         for  j=-3 to 2
 602                                 glPushMatrix()
 603                                 glTranslatef(i*10.0,0,j * 10.0)
 604                                 drawSnowMan()
 605                                 glPopMatrix()
 606                         next
 607                 next
 608                 glutSwapBuffers()
 609
 610
 611
 612
 613         func processSpecialKeys
 614
 615                 key = glutEventKey()
 616
 617                 fraction = 0.1
 618
 619                 switch key
 620                         on GLUT_KEY_LEFT
 621                                 angle -= 0.01
 622                                 lx = sin(angle)
 623                                 lz = -cos(angle)
 624                         on GLUT_KEY_RIGHT
 625                                 angle += 0.01
 626                                 lx = sin(angle)
 627                                 lz = -cos(angle)
 628                         on GLUT_KEY_UP
 629                                 x += lx * fraction
 630                                 z += lz * fraction
 631                         on GLUT_KEY_DOWN
 632                                 x -= lx * fraction
 633                                 z -= lz * fraction
 634                 off
 635
 636
 637         func main
 638
 639                 // GLUT の初期化とウィンドウの作成
 640
 641                 glutInit()
 642                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
 643
 644                 glutInitWindowPosition(100,100)
 645                 glutInitWindowSize(320,320)
 646                 glutCreateWindow("RingFreeGLUT - Test 7")
 647
 648                 // コールバックの登録
 649                 glutDisplayFunc(:renderScene)
 650                 glutReshapeFunc(:changeSize)
 651                 glutIdleFunc(:renderScene)
 652                 glutKeyboardFunc(:processNormalKeys)
 653                 glutSpecialFunc(:processSpecialKeys)
 654
 655                 // OpenGL の初期化
 656                 glEnable(GL_DEPTH_TEST)
 657
 658                 // GLUT のイベント処理サイクルへ入ります。
 659                 glutMainLoop()
 660
 661 スクリーンショット:
 662
 663 .. image:: freeglutshot6.png
 664         :alt: RingFreeGLUT
 665
 666 その他の用例:
 667
 668 .. code-block:: ring
 669
 670         load "freeglut.ring"
 671         load "opengl21lib.ring"
 672
 673         // カメラ方向の回転角度
 674         angle = 0.0
 675
 676         // 実際のベクトルはカメラ方向を表しています。
 677         lx=0.0 lz=-1.0
 678
 679         // カメラの XZ 位置
 680         x=0.0 z=5.0
 681         // キーの状態
 682         // キーを押していない時は変数は 0 です。
 683         deltaAngle = 0.0
 684         deltaMove = 0
 685
 686         func changeSize
 687                 w = glutEventWidth()
 688                 h = glutEventHeight()
 689
 690                 // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
 691                 // (幅 0 のウィンドウは作成できません)
 692                 if h = 0
 693                         h = 1
 694                 ok
 695
 696                 ratio =  w * 1.0 / h
 697
 698                 // 投射行列の使用
 699                 glMatrixMode(GL_PROJECTION)
 700
 701                 // 行列のリセット
 702                 glLoadIdentity()
 703
 704                 // ウィンドウ全体のビューポートを設定します。
 705                 glViewport(0, 0, w, h)
 706
 707                  // 正しい遠近法の設定
 708                 gluPerspective(45.0, ratio, 0.1, 100.0)
 709
 710                 // Modelview の復帰
 711                 glMatrixMode(GL_MODELVIEW)
 712
 713
 714         func drawSnowMan
 715
 716                 glColor3f(1.0, 1.0, 1.0)
 717
 718         // 体の描画
 719
 720                 glTranslatef(0.0 ,0.75, 0.0)
 721                 glutSolidSphere(0.75,20,20)
 722
 723         // 頭の描画
 724                 glTranslatef(0.0, 1.0, 0.0)
 725                 glutSolidSphere(0.25,20,20)
 726
 727         // 目の描画
 728                 glPushMatrix()
 729                 glColor3f(0.0,0.0,0.0)
 730                 glTranslatef(0.05, 0.10, 0.18)
 731                 glutSolidSphere(0.05,10,10)
 732                 glTranslatef(-0.1, 0.0, 0.0)
 733                 glutSolidSphere(0.05,10,10)
 734                 glPopMatrix()
 735
 736         // 鼻の描画
 737                 glColor3f(1.0, 0.5 , 0.5)
 738                 glRotatef(0.0,1.0, 0.0, 0.0)
 739                 glutSolidCone(0.08,0.5,10,2)
 740
 741
 742         func computePos deltaMove
 743
 744                 x += deltaMove * lx * 0.1
 745                 z += deltaMove * lz * 0.1
 746
 747
 748         func computeDir deltaAngle
 749
 750                 angle += deltaAngle
 751                 lx = sin(angle)
 752                 lz = -cos(angle)
 753
 754         func renderScene
 755
 756                 if deltaMove
 757                         computePos(deltaMove)
 758                 ok
 759
 760                 if deltaAngle
 761                         computeDir(deltaAngle)
 762                 ok
 763
 764                 // 配色と深度バッファの消去
 765                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 766
 767                 // 変換のリセット
 768                 glLoadIdentity()
 769                 // カメラの設定
 770                 gluLookAt(      x, 1.0, z,
 771                                         x+lx, 1.0,  z+lz,
 772                                         0.0, 1.0,  0.0)
 773
 774         // 地面の描画
 775
 776                 glColor3f(0.9, 0.9, 0.9)
 777                 glBegin(GL_QUADS)
 778                         glVertex3f(-100.0, 0.0, -100.0)
 779                         glVertex3f(-100.0, 0.0,  100.0)
 780                         glVertex3f( 100.0, 0.0,  100.0)
 781                         glVertex3f( 100.0, 0.0, -100.0)
 782                 glEnd()
 783
 784         // 36 体の雪だるまを描画
 785
 786                 for i = -3 to 2
 787                         for j=-3 to 2
 788                                 glPushMatrix()
 789                                 glTranslatef(i*10.0,0,j * 10.0)
 790                                 drawSnowMan()
 791                                 glPopMatrix()
 792                         next
 793                 next
 794                 glutSwapBuffers()
 795
 796
 797         func pressKey
 798                 key = glutEventKey()
 799                 xx = glutEventX()
 800                 yy = glutEventY()
 801
 802                 switch key
 803                         on GLUT_KEY_LEFT
 804                                  deltaAngle = -0.01
 805                         on GLUT_KEY_RIGHT
 806                                  deltaAngle = 0.01
 807                         on GLUT_KEY_UP
 808                                  deltaMove = 0.5
 809                         on GLUT_KEY_DOWN
 810                                 deltaMove = -0.5
 811                 off
 812
 813         func releaseKey
 814
 815                 key = glutEventKey()
 816
 817                 switch key
 818                         on GLUT_KEY_LEFT
 819                                 deltaAngle = 0.0
 820                         on GLUT_KEY_RIGHT
 821                                 deltaAngle = 0.0
 822                         on GLUT_KEY_UP
 823                                 deltaMove = 0
 824                         on GLUT_KEY_DOWN
 825                                 deltaMove = 0
 826                 off
 827
 828         func main
 829
 830                 // GLUT の初期化とウィンドウの作成
 831                 glutInit()
 832                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
 833                 glutInitWindowPosition(100,100)
 834                 glutInitWindowSize(320,320)
 835                 glutCreateWindow("RingFreeGLUT - Test 8")
 836
 837                 // コールバックの登録
 838                 glutDisplayFunc(:renderScene)
 839                 glutReshapeFunc(:changeSize)
 840                 glutIdleFunc(:renderScene)
 841
 842                 glutSpecialFunc(:pressKey)
 843
 844                 // これは新しいエントリーです。
 845                 glutIgnoreKeyRepeat(1)
 846                 glutSpecialUpFunc(:releaseKey)
 847
 848                 // OpenGL の初期化
 849                 glEnable(GL_DEPTH_TEST)
 850
 851                 // GLUT のイベント処理サイクルへ入ります。
 852                 glutMainLoop()
 853
 854
 855 .. index::
 856         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); マウスイベント
 857
 858 マウスイベント
 859 ==============
 860
 861 用例:
 862
 863 .. code-block:: ring
 864
 865         load "freeglut.ring"
 866         load "opengl21lib.ring"
 867
 868         // カメラ方向の回転角度
 869         angle = 0.0
 870
 871         // 実際のベクトルはカメラ方向を表しています。
 872         lx=0.0 lz=-1.0
 873
 874         // カメラの XZ 位置
 875         x=0.0  z=5.0
 876
 877         // キーの状態
 878         // キーを押していない時は変数は 0 です。
 879         deltaAngle = 0.0
 880         deltaMove = 0.0
 881         xOrigin = -1
 882
 883         func changeSize
 884                 w = glutEventWidth()
 885                 h = glutEventHeight()
 886
 887                 // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
 888                 // (幅 0 のウィンドウは作成できません)
 889                 if h = 0
 890                         h = 1
 891                 ok
 892
 893                 ratio =  w * 1.0 / h
 894
 895                 // 投射行列の使用
 896                 glMatrixMode(GL_PROJECTION)
 897
 898                 // 行列のリセット
 899                 glLoadIdentity()
 900
 901                 // ウィンドウ全体のビューポートを設定します。
 902                 glViewport(0, 0, w, h)
 903
 904                  // 正しい遠近法の設定
 905                 gluPerspective(45.0, ratio, 0.1, 100.0)
 906
 907                 // Modelview の復帰
 908                 glMatrixMode(GL_MODELVIEW)
 909
 910
 911         func drawSnowMan
 912
 913                 glColor3f(1.0, 1.0, 1.0)
 914
 915                 // 体の描画
 916                 glTranslatef(0.0 ,0.75, 0.0)
 917                 glutSolidSphere(0.75,20,20)
 918
 919                 // 頭の描画
 920                 glTranslatef(0.0, 1.0, 0.0)
 921                 glutSolidSphere(0.25,20,20)
 922
 923                 // 目の描画
 924                 glPushMatrix()
 925                 glColor3f(0.0,0.0,0.0)
 926                 glTranslatef(0.05, 0.10, 0.18)
 927                 glutSolidSphere(0.05,10,10)
 928                 glTranslatef(-0.1, 0.0, 0.0)
 929                 glutSolidSphere(0.05,10,10)
 930                 glPopMatrix()
 931
 932                 // 鼻の描画
 933                 glColor3f(1.0, 0.5 , 0.5)
 934                 glRotatef(0.0,1.0, 0.0, 0.0)
 935                 glutSolidCone(0.08,0.5,10,2)
 936
 937
 938         func computePos deltaMove
 939
 940                 x += deltaMove * lx * 0.1
 941                 z += deltaMove * lz * 0.1
 942
 943         func renderScene
 944
 945                 if deltaMove
 946                         computePos(deltaMove)
 947                 ok
 948
 949                 // 配色と深度バッファの消去
 950                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 951
 952                 // 変換のリセット
 953                 glLoadIdentity()
 954                 // カメラの設定
 955                 gluLookAt(      x, 1.0, z,
 956                                 x+lx, 1.0,  z+lz,
 957                                 0.0, 1.0,  0.0)
 958
 959                 // 地面の描画
 960
 961                 glColor3f(0.9, 0.9, 0.9)
 962                 glBegin(GL_QUADS)
 963                         glVertex3f(-100.0, 0.0, -100.0)
 964                         glVertex3f(-100.0, 0.0,  100.0)
 965                         glVertex3f( 100.0, 0.0,  100.0)
 966                         glVertex3f( 100.0, 0.0, -100.0)
 967                 glEnd()
 968
 969                 // 36 体の雪だるまを描画
 970
 971                 for i = -3 to 2
 972                         for  j=-3 to 2
 973                                                  glPushMatrix()
 974                                                  glTranslatef(i*10.0,0,j * 10.0)
 975                                                  drawSnowMan()
 976                                                  glPopMatrix()
 977                          next
 978                 next
 979                 glutSwapBuffers()
 980
 981         func processNormalKeys
 982
 983                 key  = glutEventKey()
 984
 985                         if key = 27
 986                                  shutdown()
 987                         ok
 988
 989
 990         func pressKey
 991                 key  = glutEventKey()
 992
 993                    switch key
 994                                  on GLUT_KEY_UP
 995                                         deltaMove = 0.5
 996                                  on GLUT_KEY_DOWN
 997                                          deltaMove = -0.5
 998                    off
 999
1000
1001         func releaseKey
1002                 key  = glutEventKey()
1003                         switch key
1004                                  on GLUT_KEY_UP
1005                                         deltaMove = 0
1006                                  on GLUT_KEY_DOWN
1007                                         deltaMove = 0
1008                         off
1009
1010
1011         func mouseMove
1012                 xx = glutEventX()
1013                 yy = glutEventY()
1014                         // これは左ボタンを押したときのみ true になります。
1015                         if xOrigin >= 0
1016
1017                         // deltaAngle の更新
1018                         deltaAngle = (xx - xOrigin) * 0.001
1019
1020                         // カメラ方向の更新
1021                         lx = sin(angle + deltaAngle)
1022                         lz = -cos(angle + deltaAngle)
1023                 ok
1024
1025
1026
1027         func mouseButton
1028
1029                 button  = glutEventButton()
1030                 state = glutEventState()
1031                 xx = glutEventX()
1032                 yy = glutEventY()
1033
1034                 // これは左ボタンを押したときのみ動作開始になります。
1035                 if button = GLUT_LEFT_BUTTON
1036                         // ボタンを離したとき
1037                         if state = GLUT_UP
1038                                 angle += deltaAngle
1039                                 xOrigin = -1
1040                         else
1041                                 // state = GLUT_DOWN
1042                                 xOrigin = xx
1043                         ok
1044                         fflush(stdout)
1045                 ok
1046
1047
1048         func main
1049
1050                 // GLUT の初期化とウィンドウの作成
1051                 glutInit()
1052                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
1053                 glutInitWindowPosition(100,100)
1054                 glutInitWindowSize(320,320)
1055                 glutCreateWindow("RingFreeGLUT - Test 9")
1056
1057                 // コールバックの登録
1058                 glutDisplayFunc(:renderScene)
1059                 glutReshapeFunc(:changeSize)
1060                 glutIdleFunc(:renderScene)
1061
1062                 glutIgnoreKeyRepeat(1)
1063                 glutKeyboardFunc(:processNormalKeys)
1064                 glutSpecialFunc(:pressKey)
1065                 glutSpecialUpFunc(:releaseKey)
1066
1067                  // ここには二つの新しい関数があります。
1068                 glutMouseFunc(:mouseButton)
1069                 glutMotionFunc(:mouseMove)
1070
1071                 // OpenGL の初期化
1072                 glEnable(GL_DEPTH_TEST)
1073
1074                 // GLUT のイベント処理サイクルへ入ります。
1075                 glutMainLoop()
1076
1077
1078 .. index::
1079         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); メニューイベント
1080
1081 メニューイベント
1082 ================
1083
1084 用例:
1085
1086 .. code-block:: ring
1087
1088
1089         load "freeglut.ring"
1090         load "opengl21lib.ring"
1091
1092         // カメラ方向の回転角度
1093         angle = 0.0
1094
1095         // 実際のベクトルはカメラ方向を表しています。
1096         lx=0.0 lz=-1.0
1097
1098         // カメラの XZ 位置
1099         x=0.0  z=5.0
1100
1101         // キーの状態
1102         // キーを押していない時は変数は 0 です。
1103         deltaAngle = 0.0
1104         deltaMove = 0
1105         xOrigin = -1
1106
1107         // メニューを定義するための定数
1108
1109
1110         // RingFreeGLUT では - メニューの項目ごとに異なる ID を指定してください。
1111         C_RED = 1
1112         C_GREEN = 2
1113         C_BLUE  = 3
1114         C_ORANGE = 4
1115
1116         C_FILL = 5
1117         C_LINE = 6
1118
1119         C_SHRINK = 7
1120         C_NORMAL = 8
1121
1122         // ポップアップメニューの定義
1123         fillMenu= 0
1124         shrinkMenu= 0
1125         mainMenu=0
1126         colorMenu=0
1127
1128         // 鼻の配色
1129         red = 1.0  blue=0.5  green=0.5
1130
1131         // 雪だるまの大きさ
1132         scale = 1.0
1133
1134         // メニューの状態
1135         menuFlag = 0
1136
1137         func changeSize
1138                 w = glutEventWidth()
1139                 h = glutEventHeight()
1140
1141                 // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
1142                 // (幅 0 のウィンドウは作成できません)
1143                 if h = 0
1144                         h = 1
1145                 ok
1146
1147                 ratio =  w * 1.0 / h
1148
1149                 // 投射行列の使用
1150                 glMatrixMode(GL_PROJECTION)
1151
1152                 // 行列のリセット
1153                 glLoadIdentity()
1154
1155                 // ウィンドウ全体のビューポートを設定します。
1156                 glViewport(0, 0, w, h)
1157
1158                  // 正しい遠近法の設定
1159                 gluPerspective(45.0, ratio, 0.1, 100.0)
1160
1161                 // Modelview の復帰
1162                 glMatrixMode(GL_MODELVIEW)
1163
1164         func drawSnowMan
1165
1166                 glScalef(scale, scale, scale)
1167                 glColor3f(1.0, 1.0, 1.0)
1168
1169         // 体の描画
1170                 glTranslatef(0.0 ,0.75, 0.0)
1171                 glutSolidSphere(0.75,20,20)
1172
1173         // 頭の描画
1174                 glTranslatef(0.0, 1.0, 0.0)
1175                 glutSolidSphere(0.25,20,20)
1176
1177         // 目の描画
1178                 glPushMatrix()
1179                 glColor3f(0.0,0.0,0.0)
1180                 glTranslatef(0.05, 0.10, 0.18)
1181                 glutSolidSphere(0.05,10,10)
1182                 glTranslatef(-0.1, 0.0, 0.0)
1183                 glutSolidSphere(0.05,10,10)
1184                 glPopMatrix()
1185
1186         // 鼻の描画
1187                 glColor3f(red, green, blue)
1188                 glRotatef(0.0,1.0, 0.0, 0.0)
1189                 glutSolidCone(0.08,0.5,10,2)
1190
1191                 glColor3f(1.0, 1.0, 1.0)
1192
1193
1194         func computePos deltaMove
1195
1196                 x += deltaMove * lx * 0.1
1197                 z += deltaMove * lz * 0.1
1198
1199
1200         func renderScene
1201
1202                 if deltaMove
1203                         computePos(deltaMove)
1204                 ok
1205
1206                 // 配色と深度バッファの消去
1207                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
1208
1209                 // 変換のリセット
1210                 glLoadIdentity()
1211                 // カメラの設定
1212                 gluLookAt(      x, 1.0, z,
1213                                 x+lx, 1.0,  z+lz,
1214                                 0.0, 1.0,  0.0)
1215
1216         // 地面の描画
1217
1218                 glColor3f(0.9, 0.9, 0.9)
1219                 glBegin(GL_QUADS)
1220                         glVertex3f(-100.0, 0.0, -100.0)
1221                         glVertex3f(-100.0, 0.0,  100.0)
1222                         glVertex3f( 100.0, 0.0,  100.0)
1223                         glVertex3f( 100.0, 0.0, -100.0)
1224                 glEnd()
1225
1226         // 36 体の雪だるまを描画
1227
1228                 for  i = -3 to 2
1229                         for  j = -3 to 2
1230                                 glPushMatrix()
1231                                 glTranslatef(i*10.0, 0.0, j * 10.0)
1232                                 drawSnowMan()
1233                                 glPopMatrix()
1234                         next
1235                 next
1236                 glutSwapBuffers()
1237
1238
1239         // -----------------------------------
1240         //             キーボード
1241         // -----------------------------------
1242
1243         func processNormalKeys
1244                 key = glutEventKey()
1245                 xx = glutEventX()
1246                 yy = glutEventY()
1247
1248                 glutSetMenu(mainMenu)
1249                 switch key
1250                         on 27
1251                                 glutDestroyMenu(mainMenu)
1252                                 glutDestroyMenu(fillMenu)
1253                                 glutDestroyMenu(colorMenu)
1254                                 glutDestroyMenu(shrinkMenu)
1255                                 shutdown()
1256
1257                         on 's'
1258                                 if not menuFlag
1259                                   glutChangeToSubMenu(2,"Shrink",shrinkMenu)
1260                                 ok
1261                         on 'c'
1262                                 if not menuFlag
1263                                         glutChangeToSubMenu(2,"Color",colorMenu)
1264                                 ok
1265                 off
1266                 if key = 27
1267                         shutdown()
1268                 ok
1269
1270
1271         func pressKey
1272
1273                 key = glutEventKey()
1274                 xx = glutEventX()
1275                 yy = glutEventY()
1276
1277                 switch key
1278                         on GLUT_KEY_UP
1279                                  deltaMove = 0.5
1280                         on GLUT_KEY_DOWN
1281                                 deltaMove = -0.5
1282                 off
1283
1284
1285         func releaseKey
1286
1287                 key = glutEventKey()
1288
1289                 switch key
1290                         on GLUT_KEY_UP
1291                                 deltaMove = 0
1292                         on GLUT_KEY_DOWN
1293                                 deltaMove = 0
1294                 off
1295
1296
1297         // -----------------------------------
1298         //             マウス
1299         // -----------------------------------
1300
1301         func mouseMove
1302                 xx = glutEventX()
1303                 yy = glutEventY()
1304
1305                 // これは左ボタンを押したときのみ true になります。
1306                 if xOrigin >= 0
1307
1308                         // deltaAngle の更新
1309                         deltaAngle = (xx - xOrigin) * 0.001
1310
1311                         // カメラ方向の更新
1312                         lx = sin(angle + deltaAngle)
1313                         lz = -cos(angle + deltaAngle)
1314                 ok
1315
1316
1317         func mouseButton
1318
1319                 button = glutEventButton()
1320                 state = glutEventState()
1321                 xx = glutEventX()
1322                 yy = glutEventY()
1323
1324                 // これは左ボタンを押したときのみ動作開始になります。
1325                 if button = GLUT_LEFT_BUTTON
1326                         // ボタンを離したとき
1327                         if state = GLUT_UP
1328                                 angle += deltaAngle
1329                                 xOrigin = -1
1330                         else
1331                                 // state = GLUT_DOWN
1332                                 xOrigin = xx
1333                         ok
1334                 ok
1335
1336
1337         // -----------------------------------
1338         //             メニュー
1339         // -----------------------------------
1340
1341         func processMenuStatus
1342
1343                 status = glutEventStatus()
1344                 xx = glutEventX()
1345                 yy = glutEventY()
1346
1347                 if  status = GLUT_MENU_IN_USE
1348                         menuFlag = 1
1349                 else
1350                         menuFlag = 0
1351                 ok
1352
1353
1354         func processMainMenu
1355
1356                 // ここにはなにもありません。
1357                 // 動作は全てサブメニューから行います。
1358
1359
1360         func processFillMenu
1361
1362                 option = glutEventValue()
1363
1364                 switch option
1365
1366                         on C_FILL
1367                                  glPolygonMode(GL_FRONT, GL_FILL)
1368                         on C_LINE
1369                                  glPolygonMode(GL_FRONT, GL_LINE)
1370                 off
1371
1372
1373         func processShrinkMenu
1374
1375                 option = glutEventValue()
1376
1377                 switch option
1378
1379                         on C_SHRINK
1380                                 scale = 0.5
1381                         on C_NORMAL
1382                                  scale = 1.0
1383                 off
1384
1385
1386         func processColorMenu
1387
1388                 option = glutEventValue()
1389
1390                 switch option
1391                         on C_RED
1392                                 red = 1.0
1393                                 green = 0.0
1394                                 blue = 0.0
1395                         on C_GREEN
1396                                 red = 0.0
1397                                 green = 1.0
1398                                 blue = 0.0
1399                         on C_BLUE
1400                                 red = 0.0
1401                                 green = 0.0
1402                                 blue = 1.0
1403                         on C_ORANGE
1404                                 red = 1.0
1405                                 green = 0.5
1406                                 blue = 0.5
1407                 off
1408
1409
1410         func createPopupMenus
1411
1412                 shrinkMenu = glutCreateMenu(:processShrinkMenu)
1413
1414                 glutAddMenuEntry("Shrink",C_SHRINK)
1415                 glutAddMenuEntry("NORMAL",C_NORMAL)
1416
1417                 fillMenu = glutCreateMenu(:processFillMenu)
1418
1419                 glutAddMenuEntry("Fill",C_FILL)
1420                 glutAddMenuEntry("Line",C_LINE)
1421
1422                 colorMenu = glutCreateMenu(:processColorMenu)
1423                 glutAddMenuEntry("Red",C_RED)
1424                 glutAddMenuEntry("Blue",C_BLUE)
1425                 glutAddMenuEntry("Green",C_GREEN)
1426                 glutAddMenuEntry("Orange",C_ORANGE)
1427
1428                 mainMenu = glutCreateMenu(:processMainMenu)
1429
1430                 glutAddSubMenu("Polygon Mode", fillMenu)
1431                 glutAddSubMenu("Color", colorMenu)
1432                  // 右ボタンでメニューへ接続
1433                 glutAttachMenu(GLUT_RIGHT_BUTTON)
1434
1435                 // これでアクティブなメニューであるかどうか検知できるようにします。
1436                 glutMenuStatusFunc(:processMenuStatus)
1437
1438
1439         // -----------------------------------
1440         //             メイン
1441         // -----------------------------------
1442
1443         func main
1444
1445                 // GLUT の初期化とウィンドウの作成
1446                 glutInit()
1447                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
1448                 glutInitWindowPosition(100,100)
1449                 glutInitWindowSize(320,320)
1450                 glutCreateWindow("RingFreeGLUT - Test 10")
1451
1452                 // コールバックの登録
1453                 glutDisplayFunc(:renderScene)
1454                 glutReshapeFunc(:changeSize)
1455                 glutIdleFunc(:renderScene)
1456
1457                 glutIgnoreKeyRepeat(1)
1458                 glutKeyboardFunc(:processNormalKeys)
1459                 glutSpecialFunc(:pressKey)
1460                 glutSpecialUpFunc(:releaseKey)
1461
1462                  // ここには二つの新しい関数があります。
1463                 glutMouseFunc(:mouseButton)
1464                 glutMotionFunc(:mouseMove)
1465
1466                 // OpenGL の初期化
1467                 glEnable(GL_DEPTH_TEST)
1468                 glEnable(GL_CULL_FACE)
1469
1470                 // メニューの初期化
1471                 createPopupMenus()
1472
1473                 // GLUT のイベント処理サイクルへ入ります。
1474                 glutMainLoop()
1475
1476 スクリーンショット:
1477
1478 .. image:: freeglutshot7.png
1479         :alt: RingFreeGLUT
1480
1481
1482 .. index::
1483         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); フォントの用法
1484
1485 フォントの用法
1486 ==============
1487
1488 用例:
1489
1490 .. code-block:: ring
1491
1492         load "freeglut.ring"
1493         load "opengl21lib.ring"
1494
1495
1496         // カメラ方向の回転角度
1497         angle = 0.0
1498
1499         // 実際のベクトルはカメラ方向を表しています。
1500         lx=0.0 lz=-1.0
1501
1502         // カメラの XZ 位置
1503         x=0.0  z=5.0
1504
1505         // キーの状態
1506         // キーを押していない時は変数は 0 です。
1507         deltaAngle = 0.0
1508         deltaMove = 0
1509         xOrigin = -1
1510
1511         // メニューを定義するための定数
1512         C_RED  = 1
1513         C_GREEN = 2
1514         C_BLUE = 3
1515         C_ORANGE = 4
1516
1517         C_FILL = 5
1518         C_LINE = 6
1519
1520         // ポップアップメニューの定義
1521         fillMenu=NULL
1522         fontMenu=NULL
1523         mainMenu=NULL
1524         colorMenu=NULL
1525
1526         // 鼻の配色
1527         red = 1.0
1528         blue=0.5
1529         green=0.5
1530
1531         // 雪だるまの大きさ
1532         scale = 1.0
1533
1534         // メニューの状態
1535         menuFlag = 0
1536
1537         // デフォルトのフォント
1538         font = GLUT_BITMAP_TIMES_ROMAN_24
1539
1540         C_INT_GLUT_BITMAP_8_BY_13 = 7
1541         C_INT_GLUT_BITMAP_9_BY_15 = 8
1542         C_INT_GLUT_BITMAP_TIMES_ROMAN_10  = 9
1543         C_INT_GLUT_BITMAP_TIMES_ROMAN_24  = 10
1544         C_INT_GLUT_BITMAP_HELVETICA_10  = 11
1545         C_INT_GLUT_BITMAP_HELVETICA_12  = 12
1546         C_INT_GLUT_BITMAP_HELVETICA_18  = 13
1547
1548         func changeSize
1549                 w = glutEventWidth()
1550                 h = glutEventHeight()
1551
1552                 // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
1553                 // (幅 0 のウィンドウは作成できません)
1554                 if h = 0
1555                         h = 1
1556                 ok
1557
1558                 ratio =  w * 1.0 / h
1559
1560                 // 投射行列の使用
1561                 glMatrixMode(GL_PROJECTION)
1562
1563                 // 行列のリセット
1564                 glLoadIdentity()
1565
1566                 // ウィンドウ全体のビューポートを設定します。
1567                 glViewport(0, 0, w, h)
1568
1569                  // 正しい遠近法の設定
1570                 gluPerspective(45.0, ratio, 0.1, 100.0)
1571
1572                 // Modelview の復帰
1573                 glMatrixMode(GL_MODELVIEW)
1574
1575         func drawSnowMan
1576
1577                 glScalef(scale, scale, scale)
1578                 glColor3f(1.0, 1.0, 1.0)
1579
1580         // 体の描画
1581                 glTranslatef(0.0 ,0.75, 0.0)
1582                 glutSolidSphere(0.75,20,20)
1583
1584         // 頭の描画
1585                 glTranslatef(0.0, 1.0, 0.0)
1586                 glutSolidSphere(0.25,20,20)
1587
1588         // 目の描画
1589                 glPushMatrix()
1590                 glColor3f(0.0,0.0,0.0)
1591                 glTranslatef(0.05, 0.10, 0.18)
1592                 glutSolidSphere(0.05,10,10)
1593                 glTranslatef(-0.1, 0.0, 0.0)
1594                 glutSolidSphere(0.05,10,10)
1595                 glPopMatrix()
1596
1597         // 鼻の描画
1598                 glColor3f(red, green, blue)
1599                 glRotatef(0.0,1.0, 0.0, 0.0)
1600                 glutSolidCone(0.08,0.5,10,2)
1601
1602                 glColor3f(1.0, 1.0, 1.0)
1603
1604         func renderBitmapString x,y,z,font,string
1605                 glRasterPos3f(x, y,z)
1606                 for c in string
1607                         glutBitmapCharacter(font,ascii(c))
1608                 next
1609
1610
1611         func computePos deltaMove
1612
1613                 x += deltaMove * lx * 0.1
1614                 z += deltaMove * lz * 0.1
1615
1616
1617         func renderScene
1618
1619                 if  deltaMove
1620                         computePos(deltaMove)
1621                 ok
1622
1623                 // 配色と深度バッファの消去
1624                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
1625
1626                 // 変換のリセット
1627                 glLoadIdentity()
1628
1629                 // カメラの設定
1630                 gluLookAt(      x, 1.0, z,
1631                                 x+lx, 1.0,  z+lz,
1632                                 0.0, 1.0,  0.0)
1633
1634                 // 地面の描画
1635
1636                 glColor3f(0.9, 0.9, 0.9)
1637                 glBegin(GL_QUADS)
1638                         glVertex3f(-100.0, 0.0, -100.0)
1639                         glVertex3f(-100.0, 0.0,  100.0)
1640                         glVertex3f( 100.0, 0.0,  100.0)
1641                         glVertex3f( 100.0, 0.0, -100.0)
1642                 glEnd()
1643
1644         // 36 体の雪だるまを描画
1645                 for i = -3 to 2
1646                         for j = -3 to 2
1647                                 glPushMatrix()
1648                                 glTranslatef(i*10.0, 0.0, j * 10.0)
1649                                 drawSnowMan()
1650                                 number = (i+3)*6+(j+3)
1651                                 renderBitmapString(0.0, 0.5, 0.0,font ,""+number)
1652                                 glPopMatrix()
1653                         next
1654                 next
1655
1656                 glutSwapBuffers()
1657
1658
1659         // -----------------------------------
1660         //             キーボード
1661         // -----------------------------------
1662
1663         func processNormalKeys
1664                 key = glutEventKey()
1665                 xx = glutEventX()
1666                 yy = glutEventY()
1667
1668                 switch key
1669                         on 27
1670                                 glutDestroyMenu(mainMenu)
1671                                 glutDestroyMenu(fillMenu)
1672                                 glutDestroyMenu(colorMenu)
1673                                 glutDestroyMenu(fontMenu)
1674                                 Shutdown()
1675                 off
1676
1677
1678         func pressKey
1679
1680                 key = glutEventKey()
1681                 xx = glutEventX()
1682                 yy = glutEventY()
1683
1684                 switch key
1685                         on GLUT_KEY_UP
1686                                  deltaMove = 0.5
1687                         on GLUT_KEY_DOWN
1688                                 deltaMove = -0.5
1689                 off
1690
1691
1692         func releaseKey
1693
1694                 key = glutEventKey()
1695
1696                 switch key
1697                         on GLUT_KEY_UP
1698                                 deltaMove = 0
1699                         on GLUT_KEY_DOWN
1700                                 deltaMove = 0
1701                 off
1702
1703
1704         // -----------------------------------
1705         //             マウス
1706         // -----------------------------------
1707
1708         func mouseMove
1709                 xx = glutEventX()
1710                 yy = glutEventY()
1711
1712                 // これは左ボタンを押したときのみ true になります。
1713                 if xOrigin >= 0
1714
1715                         // deltaAngle の更新
1716                         deltaAngle = (xx - xOrigin) * 0.001
1717
1718                         // カメラ方向の更新
1719                         lx = sin(angle + deltaAngle)
1720                         lz = -cos(angle + deltaAngle)
1721                 ok
1722
1723
1724         func mouseButton
1725
1726                 button = glutEventButton()
1727                 state = glutEventState()
1728                 xx = glutEventX()
1729                 yy = glutEventY()
1730
1731                 // これは左ボタンを押したときのみ動作開始になります。
1732                 if button = GLUT_LEFT_BUTTON
1733                         // ボタンを離したとき
1734                         if state = GLUT_UP
1735                                 angle += deltaAngle
1736                                 xOrigin = -1
1737                         else
1738                                 // state = GLUT_DOWN
1739                                 xOrigin = xx
1740                         ok
1741                 ok
1742
1743
1744         // -----------------------------------
1745         //             メニュー
1746         // -----------------------------------
1747
1748         func processMenuStatus
1749
1750                 status = glutEventStatus()
1751
1752                 if status = GLUT_MENU_IN_USE
1753                         menuFlag = 1
1754                 else
1755                         menuFlag = 0
1756                 ok
1757
1758
1759         func processMainMenu
1760
1761                 // ここにはなにもありません。
1762                 // 動作は全てサブメニューから行います。
1763
1764
1765         func processFillMenu
1766
1767                 option = glutEventValue()
1768
1769                 switch option
1770
1771                         on C_FILL
1772                                 glPolygonMode(GL_FRONT, GL_FILL)
1773                         on C_LINE
1774                                  glPolygonMode(GL_FRONT, GL_LINE)
1775                 off
1776
1777
1778         func processFontMenu
1779
1780                 option = glutEventValue()
1781
1782                 switch (option) {
1783                         on C_INT_GLUT_BITMAP_8_BY_13
1784                                 font = GLUT_BITMAP_8_BY_13
1785                         on C_INT_GLUT_BITMAP_9_BY_15
1786                                 font = GLUT_BITMAP_9_BY_15
1787                         on C_INT_GLUT_BITMAP_TIMES_ROMAN_10
1788                                 font = GLUT_BITMAP_TIMES_ROMAN_10
1789                         on C_INT_GLUT_BITMAP_TIMES_ROMAN_24
1790                                 font = GLUT_BITMAP_TIMES_ROMAN_24
1791                         on C_INT_GLUT_BITMAP_HELVETICA_10
1792                                 font = GLUT_BITMAP_HELVETICA_10
1793                         on C_INT_GLUT_BITMAP_HELVETICA_12
1794                                 font = GLUT_BITMAP_HELVETICA_12
1795                         on C_INT_GLUT_BITMAP_HELVETICA_18
1796                                 font = GLUT_BITMAP_HELVETICA_18
1797                 off
1798
1799         func processColorMenu
1800
1801                 option = glutEventValue()
1802
1803                 switch option
1804                         on C_RED
1805                                 red = 1.0
1806                                 green = 0.0
1807                                 blue = 0.0
1808                         on C_GREEN
1809                                 red = 0.0
1810                                 green = 1.0
1811                                 blue = 0.0
1812                         on C_BLUE
1813                                 red = 0.0
1814                                 green = 0.0
1815                                 blue = 1.0
1816                         on C_ORANGE
1817                                 red = 1.0
1818                                 green = 0.5
1819                                 blue = 0.5
1820                 off
1821
1822
1823         func createPopupMenus
1824
1825                 fontMenu = glutCreateMenu(:processFontMenu)
1826
1827                 glutAddMenuEntry("BITMAP_8_BY_13 ",C_INT_GLUT_BITMAP_8_BY_13 )
1828                 glutAddMenuEntry("BITMAP_9_BY_15",C_INT_GLUT_BITMAP_9_BY_15 )
1829                 glutAddMenuEntry("BITMAP_TIMES_ROMAN_10 ",C_INT_GLUT_BITMAP_TIMES_ROMAN_10  )
1830                 glutAddMenuEntry("BITMAP_TIMES_ROMAN_24",C_INT_GLUT_BITMAP_TIMES_ROMAN_24  )
1831                 glutAddMenuEntry("BITMAP_HELVETICA_10 ",C_INT_GLUT_BITMAP_HELVETICA_10  )
1832                 glutAddMenuEntry("BITMAP_HELVETICA_12",C_INT_GLUT_BITMAP_HELVETICA_12  )
1833                 glutAddMenuEntry("BITMAP_HELVETICA_18",C_INT_GLUT_BITMAP_HELVETICA_18  )
1834
1835                 fillMenu = glutCreateMenu(:processFillMenu)
1836
1837                 glutAddMenuEntry("Fill",C_FILL)
1838                 glutAddMenuEntry("Line",C_LINE)
1839
1840                 colorMenu = glutCreateMenu(:processColorMenu)
1841                 glutAddMenuEntry("Red",C_RED);
1842                 glutAddMenuEntry("Blue",C_BLUE);
1843                 glutAddMenuEntry("Green",C_GREEN);
1844                 glutAddMenuEntry("Orange",C_ORANGE);
1845
1846                 mainMenu = glutCreateMenu(:processMainMenu)
1847
1848                 glutAddSubMenu("Polygon Mode", fillMenu)
1849                 glutAddSubMenu("Color", colorMenu)
1850                 glutAddSubMenu("Font",fontMenu)
1851                  // 右ボタンでメニューへ接続
1852                 glutAttachMenu(GLUT_RIGHT_BUTTON)
1853
1854                 // これでアクティブなメニューであるかどうか検知できるようにします。
1855                 glutMenuStatusFunc(:processMenuStatus)
1856
1857
1858         // -----------------------------------
1859         //             メイン
1860         // -----------------------------------
1861
1862         func main
1863
1864                 // GLUT の初期化とウィンドウの作成
1865                 glutInit()
1866                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
1867                 glutInitWindowPosition(100,100)
1868                 glutInitWindowSize(320,320)
1869                 glutCreateWindow("RingFreeGLUT - Test 11")
1870
1871                 // コールバックの登録
1872                 glutDisplayFunc(:renderScene)
1873                 glutReshapeFunc(:changeSize)
1874                 glutIdleFunc(:renderScene)
1875
1876                 glutIgnoreKeyRepeat(1)
1877                 glutKeyboardFunc(:processNormalKeys)
1878                 glutSpecialFunc(:pressKey)
1879                 glutSpecialUpFunc(:releaseKey)
1880
1881                  // ここには二つの新しい関数があります。
1882                 glutMouseFunc(:mouseButton)
1883                 glutMotionFunc(:mouseMove)
1884
1885                 // OpenGL の初期化
1886                 glEnable(GL_DEPTH_TEST)
1887                 glEnable(GL_CULL_FACE)
1888
1889                 // メニューの初期化
1890                 createPopupMenus()
1891
1892                 // GLUT のイベント処理サイクルへ入ります。
1893                 glutMainLoop()
1894
1895 スクリーンショット:
1896
1897 .. image:: freeglutshot8.png
1898         :alt: RingFreeGLUT
1899
1900
1901 .. index::
1902         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); 一秒あたりのフレーム数
1903
1904 一秒あたりのフレーム数
1905 ======================
1906
1907 用例:
1908
1909 .. code-block:: ring
1910
1911         load "freeglut.ring"
1912         load "opengl21lib.ring"
1913
1914         // カメラ方向の回転角度
1915         angle = 0.0
1916
1917         // 実際のベクトルはカメラ方向を表しています。
1918         lx=0.0 lz=-1.0
1919
1920         // カメラの XZ 位置
1921         x=0.0  z=5.0
1922
1923         // キーの状態
1924         // キーを押していない時は変数は 0 です。
1925         deltaAngle = 0.0
1926         deltaMove = 0
1927         xOrigin = -1
1928
1929         // メニューを定義するための定数
1930         C_RED  = 1
1931         C_GREEN = 2
1932         C_BLUE = 3
1933         C_ORANGE = 4
1934
1935         C_FILL = 5
1936         C_LINE = 6
1937
1938         // ポップアップメニューの定義
1939         fillMenu=NULL
1940         fontMenu=NULL
1941         mainMenu=NULL
1942         colorMenu=NULL
1943
1944         // 鼻の配色
1945         red = 1.0
1946         blue=0.5
1947         green=0.5
1948
1949         // 雪だるまの大きさ
1950         scale = 1.0
1951
1952         // メニューの状態
1953         menuFlag = 0
1954
1955         // デフォルトのフォント
1956         font = GLUT_BITMAP_TIMES_ROMAN_24
1957
1958         C_INT_GLUT_BITMAP_8_BY_13 = 7
1959         C_INT_GLUT_BITMAP_9_BY_15 = 8
1960         C_INT_GLUT_BITMAP_TIMES_ROMAN_10  = 9
1961         C_INT_GLUT_BITMAP_TIMES_ROMAN_24  = 10
1962         C_INT_GLUT_BITMAP_HELVETICA_10  = 11
1963         C_INT_GLUT_BITMAP_HELVETICA_12  = 12
1964         C_INT_GLUT_BITMAP_HELVETICA_18  = 13
1965
1966         // ウィンドウの幅と高さ
1967         h = 0
1968         w = 0
1969
1970         // 一秒あたりのフレーム数を計算するための変数
1971         frame=0
1972         time=0
1973         timebase=0
1974         s = ""
1975
1976         func changeSize
1977                 w = glutEventWidth()
1978                 h = glutEventHeight()
1979
1980                 // ウィンドウの大きさが小さすぎる場合に、ゼロ除算エラーになるのを防ぎます。
1981                 // (幅 0 のウィンドウは作成できません)
1982                 if h = 0
1983                         h = 1
1984                 ok
1985
1986                 ratio =  w * 1.0 / h
1987
1988                 // 投射行列の使用
1989                 glMatrixMode(GL_PROJECTION)
1990
1991                 // 行列のリセット
1992                 glLoadIdentity()
1993
1994                 // ウィンドウ全体のビューポートを設定します。
1995                 glViewport(0, 0, w, h)
1996
1997                  // 正しい遠近法の設定
1998                 gluPerspective(45.0, ratio, 0.1, 100.0)
1999
2000                 // Modelview の復帰
2001                 glMatrixMode(GL_MODELVIEW)
2002
2003         func drawSnowMan
2004
2005                 glScalef(scale, scale, scale)
2006                 glColor3f(1.0, 1.0, 1.0)
2007
2008         // 体の描画
2009                 glTranslatef(0.0 ,0.75, 0.0)
2010                 glutSolidSphere(0.75,20,20)
2011
2012         // 頭の描画
2013                 glTranslatef(0.0, 1.0, 0.0)
2014                 glutSolidSphere(0.25,20,20)
2015
2016         // 目の描画
2017                 glPushMatrix()
2018                 glColor3f(0.0,0.0,0.0)
2019                 glTranslatef(0.05, 0.10, 0.18)
2020                 glutSolidSphere(0.05,10,10)
2021                 glTranslatef(-0.1, 0.0, 0.0)
2022                 glutSolidSphere(0.05,10,10)
2023                 glPopMatrix()
2024
2025         // 鼻の描画
2026                 glColor3f(red, green, blue)
2027                 glRotatef(0.0,1.0, 0.0, 0.0)
2028                 glutSolidCone(0.08,0.5,10,2)
2029
2030                 glColor3f(1.0, 1.0, 1.0)
2031
2032         func renderBitmapString x,y,z,font,string
2033                 glRasterPos3f(x, y,z)
2034                 for c in string
2035                         glutBitmapCharacter(font,ascii(c))
2036                 next
2037
2038         func renderStrokeFontString x,y,z,font,string
2039                 glPushMatrix()
2040                 glTranslatef(x, y,z)
2041                 glScalef(0.002, 0.002, 0.002)
2042                 for c in string
2043                         glutStrokeCharacter(font, Ascii(c));
2044                 next
2045                 glPopMatrix()
2046
2047
2048         func restorePerspectiveProjection
2049
2050                 glMatrixMode(GL_PROJECTION)
2051                 // 以前の投射行列へ復帰
2052                 glPopMatrix()
2053
2054                 // Modelview モードの復帰
2055                 glMatrixMode(GL_MODELVIEW)
2056
2057
2058         func setOrthographicProjection
2059
2060                 // 投射モードの切り替え
2061                 glMatrixMode(GL_PROJECTION)
2062
2063                 // 透視図の設定を有する
2064                 // 以前の行列を保存します。
2065                 glPushMatrix()
2066
2067                 // 行列のリセット
2068                 glLoadIdentity()
2069
2070                 // 2D 正投射の設定
2071                 gluOrtho2D(0, w, h, 0)
2072
2073                 // modelview モードへ復帰切り替え
2074                 glMatrixMode(GL_MODELVIEW)
2075
2076
2077
2078         func computePos deltaMove
2079
2080                 x += deltaMove * lx * 0.1
2081                 z += deltaMove * lz * 0.1
2082
2083
2084         func renderScene
2085
2086                 if  deltaMove
2087                         computePos(deltaMove)
2088                 ok
2089
2090                 // 配色と深度バッファの消去
2091                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
2092
2093                 // 変換のリセット
2094                 glLoadIdentity()
2095
2096                 // カメラの設定
2097                 gluLookAt(      x, 1.0, z,
2098                                 x+lx, 1.0,  z+lz,
2099                                 0.0, 1.0,  0.0)
2100
2101                 // 地面の描画
2102
2103                 glColor3f(0.9, 0.9, 0.9)
2104                 glBegin(GL_QUADS)
2105                         glVertex3f(-100.0, 0.0, -100.0)
2106                         glVertex3f(-100.0, 0.0,  100.0)
2107                         glVertex3f( 100.0, 0.0,  100.0)
2108                         glVertex3f( 100.0, 0.0, -100.0)
2109                 glEnd()
2110
2111         // 9 体の雪だるまを描画
2112                 for i = -3 to -1
2113                         for j = -3 to -1
2114                                 glPushMatrix()
2115                                 glTranslatef(i*10.0, 0.0, j * 10.0)
2116                                 drawSnowMan()
2117                                 number = (i+3)*3+(j+3)
2118                                 renderBitmapString(0.0, 0.5, 0.0,font ,""+number)
2119                                 glPopMatrix()
2120                         next
2121                 next
2122
2123                 // 一秒あたりのフレーム数を計算するためのコード
2124                 frame++
2125
2126                 time=glutGet(GLUT_ELAPSED_TIME)
2127                 if time - timebase > 1000
2128                         s = "RingFreeGLUT - FPS: " + (frame*1000.0/(time-timebase))
2129                         timebase = time
2130                         frame = 0
2131                 ok
2132
2133                 // ビットマップフォントで文字列 (fps) を表示するためのコード
2134                 setOrthographicProjection()
2135
2136                 glPushMatrix()
2137                 glLoadIdentity()
2138                 renderBitmapString(5,30,0,GLUT_BITMAP_HELVETICA_18,s)
2139                 glPopMatrix()
2140
2141                 restorePerspectiveProjection()
2142
2143                 glutSwapBuffers()
2144
2145
2146         // -----------------------------------
2147         //             キーボード
2148         // -----------------------------------
2149
2150         func processNormalKeys
2151                 key = glutEventKey()
2152                 xx = glutEventX()
2153                 yy = glutEventY()
2154
2155                 switch key
2156                         on 27
2157                                 glutDestroyMenu(mainMenu)
2158                                 glutDestroyMenu(fillMenu)
2159                                 glutDestroyMenu(colorMenu)
2160                                 glutDestroyMenu(fontMenu)
2161                                 Shutdown()
2162                 off
2163
2164
2165         func pressKey
2166
2167                 key = glutEventKey()
2168                 xx = glutEventX()
2169                 yy = glutEventY()
2170
2171                 switch key
2172                         on GLUT_KEY_UP
2173                                  deltaMove = 0.5
2174                         on GLUT_KEY_DOWN
2175                                 deltaMove = -0.5
2176                 off
2177
2178
2179         func releaseKey
2180
2181                 key = glutEventKey()
2182
2183                 switch key
2184                         on GLUT_KEY_UP
2185                                 deltaMove = 0
2186                         on GLUT_KEY_DOWN
2187                                 deltaMove = 0
2188                 off
2189
2190
2191         // -----------------------------------
2192         //             マウス
2193         // -----------------------------------
2194
2195         func mouseMove
2196                 xx = glutEventX()
2197                 yy = glutEventY()
2198
2199                 // これは左ボタンを押したときのみ true になります。
2200                 if xOrigin >= 0
2201
2202                         // deltaAngle の更新
2203                         deltaAngle = (xx - xOrigin) * 0.001
2204
2205                         // カメラ方向の更新
2206                         lx = sin(angle + deltaAngle)
2207                         lz = -cos(angle + deltaAngle)
2208                 ok
2209
2210
2211         func mouseButton
2212
2213                 button = glutEventButton()
2214                 state = glutEventState()
2215                 xx = glutEventX()
2216                 yy = glutEventY()
2217
2218                 // これは左ボタンを押したときのみ動作開始になります。
2219                 if button = GLUT_LEFT_BUTTON
2220                         // ボタンを離したとき
2221                         if state = GLUT_UP
2222                                 angle += deltaAngle
2223                                 xOrigin = -1
2224                         else
2225                                 // state = GLUT_DOWN
2226                                 xOrigin = xx
2227                         ok
2228                 ok
2229
2230
2231         // -----------------------------------
2232         //             メニュー
2233         // -----------------------------------
2234
2235         func processMenuStatus
2236
2237                 status = glutEventStatus()
2238
2239                 if status = GLUT_MENU_IN_USE
2240                         menuFlag = 1
2241                 else
2242                         menuFlag = 0
2243                 ok
2244
2245
2246         func processMainMenu
2247
2248                 // ここにはなにもありません。
2249                 // 動作は全てサブメニューから行います。
2250
2251
2252         func processFillMenu
2253
2254                 option = glutEventValue()
2255
2256                 switch option
2257
2258                         on C_FILL
2259                                 glPolygonMode(GL_FRONT, GL_FILL)
2260                         on C_LINE
2261                                  glPolygonMode(GL_FRONT, GL_LINE)
2262                 off
2263
2264
2265         func processFontMenu
2266
2267                 option = glutEventValue()
2268
2269                 switch (option) {
2270                         on C_INT_GLUT_BITMAP_8_BY_13
2271                                 font = GLUT_BITMAP_8_BY_13
2272                         on C_INT_GLUT_BITMAP_9_BY_15
2273                                 font = GLUT_BITMAP_9_BY_15
2274                         on C_INT_GLUT_BITMAP_TIMES_ROMAN_10
2275                                 font = GLUT_BITMAP_TIMES_ROMAN_10
2276                         on C_INT_GLUT_BITMAP_TIMES_ROMAN_24
2277                                 font = GLUT_BITMAP_TIMES_ROMAN_24
2278                         on C_INT_GLUT_BITMAP_HELVETICA_10
2279                                 font = GLUT_BITMAP_HELVETICA_10
2280                         on C_INT_GLUT_BITMAP_HELVETICA_12
2281                                 font = GLUT_BITMAP_HELVETICA_12
2282                         on C_INT_GLUT_BITMAP_HELVETICA_18
2283                                 font = GLUT_BITMAP_HELVETICA_18
2284                 off
2285
2286         func processColorMenu
2287
2288                 option = glutEventValue()
2289
2290                 switch option
2291                         on C_RED
2292                                 red = 1.0
2293                                 green = 0.0
2294                                 blue = 0.0
2295                         on C_GREEN
2296                                 red = 0.0
2297                                 green = 1.0
2298                                 blue = 0.0
2299                         on C_BLUE
2300                                 red = 0.0
2301                                 green = 0.0
2302                                 blue = 1.0
2303                         on C_ORANGE
2304                                 red = 1.0
2305                                 green = 0.5
2306                                 blue = 0.5
2307                 off
2308
2309
2310         func createPopupMenus
2311
2312                 fontMenu = glutCreateMenu(:processFontMenu)
2313
2314                 glutAddMenuEntry("BITMAP_8_BY_13 ",C_INT_GLUT_BITMAP_8_BY_13 )
2315                 glutAddMenuEntry("BITMAP_9_BY_15",C_INT_GLUT_BITMAP_9_BY_15 )
2316                 glutAddMenuEntry("BITMAP_TIMES_ROMAN_10 ",C_INT_GLUT_BITMAP_TIMES_ROMAN_10  )
2317                 glutAddMenuEntry("BITMAP_TIMES_ROMAN_24",C_INT_GLUT_BITMAP_TIMES_ROMAN_24  )
2318                 glutAddMenuEntry("BITMAP_HELVETICA_10 ",C_INT_GLUT_BITMAP_HELVETICA_10  )
2319                 glutAddMenuEntry("BITMAP_HELVETICA_12",C_INT_GLUT_BITMAP_HELVETICA_12  )
2320                 glutAddMenuEntry("BITMAP_HELVETICA_18",C_INT_GLUT_BITMAP_HELVETICA_18  )
2321
2322                 fillMenu = glutCreateMenu(:processFillMenu)
2323
2324                 glutAddMenuEntry("Fill",C_FILL)
2325                 glutAddMenuEntry("Line",C_LINE)
2326
2327                 colorMenu = glutCreateMenu(:processColorMenu)
2328                 glutAddMenuEntry("Red",C_RED);
2329                 glutAddMenuEntry("Blue",C_BLUE);
2330                 glutAddMenuEntry("Green",C_GREEN);
2331                 glutAddMenuEntry("Orange",C_ORANGE);
2332
2333                 mainMenu = glutCreateMenu(:processMainMenu)
2334
2335                 glutAddSubMenu("Polygon Mode", fillMenu)
2336                 glutAddSubMenu("Color", colorMenu)
2337                 glutAddSubMenu("Font",fontMenu)
2338                  // 右ボタンでメニューへ接続
2339                 glutAttachMenu(GLUT_RIGHT_BUTTON)
2340
2341                 // これでアクティブなメニューであるかどうか検知できるようにします。
2342                 glutMenuStatusFunc(:processMenuStatus)
2343
2344
2345         // -----------------------------------
2346         //             メイン
2347         // -----------------------------------
2348
2349         func main
2350
2351                 // GLUT の初期化とウィンドウの作成
2352                 glutInit()
2353                 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
2354                 glutInitWindowPosition(100,100)
2355                 glutInitWindowSize(320,320)
2356                 glutCreateWindow("RingFreeGLUT - Test - 9 SnowMan")
2357
2358                 // コールバックの登録
2359                 glutDisplayFunc(:renderScene)
2360                 glutReshapeFunc(:changeSize)
2361                 glutIdleFunc(:renderScene)
2362
2363                 glutIgnoreKeyRepeat(1)
2364                 glutKeyboardFunc(:processNormalKeys)
2365                 glutSpecialFunc(:pressKey)
2366                 glutSpecialUpFunc(:releaseKey)
2367
2368                  // ここには二つの新しい関数があります。
2369                 glutMouseFunc(:mouseButton)
2370                 glutMotionFunc(:mouseMove)
2371
2372                 // OpenGL の初期化
2373                 glEnable(GL_DEPTH_TEST)
2374                 glEnable(GL_CULL_FACE)
2375
2376                 // メニューの初期化
2377                 createPopupMenus()
2378
2379                 // GLUT のイベント処理サイクルへ入ります。
2380                 glutMainLoop()
2381
2382
2383 スクリーンショット:
2384
2385 一枚目のスクリーンショット:
2386
2387 .. image:: ring15freeglut.png
2388         :alt: RingFreeGLUT
2389
2390
2391 二枚目のスクリーンショット:
2392
2393 .. image:: ring15freeglut2.png
2394         :alt: RingFreeGLUT
2395
2396 .. index::
2397         pair: RingOpenGL と RingFreeGLUT の用法 (3D グラフィックス); RingOpenGL と RingFreeGLUT による立方体の作例
2398
2399 RingOpenGL と RingFreeGLUT による立方体の作例
2400 =============================================
2401
2402 用例:
2403
2404 .. code-block:: ring
2405
2406         load "freeglut.ring"
2407         load "opengl21lib.ring"
2408
2409         // ----------------------------------------------------------
2410         // グローバル変数
2411         // ----------------------------------------------------------
2412         rotate_y=0
2413         rotate_x=0
2414
2415         // ----------------------------------------------------------
2416         // display() コールバック関数
2417         // ----------------------------------------------------------
2418         func display
2419
2420           // 画面と Z バッファの消去
2421           glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
2422
2423           // 変換のリセット
2424           glLoadIdentity()
2425
2426           // rotate_x および rotate_y のユーザによる変更をリセットします。
2427           glRotatef( rotate_x, 1.0, 0.0, 0.0 )
2428           glRotatef( rotate_y, 0.0, 1.0, 0.0 )
2429
2430           // 多色面 - 前
2431           glBegin(GL_POLYGON)
2432
2433           glColor3f( 1.0, 0.0, 0.0 )     glVertex3f(  0.5, -0.5, -0.5 )      # P1 is red
2434           glColor3f( 0.0, 1.0, 0.0 )     glVertex3f(  0.5,  0.5, -0.5 )      # P2 is green
2435           glColor3f( 0.0, 0.0, 1.0 )     glVertex3f( -0.5,  0.5, -0.5 )      # P3 is blue
2436           glColor3f( 1.0, 0.0, 1.0 )     glVertex3f( -0.5, -0.5, -0.5 )      # P4 is purple
2437
2438           glEnd()
2439
2440           // 白面 - 後
2441           glBegin(GL_POLYGON)
2442           glColor3f(   1.0,  1.0, 1.0 )
2443           glVertex3f(  0.5, -0.5, 0.5 )
2444           glVertex3f(  0.5,  0.5, 0.5 )
2445           glVertex3f( -0.5,  0.5, 0.5 )
2446           glVertex3f( -0.5, -0.5, 0.5 )
2447           glEnd()
2448
2449           // 紫面 - 右
2450           glBegin(GL_POLYGON)
2451           glColor3f(  1.0,  0.0,  1.0 )
2452           glVertex3f( 0.5, -0.5, -0.5 )
2453           glVertex3f( 0.5,  0.5, -0.5 )
2454           glVertex3f( 0.5,  0.5,  0.5 )
2455           glVertex3f( 0.5, -0.5,  0.5 )
2456           glEnd()
2457
2458           // 緑面 - 左
2459           glBegin(GL_POLYGON)
2460           glColor3f(   0.0,  1.0,  0.0 )
2461           glVertex3f( -0.5, -0.5,  0.5 )
2462           glVertex3f( -0.5,  0.5,  0.5 )
2463           glVertex3f( -0.5,  0.5, -0.5 )
2464           glVertex3f( -0.5, -0.5, -0.5 )
2465           glEnd()
2466
2467           // 青面 - 上
2468           glBegin(GL_POLYGON)
2469           glColor3f(   0.0,  0.0,  1.0 )
2470           glVertex3f(  0.5,  0.5,  0.5 )
2471           glVertex3f(  0.5,  0.5, -0.5 )
2472           glVertex3f( -0.5,  0.5, -0.5 )
2473           glVertex3f( -0.5,  0.5,  0.5 )
2474           glEnd()
2475
2476           // 赤面 - 下
2477           glBegin(GL_POLYGON)
2478           glColor3f(   1.0,  0.0,  0.0 )
2479           glVertex3f(  0.5, -0.5, -0.5 )
2480           glVertex3f(  0.5, -0.5,  0.5 )
2481           glVertex3f( -0.5, -0.5,  0.5 )
2482           glVertex3f( -0.5, -0.5, -0.5 )
2483           glEnd()
2484
2485           glFlush()
2486           glutSwapBuffers()
2487
2488
2489         // ----------------------------------------------------------
2490         // specialKeys() コールバック関数
2491         // ----------------------------------------------------------
2492         func specialKeys
2493
2494                 key = glutEventKey()
2495
2496           // 右矢印 - 回転を五度増分します。
2497                 switch Key
2498
2499                 on GLUT_KEY_RIGHT
2500                         rotate_y += 5
2501
2502                 // 左矢印 - 回転を五度減分します。
2503                 on GLUT_KEY_LEFT
2504                         rotate_y -= 5
2505
2506                 on GLUT_KEY_UP
2507                         rotate_x += 5
2508
2509                 on GLUT_KEY_DOWN
2510                         rotate_x -= 5
2511
2512                 off
2513
2514           //  更新の要求
2515           glutPostRedisplay()
2516
2517
2518
2519         // ----------------------------------------------------------
2520         // main() 関数
2521         // ----------------------------------------------------------
2522         func main
2523
2524           // GLUT の初期化とユーザ仮引数の処理
2525           glutInit()
2526
2527           // トゥルーカラーのウィンドウのために Z-バッファによるダブルバッファを要求します。
2528           glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
2529
2530           // ウィンドウの作成
2531           glutCreateWindow("Awesome Cube")
2532
2533           // Z バッファの深度テストを有効にします。
2534           glEnable(GL_DEPTH_TEST)
2535
2536           // コールバック関数
2537           glutDisplayFunc(:display)
2538           glutSpecialFunc(:specialKeys)
2539
2540           // イベントに関する GLUT への制御を渡します。
2541           glutMainLoop()
2542
2543           // OS へ戻ります。
2544
2545
2546 スクリーンショット:
2547
2548 .. image:: ring15opengl.png
2549         :alt: RingOpenGL
2550