いんちょき通信

autotoolsを導入してみた

DGLlibを修正するたびに色々なオプションをつけてビルドするのがいい加減面倒になってきたので、Makefileを導入しようと思いたった。どうせならautotoolsを使おうと決めた。

色々調べてみたら、実は手でMakefileを書いた方が楽なんじゃないかと思うくらい複雑だ。ドキュメントだけでは全く意味がわからない。とりあえず、すぐにできそうなディレクトリをそれっぽく整えることから始めることにした。できあがったディレクトリ構成は次のような感じ。

libdgl+AUTHOR
        +COPYING
        +ChangeLog
        +INSTALL
        +NEWS
        +README
        +include-GL+dgl.hpp
        |                +dglbasicshape.hpp
        |                +dglcommon.hpp
        |                +dglutil.hpp
        |                +dglwindow.hpp
        +src+dglbasicshape.cpp
              +dglutil.cpp
              +dglwindow

AUTHORとかINSTALLとかはとりあえずかっこつけるために作った空ファイル。

すぐできるところが終わってしまったので、autotoolsの作業に入る。最初は"Makefile.am"というやつを作っていかなければならないようだ。作成後のディレクトリツリーはこんな感じ。

libdgl+AUTHOR
        +COPYING
        +ChangeLog
        +INSTALL
        +Makefile.am
        +NEWS
        +README
        +include+GL---------------+Makefile.am
        |           +Makefile.am    +dgl.hpp
        |                                   +dglbasicshape.hpp
        |                                   +dglcommon.hpp
        |                                   +dglutil.hpp
        |                                   +dglwindow.hpp
        +src+Makefile.am
              +dglbasicshape.cpp
              +dglutil.cpp
              +dglwindow

各Makefike.amの中身は次のようにすればいいらしい。

===== Makefile.am =====

SUBDIRS = include src

===== include/Makefile.am =====

SUBDIR = GL

===== include/GL/Makefile.am =====

EXTRA_DIST = dgl.hpp dglbasicshape.hpp dglcommon.hpp dglutil.hpp dglwindow.hpp

===== src/Makefile.am =====

lib_LTLIBRARIES = libdgl.la
libdgl_la_SOURCES = dglutil.cpp dglbasicshape.cpp dglwindow.cpp dgl.hpp dglcommon.hpp dglutil.hpp dglbasicshape.hpp dglwindow.hpp
INCLUDES = -I../include

ここまで準備ができたら、まずはプロジェクトのルートディレクトリで"autoscan"というのを実行してひな形を作成する。

$ autoscan

すると、"configure.scan"というファイルが作成される。これを編集してconfigure.acとして保存する。

1. #                                               -*- Autoconf -*-
2. # Process this file with autoconf to produce a configure script.
4. AC_PREREQ(2.61)
5. #AC_INIT(FULL-PACKAGE-NAME, VERSION, BUG-REPORT-ADDRESS)
6. AC_INIT(libdgl, 0.1, [[email protected]])
7. AM_INIT_AUTOMAKE([foreign])
8. AC_CONFIG_SRCDIR([include/GL/dgl.hpp])
9. AC_CONFIG_HEADER([config.h])
11. # Checks for programs.
12. AC_PROG_CXX
13. AC_PROG_LIBTOOL
15. # Checks for libraries.
17. # Checks for header files.
19. # Checks for typedefs, structures, and compiler characteristics.
20. AC_C_CONST
22. # Checks for library functions.
24. AC_CONFIG_FILES([Makefile
25.                  include/GL/Makefile
26.                  include/Makefile
27.                  src/Makefile])
28. AC_OUTPUT 

5行目を6行目のように編集し、7, 12行目を追加する。ライブラリ作成には12行目を追加してlibtoolを使うようにするといいようだ。

次に"./configure"実行時に必要なヘッダーファイルを自動生成してくれる"autoheader"を実行するらしい。

$ autoheader

これで"config.h.in"というファイルが作成される。どうもaclocal.m4というファイルが必要らしく、これも"aclocal"を実行すると作成されるらしい。。

$ aclocal

いよいよautomakeを実行する。インストール時に必要なスクリプトも作成するように"--add-missing --copy"オプションを使用する。

$ automake --add-missing --copy

なにやら色々メッセージが表示される。スクリプトをインストールしたよということみたいだ。さらにどうも"ltmain.sh"がないと行っている。ゴニョゴニョと調べてみると、"autoconf "を実行するときに"-i"オプションをつけていると自動作成されるようだ。

$ autoconf -i

"configure"ファイルはできているが"ltmain.sh"はない。よくみるとautoreconf -iらしい。

#autoreconf -i

これでビルドできるはず。あとは"./configure→make→make install"でいけるはずだ。早速実行してみる。

