HN 日本語サマリー

← 一覧へ戻る
プログラミング

500行以下で実現する3Dモデラー

500 Lines or Less A 3D Modeller (aosabook.org)

89 pointsby myth_drannon11 コメント

要約

この記事では、PythonとOpenGL、GLUTを用いて、500行以下でシンプルな3Dモデラーを構築する方法を解説します。3Dオブジェクトのデータ構造、2Dスクリーンへのレンダリング、ユーザー操作による編集といった基本機能を網羅しています。実装にはシーングラフ、Compositeデザインパターン、基本的なコールバックシステムが用いられ、3Dグラフィックスプログラミングの基礎概念を示しています。

全文翻訳

500行以下で実現する3Dモデラー

*Erickはソフトウェア開発者であり、2Dおよび3Dコンピュータグラフィックスの愛好家です。彼はビデオゲーム、3D特殊効果ソフトウェア、CADツールに携わってきました。現実をシミュレートすることに関わることなら、おそらく彼はもっと知りたいと思うでしょう。オンラインではerickdransch.comで見つけることができます。

はじめに

人間は生まれながらにして創造的です。私たちは常に新しく、有用で、興味深いものを設計し、構築しています。現代では、設計および作成プロセスを支援するためにソフトウェアを記述します。コンピュータ支援設計(CAD)ソフトウェアは、作成者が物理的なバージョンを構築する前に、建物、橋、ビデオゲームのアート、映画のモンスター、3Dプリント可能なオブジェクトなど、多くのものを設計することを可能にします。

CADツールの核心は、3次元の設計を2次元のスクリーンで表示および編集できるものに抽象化する方法です。この定義を満たすために、CADツールは3つの基本的な機能を提供する必要があります。第一に、設計されているオブジェクトを表すデータ構造が必要です。これは、ユーザーが構築している3次元の世界に対するコンピュータの理解です。第二に、CADツールは設計をユーザーのスクリーンに表示する方法を提供する必要があります。ユーザーは3次元の物理オブジェクトを設計していますが、コンピュータスクリーンは2次元しかありません。CADツールは、私たちがオブジェクトをどのように認識するかをモデル化し、ユーザーがオブジェクトの3次元すべてを理解できる方法でスクリーンに描画する必要があります。第三に、CADツールは設計されているオブジェクトと対話する方法を提供する必要があります。ユーザーは望ましい結果を得るために、設計に追加したり、変更したりできる必要があります。さらに、すべてのツールは、ユーザーが共同作業、共有、および作業を保存できるように、ディスクから設計を保存およびロードする方法を必要とします。

ドメイン固有のCADツールは、そのドメインの特定の要件に対して多くの追加機能を提供します。たとえば、建築CADツールは、建物に対する気候ストレスをテストするための物理シミュレーションを提供し、3Dプリントツールは、オブジェクトが実際に印刷可能かどうかをチェックする機能を提供し、電気CADツールは、銅を流れる電気の物理をシミュレートし、映画の特殊効果スイートは、パイロキネティクスを正確にシミュレートする機能を含みます。

しかし、すべてのCADツールは、上記で議論した3つの機能、つまり設計を表すデータ構造、それをスクリーンに表示する能力、および設計と対話する方法を少なくとも含める必要があります。

これを念頭に置いて、Python 500行で3D設計をどのように表現し、スクリーンに表示し、対話できるかを探ってみましょう。

レンダリングをガイドとして

3Dモデラーにおける多くの設計上の決定の原動力は、レンダリングプロセスです。設計内の複雑なオブジェクトを格納およびレンダリングできるようにしたいと考えていますが、レンダリングコードの複雑さは低く抑えたいと考えています。レンダリングプロセスを調べ、単純なレンダリングロジックで任意に複雑なオブジェクトを格納および描画できる設計のためのデータ構造を探ってみましょう。

インターフェースとメインループの管理

レンダリングを開始する前に、いくつかセットアップする必要があります。まず、設計を表示するためのウィンドウを作成する必要があります。第二に、グラフィックスドライバーと通信してスクリーンにレンダリングしたいと考えています。グラフィックスドライバーと直接通信することは避けたいので、クロスプラットフォームの抽象化レイヤーであるOpenGLと、ウィンドウを管理するためのライブラリであるGLUT(OpenGL Utility Toolkit)を使用します。

OpenGLについて

OpenGLは、クロスプラットフォーム開発のためのグラフィカルアプリケーションプログラミングインターフェースです。これは、プラットフォーム全体でグラフィックスアプリケーションを開発するための標準APIです。OpenGLには、レガシーOpenGLとモダンOpenGLの2つの主要なバリアントがあります。

OpenGLでのレンダリングは、頂点と法線によって定義されるポリゴンに基づいています。たとえば、キューブの1つの面をレンダリングするには、4つの頂点と面の法線を指定します。

レガシーOpenGLは、「固定機能パイプライン」を提供します。グローバル変数を設定することで、プログラマーは、ライティング、カラーリング、フェイスカリングなどの機能の自動実装を有効または無効にできます。OpenGLは、有効な機能でシーンを自動的にレンダリングします。この機能は非推奨です。

一方、モダンOpenGLは、プログラマーが「シェーダー」と呼ばれる小さなプログラムを記述し、専用のグラフィックスハードウェア(GPU)で実行されるプログラマブルレンダリングパイプラインを特徴としています。モダンOpenGLのプログラマブルパイプラインは、レガシーOpenGLに取って代わりました。

このプロジェクトでは、非推奨であるにもかかわらず、レガシーOpenGLを使用します。レガシーOpenGLが提供する固定機能は、コードサイズを小さく保つのに非常に役立ちます。線形代数の知識の必要性を減らし、記述するコードを簡素化します。

GLUTについて

OpenGLにバンドルされているGLUTは、オペレーティングシステムウィンドウを作成し、ユーザーインターフェースコールバックを登録することを可能にします。この基本的な機能は私たちの目的に十分です。ウィンドウ管理とユーザーインタラクションのためのより高機能なライブラリが必要な場合は、GTKやQtのようなフルウィンドウツールキットの使用を検討するでしょう。

ビューア

GLUTとOpenGLのセットアップを管理し、モデラーの残りを駆動するために、Viewerというクラスを作成します。単一のViewerインスタンスを使用し、ウィンドウの作成とレンダリングを管理し、プログラムのメインループを含みます。Viewerの初期化プロセスでは、GUIウィンドウを作成し、OpenGLを初期化します。

