3D モデラー

class Viewer(object):
    def __init__(self):
        """ Viewer を初期化する。 """
        self.init_interface()
        self.init_opengl()
        self.init_scene()
        self.init_interaction()
        init_primitives()

    def init_interface(self):
        """ ウィンドウを初期化し、描画関数を登録する。 """
        glutInit()
        glutInitWindowSize(640, 480)
        glutCreateWindow("3D Modeller")
        glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
        glutDisplayFunc(self.render)

    def init_opengl(self):
        """ シーンをレンダリングするための OpenGL の設定を初期化する。 """
        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):
        """ 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):
        """ ユーザーとの対話機構とコールバックを初期化する。 """
        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()

    # Viewer クラス
    def render(self):
        """ シーンのレンダーパス """
        self.init_view()

        glEnable(GL_LIGHTING)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # トラックボールの現在状態を使ってモデルビュー行列を組み立てる。
        glMatrixMode(GL_MODELVIEW)
        glPushMatrix()
        glLoadIdentity()
        loc = self.interaction.translation
        glTranslated(loc[0], loc[1], loc[2])
        glMultMatrixf(self.interaction.trackball.matrix)

        # 現在のモデルビュー行列の逆行列を記録する。
        currentModelView = numpy.array(glGetFloatv(GL_MODELVIEW_MATRIX))
        self.modelView = numpy.transpose(currentModelView)
        self.inverseModelView = inv(numpy.transpose(currentModelView))

        # シーンをレンダリングする。シーンに含まれる各オブジェクトに対して
        # render メソッドが呼ばれる。
        self.scene.render()

        # グリッドをレンダリングする
        glDisable(GL_LIGHTING)
        glCallList(G_OBJ_PLANE)
        glPopMatrix()

        # バッファをフラッシュしてシーンを表示させる。
        glFlush()

    def init_view(self):
        """ 射影行列を初期化する。 """
        xSize, ySize = glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)
        aspect_ratio = float(xSize) / float(ySize)

        # 射影行列を読み込む (いつでも同じ)
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()

        glViewport(0, 0, xSize, ySize)
        gluPerspective(70, aspect_ratio, 0.1, 1000.0)
        glTranslated(0, 0, -15)

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()

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):
    """ 球プリミティブ """
    def __init__(self):
        super(Sphere, self).__init__()
        self.call_list = G_OBJ_SPHERE


class Cube(Primitive):
    """ 立方体プリミティブ """
    def __init__(self):
        super(Cube, self).__init__()
        self.call_list = G_OBJ_CUBE

# Cube の定義の疑似コード
# 左面
((-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))

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])

class Interaction(object):
    def __init__(self):
        """ ユーザーとの対話を管理する。 """
        # 現在入力されているマウスボタン
        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 クラス
    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 クラス
    def register_callback(self, name, func):
        self.callbacks[name].append(func)

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

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

    # Viewer クラス
    def get_ray(self, x, y):
        """
        始点が near 平面上にあり、スクリーン座標 (x, y) を向いたレイを返す。

        入力: スクリーン上のマウスの位置 (x, y)
        出力: レイの始点と方向
        """
        self.init_view()

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

        # レイが通る二点を計算する。
        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)

    # 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 クラス
    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

    # Viewer クラス
    def move(self, x, y):
        """ シーンに対して move コマンドを実行する。 """
        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):
        """ 選択中のノードを拡大する。 """
        self.scene.scale_selected(up)

    # Scene クラス
    def rotate_selected_color(self, forwards):
        """ 選択中のノードの色を次または前の色にする。 """
        if self.selected_node is None: return
        self.selected_node.rotate_color(forwards)

    # 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

    # Scene クラス
    def scale_selected(self, up):
        """ 選択中のノードを拡大する。 """
        if self.selected_node is None: return
        self.selected_node.scale(up)

    # 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)

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

    # Scene クラス
    def move_selected(self, start, direction, inv_modelview):
        """
        選択中のノードを移動させる。ノードを選択していなければ何もしない。

        引数:
        start, direction: ノードの移動を拘束するレイ
        inv_modelview: シーンのモデルビュー行列の逆行列
        """
        if self.selected_node is None: return

        # 選択されたノードのカメラとの距離、および現在位置を取得する。
        node = self.selected_node
        depth = node.depth
        oldloc = node.selected_loc

        # 引数のレイに沿って depth だけ進んだ点がノードの新しい位置となる。
        newloc = (start + direction * depth)

        # モデルビュー行列の逆行列を使って translation を変形する。
        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

    # Node クラス
    def translate(self, x, y, z):
        self.translation_matrix = numpy.dot(
            self.translation_matrix,
            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

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

    # 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)
        # translation をワールド座標空間に変換する。
        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])