やっとできた。"./configure --prefix=installdir"(installdirは書き込み権限があるところ)としないと"/usr/local/lib"にインストールしようとして、Permission denyで失敗するってそりゃそうだ。

今回の一式はこちらから→ Libdgl.tar.gzをダウンロード

参考サイト

• Kiyoshiy - 即席GNU (automake & autoconf)
  
• Object-Oriented & Java maneuver 別室 - Automakeでmakeする
• Emacs電子書籍 - automake

C++で関数ポインタを返す関数の備忘録

C++でほぼ毎回同じ内容をだが、その関数ポインタを他の関数に渡さなければならない状態になった。しかし、ほぼ変わらない内容の関数を毎回書くのはとても面倒なので、関数ポインタを返す関数を作成することにした。

状況を整理すると次のようになる。

• void functionA(void (*)(int, int))に関数ポインタを渡したい。このインターフェースは変更不可。
• void functionB(int, int)を毎回書くのは面倒。
• functionB内部では2つdouble値が状況によって変更する必要がある。
• 戻り値がvoid (*)(int, int)のgetFuncPointer(double, double)という関数がほしい。
• functionA(getFunPointer(double, double))とすればOKとしたい。

ここで素直に作れずに壁になった部分は

• 関数内には関数を宣言できない
• 関数内に構造体を作ってメンバ関数を返すと型に構造体名が入り、void型ではなくなってしまう

試行錯誤の末にこんな感じになった。

=== in getfunc.h ===

typedef void (*PFUNC)(int, int);
PFUNC getFuncPointer(double a, double b);

=== in getFunc.cpp ===

struct FUNC_PARAM{
  double a;
  double b;
}fPrama;

void functionB(int c, int d){
  otherFunc(c / fParam.a + d / fParam.b);
}

PFUNC getFuncPointer(double a, double b){
  fParam.a = a;
  fParam.b = b;

  return functionB
}

=== in Main.cpp ===

#include <functionA.h>
#include "getFunc.h"

int main(){
  functionA(getFuncPointer(1.0, 2.0));

  return 0;
}

こうすることで、何とか意図した動作をしているようだ。functionBとFUNC_PARAM構造体は他から利用できないようになっているし、functionBの挙動もgetFuncPointer関数への引数で変更することができる。なんだか無理矢理な感じはするが、やりたかったことはできた。

もっとスマートな方法がないものだろうか。

自作OpenGLクラス(DGLLib)詳細 その4 glwindow.hpp, glwindow.cpp

"glwindow"はGLUTのウインドウをクラスでラップした"GLWindow"クラスとウインドウの設定をまとめた"GLWindowProperty"構造体を定義している。

1. #ifndef __GLWINDOW_HPP__
2. #define __GLWINDOW_HPP__
4. #include <string>
6. #include "gl.hpp"
8. using namespace std;
10. namespace DECS{
11.   namespace GL{
13.     struct GLWindowProperty{
14.       string title_;
15.       unsigned int mode_; //描画モード
16.       GLColor bgColor_; //背景色
18.       int wWidth_; //ウィンドウの幅
19.       int wHeight_; //ウインドウの高さ
20.       int wPositionX_; //ウインドウのx座標
21.       int wPositionY_; //ウインドウのy座標
22.     };
24.     static GLWindowProperty DEFAULT_WPROP = {
25.       "GLWindow", GL_RGBA, DGL_WHITE,
26.       300, 300, 100, 100}; //デフォルトのウインドウ設定
27.     class GLWindow{
28.     private:
29.       GLWindowProperty* wProp_;
31.       void (*displayFunc_)(); //描画関数の関数ポインタ
32.       void init();
33.     public:
34.       GLWindow(int argc, char* argv[]): wProp_(&DEFAULT_WPROP)
35.       {
36.         this->wProp_->wPositionX_ =
37.           (glutGet(GLUT_SCREEN_WIDTH) - this->wProp_->wWidth_) / 2;
38.         this->wProp_->wPositionY_ =
39.           (glutGet(GLUT_SCREEN_HEIGHT) - this->wProp_->wHeight_) / 2;
40.         glutInitWindowPosition(this->wProp_->wPositionX_,
41.                                            this->wProp_->wPositionY_);
42.         glutInitWindowSize(this->wProp_->wWidth_, this->wProp_->wHeight_);
43.         glutInit(&argc, argv); glutInitDisplayMode(this->wProp_->mode_);
44.       }
45.       GLWindow(int argc, char* argv[], GLWindowProperty* wProp): wProp_(wProp)
46.       {
47.         glutInitWindowPosition(this->wProp_->wPositionX_,
48.                                            this->wProp_->wPositionY_);
49.         glutInitWindowSize(this->wProp_->wWidth_, this->wProp_->wHeight_);
50.         glutInit(&argc, argv); glutInitDisplayMode(this->wProp_->mode_);
51.       }
53.       ~GLWindow(){};
55.       void setBGColor(GLColor bgColor); //背景色設定関数
56.       void setDisplayFunc(void (*displayFunc)()); //描画関数を設定する関数
58.       void create(); //ウインドウ作成関数
59.     };
60.   }
61. }
63. #endif // __GLWINDOW_HPP__