init_interface関数は、モデラーがレンダリングされるウィンドウを作成し、設計をレンダリングする必要があるときに呼び出される関数を指定します。init_opengl関数は、プロジェクトのレンダリングに必要なOpenGLの状態を設定します。行列を設定し、バックフェイスカリングを有効にし、シーンを照らすライトを登録し、オブジェクトに着色したいことをOpenGLに伝えます。init_scene関数は、Sceneオブジェクトを作成し、ユーザーが開始できるようにいくつかの初期ノードを配置します。後ほどSceneデータ構造について詳しく説明します。最後に、init_interactionは、後で議論するように、ユーザーインタラクションのためのコールバックを登録します。

Viewerを初期化した後、glutMainLoopを呼び出してプログラムの実行をGLUTに引き渡します。この関数は決して返りません。GLUTイベントに登録したコールバックは、それらのイベントが発生したときに呼び出されます。

class Viewer(object):
    def __init__(self):
        """ Initialize the viewer. """
        self.init_interface()
        self.init_opengl()
        self.init_scene()
        self.init_interaction()
        init_primitives()

    def init_interface(self):
        """ initialize the window and register the render function """
        glutInit()
        glutInitWindowSize(640, 480)
        glutCreateWindow("3D Modeller")
        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
        glutDisplayFunc(self.render)

    def init_opengl(self):
        """ initialize the opengl settings to render the scene """
        self.inverseModelView = numpy.identity(4)
        self.modelView = numpy.identity(4)

        glEnable(GL_CULL_FACE)
        glCullFace(GL_BACK)
        glEnable(GL_DEPTH_TEST)
        glDepthFunc(GL_LESS)

        glEnable(GL_LIGHT0)
        glLightfv(GL_LIGHT0, GL_POSITION, GLfloat_4(0, 0, 1, 0))
        glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, GLfloat_3(0, 0, -1))

        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
        glEnable(GL_COLOR_MATERIAL)
        glClearColor(0.4, 0.4, 0.4, 0.0)

    def init_scene(self):
        """ initialize the scene object and initial scene """
        self.scene = Scene()
        self.create_sample_scene()

    def create_sample_scene(self):
        cube_node = Cube()
        cube_node.translate(2, 0, 2)
        cube_node.color_index = 2
        self.scene.add_node(cube_node)

        sphere_node = Sphere()
        sphere_node.translate(-2, 0, 2)
        sphere_node.color_index = 3
        self.scene.add_node(sphere_node)

        hierarchical_node = SnowFigure()
        hierarchical_node.translate(-2, 0, -2)
        self.scene.add_node(hierarchical_node)

    def init_interaction(self):
        """ init user interaction and callbacks """
        self.interaction = Interaction()
        self.interaction.register_callback('pick', self.pick)
        self.interaction.register_callback('move', self.move)
        self.interaction.register_callback('place', self.place)
        self.interaction.register_callback('rotate_color', self.rotate_color)
        self.interaction.register_callback('scale', self.scale)

    def main_loop(self):
        glutMainLoop()

if __name__ == "__main__":
    viewer = Viewer()
    viewer.main_loop()

render関数に入る前に、線形代数について少し説明する必要があります。

座標空間

私たちの目的のために、座標空間は原点と3つの基底ベクトルのセット、通常は(x)、(y)、(z)軸です。

点

3次元の任意の点は、原点からの(x)、(y)、(z)方向のオフセットとして表すことができます。点の表現は、点が属する座標空間に対する相対的なものです。同じ点は、異なる座標空間では異なる表現を持ちます。3次元の任意の点は、任意の3次元座標空間で表現できます。

ベクトル

ベクトルは、(x)、(y)、(z)軸における2点間の差を表す(x)、(y)、(z)値です。

変換行列

コンピュータグラフィックスでは、異なる種類の点に対して複数の異なる座標空間を使用すると便利です。変換行列は、ある座標空間から別の座標空間へ点を変換します。ベクトル(v)をある座標空間から別の座標空間へ変換するには、変換行列(M)で乗算します:(v' = M v)。一般的な変換行列には、平行移動、スケーリング、回転があります。

モデル、ワールド、ビュー、プロジェクション座標空間

[画像: Figure 13.1 - Transformation Pipeline]

Figure 13.1 - Transformation Pipeline

アイテムをスクリーンに描画するには、いくつかの異なる座標空間間で変換する必要があります。

Figure 13.11の右側、Eye SpaceからViewport Spaceまでのすべての変換は、OpenGLが処理してくれます。

Eye SpaceからHomogeneous Clip Spaceへの変換はgluPerspectiveによって処理され、Normalized Device SpaceおよびViewport Spaceへの変換はglViewportによって処理されます。これら2つの行列は乗算され、GL_PROJECTION行列として格納されます。このプロジェクトでは、これらの行列がどのように機能するかについての用語や詳細を知る必要はありません。

しかし、図の左側は自分で管理する必要があります。モデル(メッシュとも呼ばれる)内の点をワールドスペースに変換する行列をモデル行列として定義します。ワールドスペースからアイスペースへの変換を行うビュー行列も定義します。このプロジェクトでは、これら2つの行列を組み合わせてModelView行列を取得します。

完全なグラフィックスレンダリングパイプラインと関連する座標空間についてさらに学ぶには、Real Time Renderingの第2章、または他の入門的なコンピュータグラフィックスの本を参照してください。

ビューアによるレンダリング

render関数は、レンダリング時に行う必要があるOpenGL状態のセットアップから始まります。init_viewを介してプロジェクション行列を初期化し、インタラクションメンバーからのデータを使用して、シーン空間からワールドスペースへの変換行列でModelView行列を初期化します。インタラクションクラスについては後で詳しく説明します。glClearでスクリーンをクリアし、シーンに自身をレンダリングするように指示してから、ユニットグリッドをレンダリングします。

グリッドをレンダリングする前に、OpenGLのライティングを無効にします。ライティングを無効にすると、OpenGLは光源をシミュレートするのではなく、アイテムをソリッドカラーでレンダリングします。これにより、グリッドはシーンから視覚的に区別されます。最後に、glFlushは、バッファをフラッシュしてスクリーンに表示する準備ができたことをグラフィックスドライバーに通知します。

    # class Viewer
    def render(self):
        """ The render pass for the scene """
        self.init_view()

        glEnable(GL_LIGHTING)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # Load the modelview matrix from the current state of the trackball
        glMatrixMode(GL_MODELVIEW)
        glPushMatrix()
        glLoadIdentity()
        loc = self.interaction.translation
        glTranslated(loc[0], loc[1], loc[2])
        glMultMatrixf(self.interaction.trackball.matrix)

        # store the inverse of the current modelview.
        currentModelView = numpy.array(glGetFloatv(GL_MODELVIEW_MATRIX))
        self.modelView = numpy.transpose(currentModelView)
        self.inverseModelView = inv(numpy.transpose(currentModelView))

        # render the scene. This will call the render function for each object
        # in the scene
        self.scene.render()

        # draw the grid
        glDisable(GL_LIGHTING)
        glCallList(G_OBJ_PLANE)
        glPopMatrix()

        # flush the buffers so that the scene can be drawn
        glFlush()

    def init_view(self):
        """ initialize the projection matrix """
        xSize, ySize = glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)
        aspect_ratio = float(xSize) / float(ySize)

        # load the projection matrix. Always the same
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()

        glViewport(0, 0, xSize, ySize)
        gluPerspective(70, aspect_ratio, 0.1, 1000.0)
        glTranslated(0, 0, -15)
レンダリングするもの:シーン

レンダリングパイプラインをワールド座標空間での描画を処理するように初期化したので、何をレンダリングするのでしょうか?設計は3Dモデルで構成されることを目標としていることを思い出してください。設計を格納するためのデータ構造が必要であり、このデータ構造を使用して設計をレンダリングする必要があります。上記のビューアのレンダリングループからself.scene.render()を呼び出していることに注意してください。シーンとは何でしょうか?

Sceneクラスは、設計を表すために使用するデータ構造へのインターフェースです。データ構造の詳細を抽象化し、レンダリング、アイテムの追加、アイテムの操作を含む、設計と対話するために必要なインターフェース関数を提供します。Sceneオブジェクトは1つあり、ビューアが所有しています。Sceneインスタンスは、node_listと呼ばれるシーン内のすべてのアイテムのリストを保持します。また、選択されたアイテムも追跡します。シーンのrender関数は、node_listの各メンバーに対してrenderを呼び出すだけです。

class Scene(object):

    # オブジェクトを配置するカメラからのデフォルトの深度
    PLACE_DEPTH = 15.0

    def __init__(self):
        # シーンは表示されるノードのリストを保持します
        self.node_list = list()
        # 現在選択されているノードを追跡します。
        # アクションは、何かが選択されているかどうかに依存する場合があります
        self.selected_node = None

    def add_node(self, node):
        """ シーンに新しいノードを追加します """
        self.node_list.append(node)

    def render(self):
        """ シーンをレンダリングします。 """
        for node in self.node_list:
            node.render()
ノード

シーンのrender関数では、シーンのnode_listの各アイテムに対してrenderを呼び出します。しかし、そのリストの要素は何でしょうか?それらをノードと呼びます。概念的には、ノードはシーンに配置できるものです。オブジェクト指向ソフトウェアでは、Nodeを抽象基底クラスとして記述します。Sceneに配置するオブジェクトを表すすべてのクラスは、Nodeを継承します。この基底クラスにより、シーンについて抽象的に推論できます。コードベースの残りは、表示するオブジェクトの詳細を知る必要はありません。それらがNodeクラスのインスタンスであることだけを知っていれば十分です。

各タイプのNodeは、自身をレンダリングするための動作と、その他のインタラクションのための動作を定義します。Nodeは、それ自体に関する重要なデータ(平行移動行列、スケーリング行列、色など)を追跡します。ノードの平行移動行列とそのスケーリング行列の乗算は、ノードのモデル座標空間からワールド座標空間への変換行列を与えます。ノードはまた、軸配置境界ボックス(AABB)を格納します。AABBについては、後で選択について議論する際に詳しく説明します。

Nodeの最も単純な具体的な実装はプリミティブです。プリミティブは、シーンに追加できる単一のソリッド形状です。このプロジェクトでは、プリミティブはCubeとSphereです。

class Node(object):
    """ シーン要素の基底クラス """
    def __init__(self):
        self.color_index = random.randint(color.MIN_COLOR, color.MAX_COLOR)
        self.aabb = AABB([0.0, 0.0, 0.0], [0.5, 0.5, 0.5])
        self.translation_matrix = numpy.identity(4)
        self.scaling_matrix = numpy.identity(4)
        self.selected = False

    def render(self):
        """ アイテムをスクリーンにレンダリングします """
        glPushMatrix()
        glMultMatrixf(numpy.transpose(self.translation_matrix))
        glMultMatrixf(self.scaling_matrix)
        cur_color = color.COLORS[self.color_index]
        glColor3f(cur_color[0], cur_color[1], cur_color[2])
        if self.selected:  # ノードが選択されている場合は光を発する
            glMaterialfv(GL_FRONT, GL_EMISSION, [0.3, 0.3, 0.3])

        self.render_self()

        if self.selected:
            glMaterialfv(GL_FRONT, GL_EMISSION, [0.0, 0.0, 0.0])
        glPopMatrix()

    def render_self(self):
        raise NotImplementedError(
            "The Abstract Node Class doesn't define 'render_self'")

class Primitive(Node):
    def __init__(self):
        super(Primitive, self).__init__()
        self.call_list = None

    def render_self(self):
        glCallList(self.call_list)


class Sphere(Primitive):
    """ Sphere primitive """
    def __init__(self):
        super(Sphere, self).__init__()
        self.call_list = G_OBJ_SPHERE


class Cube(Primitive):
    """ Cube primitive """
    def __init__(self):
        super(Cube, self).__init__()
        self.call_list = G_OBJ_CUBE

ノードのレンダリングは、各ノードが格納する変換行列に基づいています。ノードの変換行列は、スケーリング行列と平行移動行列の組み合わせです。ノードのタイプに関係なく、レンダリングの最初のステップは、モデル座標空間からビュー座標空間への変換を行う変換行列にOpenGL ModelView行列を設定することです。OpenGL行列が最新になったら、render_selfを呼び出して、ノードに自身を描画するために必要なOpenGL呼び出しを行わせます。最後に、この特定のノードに対して行ったOpenGL状態の変更を元に戻します。ノードをレンダリングする前後にModelView行列の状態を保存および復元するために、OpenGLのglPushMatrixおよびglPopMatrix関数を使用します。ノードが色、位置、スケールを格納し、レンダリング前にそれらをOpenGL状態に適用していることに注意してください。