使い方はメイン関数内で次のように記述する。

1. int main(int argc, char* argv[]){
2.   GLWindowProperty wProp = {
3.       "DECS GL TEST", GL_RGBA, DGL_WHITE,
4.       500, 500, 100, 100};
6.   GLWindow w(argc, argv, &wProp);
7.   w.setDisplayFunc(display);
8.   w.create();
10.   return EXIT_SUCCESS;
11. }

WindowProperty構造体を用意して、コマンドライン引数とともにインスタンスを生成する。次に描画関数を設定して、"create()"を実行する。ここで描画関数は"void display()"と定義されている。

構成要素の詳細 : 

• 自作OpenGLクラス(DGLLib)詳細 その1 gl.hpp
  
• 自作OpenGLクラス(DGLLib)詳細 その2 glutil.hpp, glutil.cpp
• 自作OpenGLクラス(DGLLib)詳細 その3 glbasicshape.hpp, glbasicshape.cpp
• 自作OpenGLクラス(DGLLib)詳細 その4 glwindow.hpp, glwindow.cpp

自作OpenGLクラス(DGLLib)詳細 その3 glbasicshape.hpp, glbasicshape.cpp

"glbasicshape"は基本図形クラスを定義している。現在のところ以下のものを含んでいる。

• 直線
• 三角形
• 四角形
• 円(N角形)

基本的に各図形はGLObjectクラスを継承している。

1. #ifndef __GLBASICSHAPE_HPP__
2. #define __GLBASICSHAPE_HPP__
4. #include "gl.hpp"
6. namespace DECS{
7.   namespace GL{
9.     class GLLine : GLObject{
10.     private:
11.       GLPosition beginPoint_;
12.       GLPosition endPoint_;
14.       GLLine(){};
15.     public:
16.       GLLine(GLPosition beginPoint, GLPosition endPoint):
17.         GLObject(GL_LINES), beginPoint_(beginPoint), endPoint_(endPoint){};
18.       GLLine(GLPosition beginPoint, GLPosition endPoint, GLColor color):
19.         GLObject(GL_LINES, color), beginPoint_(beginPoint), endPoint_(endPoint){};
20.       GLLine(int mode,     GLPosition beginPoint, GLPosition endPoint,     GLColor color):
21.         GLObject(mode, color), beginPoint_(beginPoint), endPoint_(endPoint){};
22.       ~GLLine(){};
24.       void setPoint(GLPosition beginPoint, GLPosition endPosition);
25.       virtual void setColor(GLColor color);
26.       virtual void draw();
27.     };
29.     class GLTriangle :GLObject{
30.     private:
31.       GLPosition point1_;
32.       GLPosition point2_;
33.       GLPosition point3_;
34.  
35.       GLTriangle(){};
36.     public:
37.       GLTriangle(GLPosition point1, GLPosition point2, GLPosition point3):
38.         GLObject(GL_LINE_LOOP),
39.         point1_(point1), point2_(point2), point3_(point3){};
40.       GLTriangle(GLPosition point1, GLPosition point2, GLPosition point3,
41.                         GLColor color):
42.         GLObject(GL_LINE_LOOP, color),
43.         point1_(point1), point2_(point2), point3_(point3){};
44.       GLTriangle(int mode,
45.                         GLPosition point1, GLPosition point2, GLPosition point3):
46.         GLObject(mode),
47.         point1_(point1), point2_(point2), point3_(point3){};
48.       GLTriangle(int mode,
49.                        GLPosition point1, GLPosition point2, GLPosition point3,
50.                        GLColor color):
51.         GLObject(mode, color),
52.         point1_(point1), point2_(point2), point3_(point3){};
53.       ~GLTriangle(){};
55.       void setPoint(GLPosition point1, GLPosition point2, GLPosition point3);
56.       virtual void setColor(GLColor color);
57.       virtual void draw();
58.     };
60.     class GLSquare : GLObject{
61.     private:
62.       GLPosition point1_;
63.       GLPosition point2_;
64.       GLPosition point3_;
65.       GLPosition point4_;
67.       GLSquare(){};
68.     public:
69.       GLSquare(GLPosition point1, GLPosition point2,
70.                      GLPosition point3, GLPosition point4):
71.         GLObject(GL_LINE_LOOP),
72.         point1_(point1), point2_(point2),
73.         point3_(point3), point4_(point4){};
74.       GLSquare(GLPosition point1, GLPosition point2,
75.                      GLPosition point3, GLPosition point4,
76.                      GLColor color):
77.         GLObject(GL_LINE_LOOP, color),
78.         point1_(point1), point2_(point2),
79.         point3_(point3), point4_(point4){};
81.       GLSquare(int mode,
82.                      GLPosition point1, GLPosition point2,
83.                      GLPosition point3, GLPosition point4):
84.         GLObject(mode),
85.         point1_(point1), point2_(point2),
86.         point3_(point3), point4_(point4){};
87.       GLSquare(int mode,
88.                      GLPosition point1, GLPosition point2,
89.                      GLPosition point3, GLPosition point4,
90.                      GLColor color):
91.         GLObject(mode, color),
92.         point1_(point1), point2_(point2),
93.         point3_(point3), point4_(point4){};
94.       ~GLSquare(){};
96.       void setPoint(GLPosition point1, GLPosition point2,
97.                            GLPosition point3, GLPosition point4);
98.       virtual void setColor(GLColor color);
99.       virtual void draw();
100.     };
102.     class GLCircle : GLObject{
103.     private:
104.       GLPosition center_;
105.       GLdouble radius_;
106.       int nPoint_;
108.       GLCircle(){};
109.     public:
110.       GLCircle(GLdouble radius):
111.         GLObject(GL_LINE_LOOP),
112.         center_(DGL_ORIGIN), radius_(radius), nPoint_(100){};
113.       GLCircle(GLPosition center, GLdouble radius):
114.         GLObject(GL_LINE_LOOP),
115.         center_(center), radius_(radius), nPoint_(100){};
116.       GLCircle(int mode, GLPosition center, GLdouble radius):
117.         GLObject(mode),
118.         center_(center), radius_(radius), nPoint_(100){};
119.       GLCircle(GLPosition center, GLdouble radius, GLColor color):
120.         GLObject(GL_LINE_LOOP, color),
121.         center_(center), radius_(radius), nPoint_(100){};
122.       GLCircle(int mode,
123.                    GLPosition center, GLdouble radius, GLColor color):
124.         GLObject(mode, color),
125.         center_(center), radius_(radius), nPoint_(100){};
126.       GLCircle(int mode,
127.                     GLPosition center, GLdouble radius, int nPoint,
128.                     GLColor color):
129.         GLObject(mode, color),
130.         center_(center), radius_(radius), nPoint_(nPoint){};
131.       ~GLCircle(){};
133.       void setCenter(GLPosition center);
134.       void setRadius(GLdouble radius);
135.       void setNumberOfPoints(int nPoint);
137.       virtual void setColor(GLColor color);
138.       virtual void draw();
139.     };
140.     /* Following 3D Shape Classes are not supported yet.
141.     class GLCube : GLObject{    };
143.     class GLPyramid : GLObject{    };
145.     class GLCone : GLObject{    };
146.     */
147.   }
148. }
150. #endif // __GLBASICSHAPE_HPP__