ノードが現在選択されている場合、光を発するようにします。これにより、ユーザーは選択したノードを視覚的に確認できます。

プリミティブをレンダリングするために、OpenGLのコールリスト機能を使用します。OpenGLコールリストは、一度定義され、単一の名前の下にバンドルされた一連のOpenGL呼び出しです。呼び出しはglCallList(LIST_NAME)でディスパッチできます。各プリミティブ(SphereとCube)は、それをレンダリングするために必要なコールリストを定義します(図示せず)。

たとえば、キューブのコールリストは、原点を中心とし、エッジが正確に1ユニット長のキューブの6つの面を描画します。

# 疑似コード キューブ定義
# 左面
# ((-0.5, -0.5, -0.5), (-0.5, -0.5, 0.5), (-0.5, 0.5, 0.5), (-0.5, 0.5, -0.5)),
# 背面
# ((-0.5, -0.5, -0.5), (-0.5, 0.5, -0.5), (0.5, 0.5, -0.5), (0.5, -0.5, -0.5)),
# 右面
# ((0.5, -0.5, -0.5), (0.5, 0.5, -0.5), (0.5, 0.5, 0.5), (0.5, -0.5, 0.5)),
# 前面
# ((-0.5, -0.5, 0.5), (0.5, -0.5, 0.5), (0.5, 0.5, 0.5), (-0.5, 0.5, 0.5)),
# 底面
# ((-0.5, -0.5, 0.5), (-0.5, -0.5, -0.5), (0.5, -0.5, -0.5), (0.5, -0.5, 0.5)),
# 上面
# ((-0.5, 0.5, -0.5), (-0.5, 0.5, 0.5), (0.5, 0.5, 0.5), (0.5, 0.5, -0.5))

プリミティブのみを使用すると、モデリングアプリケーションにとっては非常に制限的になります。3Dモデルは通常、複数のプリミティブ(またはこのプロジェクトの範囲外である三角形メッシュ)で構成されています。幸いなことに、Nodeクラスの設計は、複数のプリミティブで構成されるSceneノードを容易にします。実際、追加の複雑さをかけずに、ノードの任意のグループをサポートできます。

動機として、基本的な図形を考えてみましょう。3つの球体で構成される典型的な雪だるま、または雪のフィギュアです。図形は3つの別々のプリミティブで構成されていますが、単一のオブジェクトとして扱いたいと考えています。

他のノードを含むNodeであるHierarchicalNodeというクラスを作成します。これは「子」のリストを管理します。階層ノードのrender_self関数は、単に子ノードのそれぞれに対してrender_selfを呼び出します。HierarchicalNodeクラスを使用すると、シーンに図形を追加することが非常に簡単になります。これで、雪のフィギュアを定義することは、それを構成する形状、およびそれらの相対的な位置とサイズを指定するのと同じくらい簡単になります。

[画像: Figure 13.2 - Hierarchy of Node subclasses]

Figure 13.2 - Hierarchy of Node subclasses

class HierarchicalNode(Node):
    def __init__(self):
        super(HierarchicalNode, self).__init__()
        self.child_nodes = []

    def render_self(self):
        for child in self.child_nodes:
            child.render()
class SnowFigure(HierarchicalNode):
    def __init__(self):
        super(SnowFigure, self).__init__()
        self.child_nodes = [Sphere(), Sphere(), Sphere()]
        self.child_nodes[0].translate(0, -0.6, 0) # scale 1.0
        self.child_nodes[1].translate(0, 0.1, 0)
        self.child_nodes[1].scaling_matrix = numpy.dot(
            self.scaling_matrix, scaling([0.8, 0.8, 0.8]))
        self.child_nodes[2].translate(0, 0.75, 0)
        self.child_nodes[2].scaling_matrix = numpy.dot(
            self.scaling_matrix, scaling([0.7, 0.7, 0.7]))
        for child_node in self.child_nodes:
            child_node.color_index = color.MIN_COLOR
        self.aabb = AABB([0.0, 0.0, 0.0], [0.5, 1.1, 0.5])

Nodeオブジェクトがツリーデータ構造を形成していることに気づくかもしれません。render関数は、階層ノードを通じて、ツリーを深さ優先で走査します。走査中に、ワールドスペースへの変換に使用されるModelView行列のスタックを保持します。各ステップで、現在のModelView行列をスタックにプッシュし、すべての子ノードのレンダリングが完了したら、行列をスタックからポップして、親ノードのModelView行列をスタックのトップに残します。

Nodeクラスをこのように拡張可能にすることで、シーン操作やレンダリングの他のコードを変更することなく、新しいタイプの形状をシーンに追加できます。ノードの概念を使用して、1つのSceneオブジェクトが多くの子を持つ可能性があるという事実を抽象化することは、Compositeデザインパターンとして知られています。

ユーザーインタラクション

モデラーがシーンを格納および表示できるようになり、対話する方法が必要になりました。2種類のインタラクションを促進する必要があります。第一に、シーンのビューイングパースペクティブを変更する機能が必要です。シーンの周りにカメラを移動できるようにしたいと考えています。第二に、新しいノードを追加し、シーン内のノードを変更できるようにする必要があります。

ユーザーインタラクションを可能にするには、ユーザーがキーを押したりマウスを動かしたりしたときに知る必要があります。幸いなことに、オペレーティングシステムはこれらのイベントが発生したときにすでに知っています。GLUTは、特定のイベントが発生するたびに呼び出される関数を登録することを可能にします。キー入力やマウスの動きを解釈する関数を記述し、対応するキーが押されたときにそれらの関数を呼び出すようにGLUTに指示します。ユーザーがどのキーを押しているかがわかったら、入力を解釈し、意図されたアクションをシーンに適用する必要があります。

オペレーティングシステムイベントのリスニングとそれらの意味の解釈のロジックは、Interactionクラスにあります。前に書いたViewerクラスは、Interactionの単一インスタンスを所有しています。マウスボタンが押されたとき(glutMouseFunc)、マウスが動いたとき(glutMotionFunc)、キーボードボタンが押されたとき(glutKeyboardFunc)、および矢印キーが押されたとき(glutSpecialFunc)に呼び出される関数を登録するために、GLUTコールバックメカニズムを使用します。入力イベントを処理する関数は後で説明します。

class Interaction(object):
    def __init__(self):
        """ Handles user interaction """
        # 現在押されているマウスボタン
        self.pressed = None
        # カメラの現在の位置
        self.translation = [0, 0, 0, 0]
        # 回転を計算するためのトラックボール
        self.trackball = trackball.Trackball(theta = -25, distance=15)
        # 現在のマウス位置
        self.mouse_loc = None
        # 洗練されていないコールバックメカニズム
        self.callbacks = defaultdict(list)

        self.register()

    def register(self):
        """ glutにコールバックを登録します """
        glutMouseFunc(self.handle_mouse_button)
        glutMotionFunc(self.handle_mouse_move)
        glutKeyboardFunc(self.handle_keystroke)
        glutSpecialFunc(self.handle_keystroke)
オペレーティングシステムコールバック

ユーザー入力を意味のある方法で解釈するには、マウスの位置、マウスボタン、キーボードの知識を組み合わせる必要があります。ユーザー入力を意味のあるアクションに解釈するには多くのコードが必要なため、メインのコードパスから離れた別のクラスにカプセル化します。Interactionクラスは、他のコードベースから無関係な複雑さを隠し、オペレーティングシステムイベントをアプリケーションレベルのイベントに変換します。

    # class Interaction 
    def translate(self, x, y, z):
        """ カメラを平行移動します """
        self.translation[0] += x
        self.translation[1] += y
        self.translation[2] += z

    def handle_mouse_button(self, button, mode, x, y):
        """ マウスボタンが押されたり離されたりしたときに呼び出されます """
        xSize, ySize = glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)
        y = ySize - y  # OpenGLは反転しているため、y座標を反転します
        self.mouse_loc = (x, y)

        if mode == GLUT_DOWN:
            self.pressed = button
            if button == GLUT_RIGHT_BUTTON:
                pass
            elif button == GLUT_LEFT_BUTTON:  # ピック
                self.trigger('pick', x, y)
            elif button == 3:  # スクロールアップ
                self.translate(0, 0, 1.0)
            elif button == 4:  # スクロールアップ
                self.translate(0, 0, -1.0)
        else:  # マウスボタンリリース
            self.pressed = None
        glutPostRedisplay()

    def handle_mouse_move(self, x, screen_y):
        """ マウスが移動したときに呼び出されます """
        xSize, ySize = glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)
        y = ySize - screen_y  # OpenGLは反転しているため、y座標を反転します
        if self.pressed is not None:
            dx = x - self.mouse_loc[0]
            dy = y - self.mouse_loc[1]
            if self.pressed == GLUT_RIGHT_BUTTON and self.trackball is not None:
                # 原点を常に回転させたいので、更新されたカメラ位置は無視します
                self.trackball.drag_to(self.mouse_loc[0], self.mouse_loc[1], dx, dy)
            elif self.pressed == GLUT_LEFT_BUTTON:
                self.trigger('move', x, y)
            elif self.pressed == GLUT_MIDDLE_BUTTON:
                self.translate(dx/60.0, dy/60.0, 0)
            else:
                pass
            glutPostRedisplay()
        self.mouse_loc = (x, y)

    def handle_keystroke(self, key, x, screen_y):
        """ ユーザーからのキーボード入力時に呼び出されます """
        xSize, ySize = glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)
        y = ySize - screen_y
        if key == 's':
            self.trigger('place', 'sphere', x, y)
        elif key == 'c':
            self.trigger('place', 'cube', x, y)
        elif key == GLUT_KEY_UP:
            self.trigger('scale', up=True)
        elif key == GLUT_KEY_DOWN:
            self.trigger('scale', up=False)
        elif key == GLUT_KEY_LEFT:
            self.trigger('rotate_color', forward=True)
        elif key == GLUT_KEY_RIGHT:
            self.trigger('rotate_color', forward=False)
        glutPostRedisplay()
内部コールバック

上記のコードスニペットでは、Interactionインスタンスがユーザーアクションを解釈するときに、アクションタイプを説明する文字列とともにself.triggerを呼び出していることに気づくでしょう。Interactionクラスのtrigger関数は、アプリケーションレベルのイベントを処理するために使用する単純なコールバックシステムの1つです。Viewerクラスのinit_interaction関数がregister_callbackを呼び出すことによってInteractionインスタンスにコールバックを登録することを思い出してください。

    # class Interaction
    def register_callback(self, name, func):
        self.callbacks[name].append(func)

ユーザーインターフェースコードがイベントをシーンにトリガーする必要がある場合、Interactionクラスは、その特定のイベントに対して保存されているすべてのコールバックを呼び出します。

    # class Interaction
    def trigger(self, name, *args, **kwargs):
        for func in self.callbacks[name]:
            func(*args, **kwargs)

このアプリケーションレベルのコールバックシステムは、システムの残りの部分がオペレーティングシステム入力について知る必要性を抽象化します。各アプリケーションレベルのコールバックは、アプリケーション内の意味のある要求を表します。Interactionクラスは、オペレーティングシステムイベントとアプリケーションレベルイベント間の翻訳者として機能します。これは、モデラーをGLUT以外のツールキットに移植することにした場合、新しいツールキットからの入力を同じ意味のあるアプリケーションレベルのコールバックセットに変換するクラスに置き換えるだけでよいことを意味します。表13.1のコールバックと引数を使用します。

表13.1 - Interactionコールバックと引数

コールバック引数目的
pickx:number, y:numberマウスカーソル位置のノードを選択します。
movex:number, y:number現在選択されているノードをマウスカーソル位置に移動します。
placeshape:string, x:number, y:number指定されたタイプの形状を指定されたマウスカーソル位置に配置します。
rotate_colorforward:boolean現在選択されているノードの色をリスト内で前後に回転させます。
scaleup:boolean現在選択されているノードを拡大または縮小します(パラメータによる)。

この単純なコールバックシステムは、このプロジェクトに必要なすべての機能を提供します。しかし、本番の3Dモデラーでは、ユーザーインターフェースオブジェクトは動的に作成および破棄されることがよくあります。その場合、オブジェクトがイベントに対してコールバックを登録および登録解除できる、より洗練されたイベントリスニングシステムが必要になります。