基本的にサイズなどを指定してインスタンスを生成するか、インスタンス生成後にサイズや色を指定して、描画関数内で"draw()"メンバ関数を呼び出す作りになっている。

構成要素の詳細 : 

• 自作OpenGLクラス(DGLLib)詳細 その1 gl.hpp
  
• 自作OpenGLクラス(DGLLib)詳細 その2 glutil.hpp, glutil.cpp
• 自作OpenGLクラス(DGLLib)詳細 その3 glbasicshape.hpp, glbasicshape.cpp
• 自作OpenGLクラス(DGLLib)詳細 その4 glwindow.hpp, glwindow.cpp

自作OpenGLクラス(DGLLib)詳細 その2 glutil.hpp, glutil.cpp

"glutil"は色と座標を管理する"GLColor"、"GLPosition"クラスを定義する。GLColorクラスはRGBA指定、GLPositionクラスは3次元座標を扱う。

1. #ifndef __GLUTIL_HPP__
2. #define __GLUTIL_HPP__
4. #include <GLUT/glut.h>
6. namespace DECS{
7.   namespace GL{
9.     static const int X = 0; //x座標の添え字
10.     static const int Y = 1; //y座標の添え字
11.     static const int Z = 2; //z座標の添え字
12.     static const int R = 0; //赤の添え字
13.     static const int G = 1; //緑の添え字
14.     static const int B = 2; //青の添え字
15.     static const int A = 3; //アルファ値の添え字
17.     class GLColor{
18.     private:
19.       GLdouble color_[4];
20.     public:
21.       GLColor();
22.       GLColor(GLdouble r, GLdouble g, GLdouble b); //アルファ値を指定しない場合は1.0
23.       GLColor(GLdouble r, GLdouble g, GLdouble b, GLdouble a);
24.       ~GLColor();
26.       GLdouble r();
27.       GLdouble g();
28.       GLdouble b();
29.       GLdouble a();
30.     };
31.     class GLPosition{
32.     private:
33.       GLdouble position_[3];
34.     public:
35.       GLPosition();
36.       GLPosition(GLdouble x, GLdouble y, GLdouble z);
37.       ~GLPosition();
38.       GLdouble& x();
39.       GLdouble& y();
40.       GLdouble& z();
41.     };
42.   }
43. }
45. #endif // __GLUTIL_HPP__