シーンとのインターフェース

コールバックメカニズムにより、Interactionクラスからユーザー入力イベントに関する意味のある情報を受け取ることができます。これらのアクションをSceneに適用する準備ができました。

シーンの移動

このプロジェクトでは、シーンの変換によってカメラの動きを実現します。つまり、カメラは固定された位置にあり、ユーザー入力はカメラを移動するのではなくシーンを移動させます。カメラは[0, 0, -15]に配置され、ワールドスペースの原点を向いています。(あるいは、シーンを移動する代わりにカメラを移動するようにパースペクティブ行列を変更することもできます。この設計上の決定は、プロジェクトの残りの部分への影響はほとんどありません。)Viewerのrender関数に戻ると、レンダリング前にInteractionの状態がOpenGL行列状態を変換するために使用されていることがわかります。シーンとのインタラクションには、回転と平行移動の2種類があります。

トラックボールによるシーンの回転

トラックボールアルゴリズムを使用してシーンの回転を実現します。トラックボールは、3次元でシーンを操作するための直感的なインターフェースです。概念的には、トラックボールインターフェースは、シーンが透明なグローブの中にあるかのように機能します。グローブの表面に手を置いて押すと、グローブが回転します。同様に、右マウスボタンをクリックして画面上で動かすと、シーンが回転します。トラックボールの理論については、OpenGL Wikiで詳細を確認できます。このプロジェクトでは、Glumpyの一部として提供されているトラックボール実装を使用しています。

マウスの現在の位置を開始位置として、マウス位置の変更をパラメータとしてdrag_to関数を使用してトラックボールと対話します。

self.trackball.drag_to(self.mouse_loc[0], self.mouse_loc[1], dx, dy)

結果の回転行列は、シーンがレンダリングされるときにビューアのtrackball.matrixです。

余談:クォータニオン

回転は伝統的に2つの方法のいずれかで表されます。1つ目は各軸周りの回転値です。これを浮動小数点数の3タプルとして格納できます。回転のもう1つの一般的な表現はクォータニオンです。これは、(x)、(y)、(z)座標を持つベクトルと(w)回転で構成される要素です。クォータニオンを使用すると、軸ごとの回転と比較して多くの利点があります。特に、数値的に安定しています。クォータニオンは、ジンバルロックのような問題を回避します。クォータニオンの欠点は、扱いにくく、理解しにくいことです。もしあなたが勇敢で、クォータニオンについてもっと学びたいなら、この説明を参照してください。

トラックボール実装は、シーンの回転を格納するために内部的にクォータニオンを使用することで、ジンバルロックを回避します。幸いなことに、トラックボールの行列メンバーは回転を行列に変換するため、クォータニオンを直接操作する必要はありません。

シーンの平行移動

シーンの平行移動(つまり、スライド)は、回転よりもはるかに簡単です。シーンの平行移動は、マウスホイールと左マウスボタンで行われます。左マウスボタンは、(x)および(y)座標でシーンを平行移動します。マウスホイールをスクロールすると、z座標(カメラに向かってまたはカメラから離れて)でシーンが平行移動します。Interactionクラスは現在のシーンの平行移動を格納し、translate関数で変更します。ビューアは、レンダリング中にglTranslated呼び出しで使用するために、Interactionのカメラ位置を取得します。

シーンオブジェクトの選択

ユーザーがシーン全体を移動および回転させて目的のパースペクティブを取得できるようになると、次のステップは、シーンを構成するオブジェクトをユーザーが操作できるようにすることです。

ユーザーがオブジェクトを操作できるようにするには、アイテムを選択できる必要があります。

アイテムを選択するために、現在のプロジェクション行列を使用して、マウスカーソルがシーンにレイを発射しているかのように、レイを表すレイを生成します。選択されたノードは、レイが交差するカメラに最も近いノードです。したがって、ピッキングの問題は、レイとシーン内のノードとの間の交差を見つける問題に還元されます。したがって、問題は、レイがノードにヒットするかどうかをどのように判断するかということです。

レイがノードと正確に交差するかどうかを計算することは、コードの複雑さとパフォーマンスの両面で困難な問題です。各プリミティブタイプに対して、レイとオブジェクトの交差チェックを記述する必要があります。多くの面を持つ複雑なメッシュジオメトリを持つシーンノードの場合、正確なレイとオブジェクトの交差を計算するには、各面に対してレイをテストする必要があり、計算コストが高くなります。

コードをコンパクトに保ち、パフォーマンスを合理的にするために、レイとオブジェクトの交差テストには、シンプルで高速な近似を使用します。私たちの実装では、各ノードは、それが占める空間の近似である軸配置境界ボックス(AABB)を格納します。レイがノードと交差するかどうかをテストするには、レイがノードのAABBと交差するかどうかをテストします。この実装は、すべてのノードが交差テストのための同じコードを共有することを意味し、すべてのノードタイプに対してパフォーマンスコストが一定で小さいことを意味します。

    # class Viewer
    def get_ray(self, x, y):
        """
        ニアプレーンから始まり、x、y座標が向いている方向のレイを生成します

        消費: スクリーン上のマウスのx、y座標
        戻り値: レイの開始点、方向
        """
        self.init_view()

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

        # 線上の2点を取得します。
        start = numpy.array(gluUnProject(x, y, 0.001))
        end = numpy.array(gluUnProject(x, y, 0.999))

        # それらの点をレイに変換します
        direction = end - start
        direction = direction / norm(direction)

        return (start, direction)

    def pick(self, x, y):
        """ オブジェクトのピックを実行します。シーン内のオブジェクトを選択します。 """
        start, direction = self.get_ray(x, y)
        self.scene.pick(start, direction, self.modelView)

どのノードがクリックされたかを判断するために、シーンを走査してレイがノードにヒットするかどうかをテストします。現在選択されているノードを選択解除し、レイの始点に最も近い交差を持つノードを選択します。

    # class Scene
    def pick(self, start, direction, mat):
        """
        選択を実行します。

        start、directionはレイを表します。
        matはシーンの現在のモデルビュー行列の逆行列です。
        """
        if self.selected_node is not None:
            self.selected_node.select(False)
            self.selected_node = None

        # 最も近いヒットを追跡します。
        mindist = sys.maxint
        closest_node = None
        for node in self.node_list:
            hit, distance = node.pick(start, direction, mat)
            if hit and distance < mindist:
                mindist, closest_node = distance, node

        # 何かにヒットした場合、それを追跡します。
        if closest_node is not None:
            closest_node.select()
            closest_node.depth = mindist
            closest_node.selected_loc = start + direction * mindist
            self.selected_node = closest_node

Nodeクラス内では、pick関数はレイがNodeの軸配置境界ボックスと交差するかどうかをテストします。ノードが選択されている場合、select関数はノードの選択状態を切り替えます。AABBのray_hit関数は、ボックスの座標空間とレイの座標空間との間の変換行列を3番目のパラメータとして受け入れることに注意してください。各ノードは、ray_hit関数呼び出しを行う前に、独自の変換を行列に適用します。

    # class Node
    def pick(self, start, direction, mat):
        """
        レイがオブジェクトにヒットするかどうかを返します

        消費:
        start、directionはチェックするレイを形成します
        matはレイを変換するためのモデルビュー行列です
        """

        # 現在の平行移動でモデルビュー行列を変換します
        newmat = numpy.dot(
            numpy.dot(mat, self.translation_matrix), 
            numpy.linalg.inv(self.scaling_matrix)
        )
        results = self.aabb.ray_hit(start, direction, newmat)
        return results

    def select(self, select=None):
       """ 選択状態を切り替えるか設定します """
       if select is not None:
           self.selected = select
       else:
           self.selected = not self.selected
    

レイとAABBの選択アプローチは、理解と実装が非常に簡単です。しかし、特定の状況では結果が間違っています。

[画像: Figure 13.3 - AABB Error]

Figure 13.3 - AABB Error

たとえば、Sphereプリミティブの場合、球体自体はAABBの各面の中心でしかAABBに触れません。しかし、ユーザーが球体のAABBの角をクリックした場合、ユーザーがその背後にあるものに向かってクリックしようとした場合でも、球体との衝突が検出されます(Figure 13.3)。

複雑さ、パフォーマンス、および正確さの間のこのトレードオフは、コンピュータグラフィックスやソフトウェアエンジニアリングの多くの分野で一般的です。

シーンオブジェクトの変更

次に、ユーザーが選択したノードを操作できるようにしたいと考えています。選択したノードを移動、リサイズ、または色を変更したい場合があります。ノードを操作するコマンドをユーザーが入力すると、Interactionクラスは入力をユーザーが意図したアクションに変換し、対応するコールバックを呼び出します。

Viewerがこれらのイベントのいずれかのコールバックを受信すると、Sceneの適切な関数を呼び出し、それが選択されたNodeに変換を適用します。

    # class Viewer
    def move(self, x, y):
        """ シーンで移動コマンドを実行します。 """
        start, direction = self.get_ray(x, y)
        self.scene.move_selected(start, direction, self.inverseModelView)

    def rotate_color(self, forward):
        """
        選択されたノードの色を回転させます。
        ブール値'forward'は回転方向を示します。
        """
        self.scene.rotate_selected_color(forward)

    def scale(self, up):
        """ 選択されたノードをスケールします。ブール値'up'は拡大を示します。 """
        self.scene.scale_selected(up)
色の変更

色と同様に、シーンはスケーリングの変更を、もしあれば選択されたノードにディスパッチします。

    # class Scene
    def rotate_selected_color(self, forwards):
        """ 現在選択されているノードの色を回転させます """
        if self.selected_node is None: return
        self.selected_node.rotate_color(forwards)

各ノードは現在の色を格納します。rotate_color関数は、ノードの現在の色を変更するだけです。ノードがレンダリングされるときに、色はglColorでOpenGLに渡されます。

    # class Node
    def rotate_color(self, forwards):
        self.color_index += 1 if forwards else -1
        if self.color_index > color.MAX_COLOR:
            self.color_index = color.MIN_COLOR
        if self.color_index < color.MIN_COLOR:
            self.color_index = color.MAX_COLOR
ノードのスケーリング

スケールと同様に、シーンはスケーリングの変更を選択されたノードにディスパッチします。もしあれば。

    # class Scene
    def scale_selected(self, up):
        """ 現在の選択をスケールします """
        if self.selected_node is None: return
        self.selected_node.scale(up)
    

各ノードは、スケールを格納する現在の行列を格納します。(x)、(y)、および(z)方向の(x)、(y)、および(z)スケール係数でスケーリングする行列は次のようになります。