GLColorクラスではRGBAの各値を取得するのみで、インスタンス化後の変更はできない。GLPositionクラスはXYZ各値の参照を返すので、インスタンスの各値を変更することができる。

構成要素の詳細 : 

• 自作OpenGLクラス(DGLLib)詳細 その1 gl.hpp
  
• 自作OpenGLクラス(DGLLib)詳細 その2 glutil.hpp, glutil.cpp
• 自作OpenGLクラス(DGLLib)詳細 その3 glbasicshape.hpp, glbasicshape.cpp
• 自作OpenGLクラス(DGLLib)詳細 その4 glwindow.hpp, glwindow.cpp

自作OpenGLクラス(DGLLib)詳細 その1 gl.hpp

"gl.hpp"は自作OpenGLクラス基本図形のベースになる"GLObject"を定義している。そのほかに、三原色、白、黒といった色や原点座標の静的オブジェクトを定義している。ヘッダーのみで実装が伴わない。

1. #ifndef __GL_HPP__
2. #define __GL_HPP__
4. #include "glutil.hpp"
6. namespace DECS{
7.   namespace GL{
9.     static GLColor DGL_WHITE(1.0, 1.0, 1.0, 1.0); //白
10.     static GLColor DGL_BLACK(0.0, 0.0, 0.0, 1.0); //黒
11.     static GLColor DGL_RED(1.0, 0.0, 0.0, 1.0); //赤
12.     static GLColor DGL_GREEN(0.0, 1.0, 0.0, 1.0); //緑
13.     static GLColor DGL_BLUE(0.0, 0.0, 1.0, 1.0); //青
15.     static GLPosition DGL_ORIGIN(0.0, 0.0, 0.0); //原点
17.     class GLObject{
18.     protected:
19.       int mode_;
20.       GLColor color_;
21.     public:
22.       GLObject():mode_(GL_POLYGON){}; //デフォルトコンストラクタ
23.       GLObject(int mode):mode_(mode){}; //モード指定コンストラクタ
24.       GLObject(int mode, GLColor color):mode_(mode), color_(color){};
25.       //モード、色指定コンストラクタ
26.       virtual void setColor(GLColor color) = 0; //色設定関数
27.       virtual void draw() = 0; //描画関数
28.     };
29.   }
30. }
32. #endif // __GL_HPP__

基本図形はこの"GLObject"を継承する。

構成要素の詳細 : 

• 自作OpenGLクラス(DGLLib)詳細 その1 gl.hpp
  
• 自作OpenGLクラス(DGLLib)詳細 その2 glutil.hpp, glutil.cpp
• 自作OpenGLクラス(DGLLib)詳細 その3 glbasicshape.hpp, glbasicshape.cpp
• 自作OpenGLクラス(DGLLib)詳細 その4 glwindow.hpp, glwindow.cpp

GLUT、OpenGLで作るウインドウやらをクラスでラップしてみた

前回、前々回で試してみたGLUTでOpenGLだが、1ファイルにごちゃごちゃと書いてわからなくなってきたので、ファイルを分けて整理+改良してみた。構成は以下の通り。

• gl.hpp : GLObjectクラスを定義、色、原点の定数を定義
• glutil.hpp, glutil.cpp : GLColorクラス、GLPositionクラスを定義、実装
• glbasicshape.hpp, glbasicshape.cpp : GLLineクラス、GLTriangleクラス、GLSquareクラス、GLCircleクラスを定義、実装
• glwindow.hpp, glwindow.cpp : GLWindowProperty構造体、GLWindowクラスを定義、実装

要は過去2回で作ったものを整理整頓したということ。過去のものからの改善点は次の通り。

• 座標や色指定で数字をごちゃごちゃと引数に渡すのめんどうなので、GLColorクラスとGLPositionクラスで管理することにした
• 白、黒、赤、緑、青のGLColorオブジェクトを定義した
• 原点を表すGLPositionオブジェクトを定義した
• 基本図形として直線(GLLine)、三角形(GLTriangle)、四角形(GLSquare)を追加した
• 円(GLCircle)のメンバ変数radius_はちゃんと半径を表すようにした
• 基本図形のモード指定が可能になった
• ウインドウのタイトルやサイズなどを管理する構造体(GLWindowProperty)を追加して、Window作成時の引数をすっきりさせた
• 描画関数をフレンド関数からメンバ変数の関数ポインタに変更して、変な依存関係をマシにした

試した感じではひとまず意図したとおりに動いているようだ。今後はこれをベースにいろいろ試してみようと思う。今思いつく限りの改善点は次の通り。

• 相変わらずドキュメントがないのがいけてないと思う
• 相変わらずエラー時の挙動とかを考えていないのがいまいち
• 座標系を設定する
• マウスイベントとキーボードイベントぐらいは扱えるようにする
• 3Dを扱いたい
• アニメーションを扱いたい
• ファイルに出力したい
• 共有ライブラリ化とmakeとかで簡単にビルドできるようにしたい

ちなみにソースはこちら→ Dgl.tar.gzをダウンロード

$ g++ -o testDGL testDGL.cpp glutil.cpp glwindow.cpp glbasicshape.cpp -framework GLUT -framework OpenGL

とすればビルドできるはず。ちなみに実行するとこんな感じ。

構成要素の詳細 : 

• 自作OpenGLクラス(DGLLib)詳細 その1 gl.hpp
  
• 自作OpenGLクラス(DGLLib)詳細 その2 glutil.hpp, glutil.cpp
• 自作OpenGLクラス(DGLLib)詳細 その3 glbasicshape.hpp, glbasicshape.cpp
• 自作OpenGLクラス(DGLLib)詳細 その4 glwindow.hpp, glwindow.cpp

OpenGLで円を描いてみる

前回の記事でOpenGLを使ってウインドウを表示してみたが、味気なさ過ぎるのでとりあえず2Dの何かを描いてみることにした。直線とか四角を描くのも少し物足りないので円にする。

OpenGLの描画は基本的に頂点を指定してつないでいくというものなので、円は細かい直線の連続として表すことになる。基本的な描画方法は次のようになる。

1. glColor3d(GLdoubleR, GLdouble G, GLdouble B);←この後描くものの色を指定
2. glBegin(GL_POLYGON);←ポリゴンで描く、他にも線で囲むだけのGL_LINE_LOOPとかを指定できる。
3. glVertex3d(GLdouble x, GLdouble y, GLdouble z);←頂点を指定
4. glVertex3dを繰り返して必要な頂点を順番に指定する。
5. glEnd();

以上のような処理を描画関数の中に書くといいらしい。

どうも一つずつ頂点を指定して、形を指定しなければならないようでとてもめんどくさい。というわけで、よく使いそうな図形のクラスを作成することにした。とりあえず今回描こうとしている円クラスを作ることにする。将来的に四角とか三角を作るためにGLObjectクラスを作成し、それを継承することにした。

GLObjectクラス

1. class GLObject{
2. protected:
3.   int mode_;←描画モード
4.   GLColor color_;←塗りつぶす色
5. public:
6.   GLObject():mode_(GL_POLYGON){};←デフォルトはポリゴン
7.   GLObject(int mode):mode_(mode){};
8.   virtual void setColor(GLColor Color) = 0;←色指定メンバ関数
9.   virtual void setObject() = 0;←配置メンバ関数
10. }

GLObjectクラスは抽象クラスとした。オブジェクトなんて曖昧なものを実体化できるわけがない。デフォルトでポリゴンモードで描画して、色をメンバ偏すに持っている。色指定と配置関数を用意した。こいつを継承する形でGLCircleクラスを作成する。

GLCircleクラス

1. class GLCircle : GLObject{
2. private:
3.   GLdouble center_[2];←中心座標
4.   GLdouble radius_;←直径
5.   int nPoint_;←描画する直線の数
6. public:
7.   GLCircle():
8.     radius_(0.5),nPoint_(20)←デフォルトはウインドウの半分の直径で20本の直線で描画
9.   {
10.     this->center_[0] = 0.5;
11.     this->center_[1] = 0.5;←中心座標はウインドウの中心
12.   }
14.   GLCircle(int mode):←モード指定できるコンストラクタ、他のはデフォルトと同じ
15.     GLObject(mode),
16.     radius_(0.5),
17.     nPoint_(20)
18.   {
19.     this->center_[0] = 0.5;
20.     this->center_[1] = 0.5;
21.   }
23.   GLCircle(int mode, GLdouble x, GLdouble y, GLdouble r, int n):←全部指定のコンストラクタ
24.     GLObject(mode),
25.     radius_(r),
26.     nPoint_(n)
27.   {
28.     this->center_[0] = x;
29.     this->center_[1] = y;
30.   }
32.   virtual void setColor(GLColor Color){←色設定メンバ関数の実装
33.     this->color_ = Color;
34.   }
36.   virtual void setObject()←配置関数の実装
37.   {
38.     glColor3d(this->color_.r(), this->color_.g(), this->color_.b());←色指定
39.     glBegin(this->mode_);
40.     for(int i = 0; i < this->nPoint_; i++){←要は直線数で分割して点を指定していくということ
41.       double rate = (double)i / nPoint_;
42.       double x = this->radius_ * cos(2.0 * M_PI * rate) + this->center_[0];←i番目のx座標
43.       double y = this->radius_ * sin(2.0 * M_PI * rate) + this->center_[1];←i番目のy座標
44.       glVertex3d(x, y, 0.0);
45.     }
46.     glEnd();
47.   }
49.   void setCenter(GLdouble x, GLdouble y)←中心座標設定メンバ関数
50.   {
51.     this->center_[0] = x;
52.     this->center_[1] = y;
53.   }
55.   void setNPoint(int n)←直線数の指定メンバ関数
56.   {
57.     this->nPoint_ = n;
58.   }
60.   void setRadius(GLdouble r)←直径指定メンバ関数
61.   {
62.     this->radius_ = r;
63.   }
64. }