([ \begin{bmatrix} x & 0 & 0 & 0 \ 0 & y & 0 & 0 \ 0 & 0 & z & 0 \ 0 & 0 & 0 & 1 \ \end{bmatrix} )

ユーザーがノードのスケールを変更すると、結果のスケーリング行列がノードの現在のスケーリング行列に掛けられます。

    # class Node
    def scale(self, up):
        s =  1.1 if up else 0.9
        self.scaling_matrix = numpy.dot(self.scaling_matrix, scaling([s, s, s]))
        self.aabb.scale(s)

scaling関数は、(x)、(y)、(z)スケーリング係数のリストが与えられた場合、そのような行列を返します。

def scaling(scale):
    s = numpy.identity(4)
    s[0, 0] = scale[0]
    s[1, 1] = scale[1]
    s[2, 2] = scale[2]
    s[3, 3] = 1
    return s
ノードの移動

ノードを平行移動するために、ピッキングに使用したのと同じレイ計算を使用します。現在のマウス位置を表すレイをシーンのmove関数に渡します。ノードの新しい位置はレイ上にあるはずです。レイ上のどこにノードを配置するかを決定するために、ノードがカメラからどれだけ離れているかを知る必要があります。ノードが選択されたときに(pick関数で)その位置とカメラからの距離を格納したので、ここでそのデータを使用できます。ターゲットレイに沿ってカメラから同じ距離にある点を見つけ、新しい位置と古い位置の間のベクトル差を計算します。次に、結果のベクトルでノードを平行移動します。

    # class Scene
    def move_selected(self, start, direction, inv_modelview):
        """
        選択されたノードを移動します。もしあれば。

        消費:
        start、directionは移動先のレイを表します
        matはシーンのモデルビュー行列です
        """
        if self.selected_node is None: return

        # 選択されたノードの現在の深度と位置を見つけます
        node = self.selected_node
        depth = node.depth
        oldloc = node.selected_loc

        # ノードの新しい位置は、新しいレイに沿った同じ深度です
        newloc = (start + direction * depth)

        # 平行移動をモデルビュー行列で変換します
        translation = newloc - oldloc
        pre_tran = numpy.array([translation[0], translation[1], translation[2], 0])
        translation = inv_modelview.dot(pre_tran)

        # ノードを平行移動し、その位置を追跡します
        node.translate(translation[0], translation[1], translation[2])
        node.selected_loc = newloc

新しい位置と古い位置はカメラ座標空間で定義されていることに注意してください。平行移動はワールド座標空間で定義する必要があります。したがって、モデルビュー行列の逆行列を掛けることによって、カメラ空間の平行移動をワールド空間の平行移動に変換します。

スケールと同様に、各ノードは、その平行移動を表す行列を格納します。平行移動行列は次のようになります。

([ \begin{bmatrix} 1 & 0 & 0 & x \ 0 & 1 & 0 & y \ 0 & 0 & 1 & z \ 0 & 0 & 0 & 1 \ \end{bmatrix} )

ノードが平行移動されると、現在の平行移動を表す新しい平行移動行列を構築し、レンダリング中に使用するためにノードの現在の平行移動行列に掛けます。

    # class Node
    def translate(self, x, y, z):
        self.translation_matrix = numpy.dot(
            self.translation_matrix, 
            translation([x, y, z]))

translation関数は、(x)、(y)、(z)の平行移動距離を表すリストが与えられた場合、平行移動行列を返します。

def translation(displacement):
    t = numpy.identity(4)
    t[0, 3] = displacement[0]
    t[1, 3] = displacement[1]
    t[2, 3] = displacement[2]
    return t
ノードの配置

ノードの配置は、ピッキングと平行移動の両方のテクニックを使用します。現在のマウス位置のレイと同じレイ計算を使用して、ノードを配置する場所を決定します。

    # class Viewer
    def place(self, shape, x, y):
        """ シーンに新しいプリミティブの配置を実行します。 """
        start, direction = self.get_ray(x, y)
        self.scene.place(shape, start, direction, self.inverseModelView)

新しいノードを配置するには、まず対応するタイプのノードの新しいインスタンスを作成し、それをシーンに追加します。ノードをユーザーのカーソルの下に配置したいので、カメラから一定の距離にあるレイ上の点を見つけます。ここでも、レイはカメラ空間で表されるため、結果の平行移動ベクトルをモデルビュー行列の逆行列で掛けることによって、ワールド座標空間に変換します。最後に、計算されたベクトルで新しいノードを平行移動します。

    # class Scene
    def place(self, shape, start, direction, inv_modelview):
        """
        新しいノードを配置します。

        消費:
        shape 追加する形状
        start、directionは移動先のレイを表します
        inv_modelviewはシーンの逆モデルビュー行列です
        """
        new_node = None
        if shape == 'sphere': new_node = Sphere()
        elif shape == 'cube': new_node = Cube()
        elif shape == 'figure': new_node = SnowFigure()

        self.add_node(new_node)

        # カメラ空間でカーソル位置にノードを配置します
        translation = (start + direction * self.PLACE_DEPTH)

        # 平行移動をワールドスペースに変換します
        pre_tran = numpy.array([translation[0], translation[1], translation[2], 1])
        translation = inv_modelview.dot(pre_tran)

        new_node.translate(translation[0], translation[1], translation[2])

要約

おめでとうございます!小さな3Dモデラーを正常に実装しました!

[画像: Figure 13.4 - Sample Scene]

Figure 13.4 - Sample Scene

シーン内のオブジェクトを表す拡張可能なデータ構造を開発する方法を学びました。Compositeデザインパターンとツリーベースのデータ構造を使用すると、レンダリングのためにシーンを簡単に走査でき、新しいタイプのノードを追加する際に複雑さを増すことなく対応できることに気づきました。このデータ構造を活用して設計をスクリーンにレンダリングし、シーングラフの走査でOpenGL行列を操作しました。アプリケーションレベルのイベントのための非常にシンプルなコールバックシステムを構築し、オペレーティングシステムイベントの処理をカプセル化するために使用しました。レイとオブジェクトの衝突検出の可能な実装と、正確さ、複雑さ、パフォーマンスの間のトレードオフについて議論しました。最後に、シーンの内容を操作するためのメソッドを実装しました。

本番の3Dソフトウェアには、これらの同じ基本的なビルディングブロックが見つかることが期待できます。シーングラフ構造と相対座標空間は、CADツールからゲームエンジンまで、多くのタイプの3Dグラフィックスアプリケーションで見られます。このプロジェクトの主な簡略化はユーザーインターフェースにあります。本番の3Dモデラーは、完全なユーザーインターフェースを備えていることが期待され、そのためには私たちのシンプルなコールバックシステムではなく、はるかに洗練されたイベントシステムが必要になります。

このプロジェクトに新しい機能を追加するために、さらに実験を行うことができます。次のいずれかを試してください。

  • 任意の形状に対応する三角形メッシュをサポートするNodeタイプを追加します。
  • モデラーのアクションの元に戻す/やり直しを可能にする、元に戻すスタックを追加します。
  • DXFのような3Dファイル形式を使用して設計を保存/ロードします。
  • レンダリングエンジンを統合します。フォトリアリスティックレンダラーで使用するために設計をエクスポートします。
  • 正確なレイとオブジェクトの交差検出で衝突検出を改善します。

さらなる探求

現実世界の3Dモデリングソフトウェアについてのさらなる洞察を得るために、いくつかのオープンソースプロジェクトが興味深いものとなっています。

Blenderは、オープンソースのフル機能3Dアニメーションスイートです。ビデオの特殊効果の作成やゲーム作成のための完全な3Dパイプラインを提供します。モデラーはこのプロジェクトの小さな一部であり、モデラーを大規模なソフトウェアスイートに統合する良い例です。

OpenSCADは、オープンソースの3Dモデリングツールです。対話的ではなく、シーンを生成する方法を指定するスクリプトファイルを読み取ります。これにより、デザイナーは「モデリングプロセスを完全に制御」できます。

コンピュータグラフィックスのアルゴリズムとテクニックに関する詳細については、Graphics Gemsが優れたリソースです。

  1. Dr. Anton Gerdelanに画像を提供していただき感謝します。彼のOpenGLチュートリアルブックはhttp://antongerdelan.net/opengl/で入手できます。↩