GLObjectのメンバに加えて、中心座標と半径と何本の直線で表示するの変数とそれぞれのset関数を用意した。直径指定なのに変数名が半径なのは途中まで半径と思い込んでいたためで、気にしないでほしい。

ついでに、所々に出てくるGLColorなるものは、色指定でいちいち３つも値を描くのが面倒なため、クラス化したもの。中身はこんな感じ。

1. class GLColor{
2. private:
3.   GLdouble r_;
4.   GLdouble g_;
5.   GLdouble b_;
6. public:  GLColor():
7.     r_(0.0),g_(0.0),b_(0.0){}
8.   GLColor(GLdouble r, GLdouble g, GLdouble b):
9.     r_(r),g_(g),b_(b){}
10.   ~GLColor(){}
11.   GLdouble r(){ return this->r_; }
12.   GLdouble g(){ return this->g_; }
13.   GLdouble b(){ return this->b_; }
14. }

メンバ変数にRGBそれぞれの値を持っていて、メンバ関数から呼び出せるというもの。

前回作成した描画関数にこんな感じで書き足す

1. void display(){
2.   GLCircle circle;←円オブジェクトを作成
3.   GLColor color(0.0, 1.0,0.0);←緑色を作る
4.   circle.setColor(color);←色指定
5.   circle.setNPoint(100);←分割数
6.   circle.setCenter(0.1, 0.1);←中心座標指定
7.   glClear(GL_COLOR_BUFFER_BIT);
8.   circle.setObject();←配置
9.   glFlush();
10. }

メイン関数とかは前回と変わらない。これを実行すると次のようになる。

いくら何でも色のセンスが悪すぎだとは思う。が、気にしない。全体のソースはこちら→ WindowClass2.cpp

ついでに直線の本数を10本にしたものは次のようになる。

これはもはや円ではないと思う。円を描くクラスと言うより、正n角形を描画するクラスってことでおおような気もしてきた。今回はここまで。

OpenGLを試してみる

ターミナルでちょこまかするのに飽きてきたので、お絵かきをしてみようといきなりOpenGLに飛びついた。ちょっと調べてみるとどうやらGLUT(The OpenGL Utility Toolkit)というやつを使うと便利らしい。

Mac OS Xの場合、個別にインストールしなくてもDeveloper Toolsに含まれていることがわかった。さっそくWindowを作ってみる。

1. #include <cstdlib>
3. #include <GLUT/glut.h>
5. using namespace std;
7. void display(void)
8. {
9. }
10. int main(int argc, char* argv[], char* envp[])
11. {
12.   glutInit(&argc, argv);
13.   glutCreateWindow(argv[0]);
14.   glutDisplayFunc(display);
15.   glutMainLoop();
17.   return EXIT_SUCCESS;
18. }

TestGL.cppをダウンロード

どうもMac以外では「#include <GLUT/glut.h>」を「#include <GL/glut.h>」とすればいいらしい。ちなみに試してはいない。

1. 流れとしては「glutinit」にコマンドライン引数をそのまま渡して初期化する。
2. 「glutCreateWindow」でウィンドウを開く。引数はタイトルバーに表示される文字列らしい。
3. 「glutDisplayFunc」に描画関数の関数ポインタを渡す。描画や再描画のタイミングでここでしてした関数が呼ばれるらしい。
4. 「glutMainLoop」はイベントを待っているやつ。

また、ビルド時は「-framework」オプションが必要になる。

# g++ -o testGL testGL.cpp -framework GLUT -framework OpenGL

とするとOK。実行すると下のような味気ないWindowが表示される。
ただ、メイン関数内にglut〜、glut〜と書くのが、ごちゃごちゃしそうでいやなので、クラスにしてしまおうと改良してみた。そのソースは次の通り。

1. #include <string>
2. #include <cstdlib>
4. #include <GLUT/glut.h>
6. using namespace std;
8. void display()
9. {
10. }
12. class Window{
13. private:
14.   string title_;
15. public:
16.   Window(int argc, char* argv[], string title):
17.     title_(title)
18.   {
19.     glutInit(&argc, argv);
20.     glutCreateWindow(this->title_c_str());
21.     glutDisplayFunc(display);
22.     glutMainLoop();
23.   }
24.   ~Window(){}
25.   friend void display();
26. };
28. int main(int argc, char* argv[], char* envp[])
29. {
30.   Window w(argc, argv, "Window Class Version");
32.   return EXIT_SUCCESS;
33. }

WindowClass.cppをダウンロード

基本的な処理は一緒だが、Windowクラス内にglut〜の処理を放り込んでいる。コンストラクタ内で処理を行っているのがいけてないとは思う。また、描画関数をメンバに加えると、どうしてもうまく関数ポインタで渡せなかったので、フレンド関数としている。ここもなんだかいけてない。ちなみに実行したところは下のような感じ。

あいかわらず味気ない。一応ウインドウのタイトルにメンバ変数が反映されているのがわかる。

次はウインドウ内に描画しようと思うが、長くなってきたので次回に続く。

boost::threadを使って、クラス内でスレッドを作ってみる

最近のマイブームboost::threadをもう少しゴニョゴニョしてみた。

今回はクラスをインスタンス化するときにスレッド生成して、そのクラスのメンバ関数をバックグランドで実行する。スレッドの同期はデストラクタ内で行う。つまり、プログラム内でクラスをインスタンス化すると、メイン関数の処理を気にせず裏でひたすらメンバ関数を実行している感じ。

1. #include <iostream>
2. #include <string>
4. #include <cstdlib>
5. #include <ctime>
7. #include <boost/thread.hpp>
8. #include <boost/bind.hpp>
10. using namespace std;
11. using namespace boost;
13. class threadWriter{
14. private:
15.   string thName_;
16.   thread th_;
17. public:
18.   void writeMsg()  {
19.     time_t clock;
20.     for (int i = 0; i < 100; i++){
21.       time(&clock);
22.       cout << this->thName_ << ": " << ctime(&clock);
23.       for(int j = 0; j < 10000; j++){
24.         for(int k = 0; k < 10000; k++){
25.           int a = j * k;
26.         }
27.       }
28.     }
29.   }
30.   threadWriter(){  }
31.   threadWriter(string thName)
32.     :thName_(thName),th_(bind(&threadWriter::writeMsg, this)){  }
33.   ~threadWriter()
34.   {
35.     this->th_.join();
36.   }
37. };
39. int main()
40. {
41.   string thName="THREAD 1";
42.   threadWriter thw1(thName);
44.   time_t clock;
45.   for (int i = 0; i < 100; i++){
46.     time(&clock);
47.     cout << "MAIN: " << ctime(&clock);
48.     for(int j = 0; j < 10000; j++){
49.       for(int k = 0; k < 10000; k++){
50.         int a = j * k;
51.       }
52.     }
53.   }
55.  return EXIT_SUCCESS;
56. } 

ThreadInClass.cppをダウンロード

32行目で初期化子を使ってクラスのthread型のメンバ変数に、メンバ関数オブジェクトを渡している。このとき、boost::bindを使用してメンバ関数のオブジェクトを作成している。

35行目のデストラクタ内でスレッドの終了を待っている。これによって、スレッドが終了して初めてインスタンスが破棄されることになる。

実行結果はこんな感じ

MAIN: Mon Feb  7 00:34:08 2011

THREAD 1: Mon Feb  7 00:34:08 2011

MAIN: Mon Feb  7 00:34:08 2011

THREAD 1: Mon Feb  7 00:34:08 2011

MAIN: Mon Feb  7 00:34:09 2011

THREAD 1: Mon Feb  7 00:34:09 2011

THREAD 1: Mon Feb  7 00:34:09 2011

MAIN: Mon Feb  7 00:34:09 2011

THREAD 1: Mon Feb  7 00:34:10 2011

MAIN: Mon Feb  7 00:34:10 2011

THREAD 1: Mon Feb  7 00:34:10 2011

MAIN: Mon Feb  7 00:34:10 2011

THREAD 1: Mon Feb  7 00:34:10 2011

MAIN: Mon Feb  7 00:34:10 2011

THREAD 1: Mon Feb  7 00:34:11 2011

MAIN: Mon Feb  7 00:34:11 2011

MAIN: Mon Feb  7 00:34:11 2011

MAIN: Mon Feb  7 00:34:11 2011

 

ただ、なぜか最初の表示だけ「: Mon Feb  7 00:33:34 2011」となり「THREAD 1」が表示されない。今日は疲れたので、調べるのは今度にしよう。