def __init__(self):
        configuration = self.Configuration()
        configuration.title = "Magnum Python Primitives + SceneGraph Example"
        platform.Application.__init__(self, configuration)

        gl.Renderer.enable(gl.Renderer.Feature.DEPTH_TEST)
        gl.Renderer.enable(gl.Renderer.Feature.FACE_CULLING)

        # Scene and drawables
        self._scene = Scene3D()
        self._drawables = scenegraph.DrawableGroup3D()

        # Camera setup
        camera_object = Object3D(self._scene)
        camera_object.translate(Vector3.z_axis(10.0))
        self._camera = scenegraph.Camera3D(camera_object)
        self._camera.projection_matrix = Matrix4.perspective_projection(
            fov=Deg(35.0), aspect_ratio=1.33333, near=0.01, far=100.0)

        # Cube object and drawable
        self._cube = Object3D(self._scene)
        self._cube.rotate_y(Deg(40.0))
        self._cube.rotate_x(Deg(30.0))
        self._cube_drawable = CubeDrawable(
            self._cube, self._drawables,
            meshtools.compile(primitives.cube_solid()), shaders.Phong(),
            Color3.from_hsv(Deg(35.0), 1.0, 1.0))
    def test_drawable_group(self):
        object = Object3D()
        drawables = scenegraph.DrawableGroup3D()

        deleted = 0

        class MyDrawable(scenegraph.Drawable3D):
            def __del__(self):
                nonlocal deleted
                deleted += 1

        a = MyDrawable(object, drawables)
        b = MyDrawable(object, drawables)

        # The drawable group should have these listed
        self.assertEqual([i for i in drawables], [a, b])

        # Deleting each of them should do nothing, since they're still
        # referenced by the object
        del a, b
        self.assertEqual(deleted, 0)
        self.assertEqual(len(drawables), 2)

        # Deleting the holder object will, tho
        del object
        self.assertEqual(deleted, 2)
        self.assertEqual(len(drawables), 0)
    def test_camera_draw(self):
        scene = Scene3D()
        drawables = scenegraph.DrawableGroup3D()

        camera_object = Object3D(scene)
        camera_object.translate((0.0, 1.0, 5.0))

        camera = scenegraph.Camera3D(camera_object)

        rendered = None, None
        deleted = "no :)"

        class MyDrawable(scenegraph.Drawable3D):
            def draw(self, transformation_matrix: Matrix4,
                     camera: scenegraph.Camera3D):
                nonlocal rendered
                rendered = (transformation_matrix, camera)

            def __del__(self):
                nonlocal deleted
                deleted = "yes :("

        class MySilentDrawable(scenegraph.Drawable3D):
            def draw(self, transformation_matrix: Matrix4,
                     camera: scenegraph.Camera3D):
                pass

        object = Object3D(scene)
        object.translate(Vector3.x_axis(5.0))
        a = MyDrawable(object, drawables)
        b = MySilentDrawable(object, drawables)

        # The drawable group should have these listed
        self.assertEqual([i for i in drawables], [a, b])

        # Deleting the object, the camera holder and drawable does nothing
        del camera_object, object, a, b

        camera.draw(drawables)
        self.assertEqual(
            rendered[0],
            Matrix4.translation(Vector3.x_axis(5.0)) @ Matrix4.translation(
                (0.0, -1.0, -5.0)))
        self.assertIs(rendered[1], camera)

        # Deleting the scene will delete A and the drawable as well
        del scene
        self.assertEqual(deleted, "yes :(")
        self.assertIsNone(camera.object)
        self.assertIs(len(drawables), 0)
    def __init__(self):
        configuration = self.Configuration()
        configuration.title = "Magnum Python Viewer Example"
        Application.__init__(self, configuration)

        gl.Renderer.enable(gl.Renderer.Feature.DEPTH_TEST)
        gl.Renderer.enable(gl.Renderer.Feature.FACE_CULLING)

        # Scene and drawables
        self._scene = Scene3D()
        self._drawables = scenegraph.DrawableGroup3D()

        # Every scene needs a camera
        camera_object = Object3D(parent=self._scene)
        camera_object.translate(Vector3.z_axis(5.0))
        self._camera = scenegraph.Camera3D(camera_object)
        self._camera.aspect_ratio_policy = scenegraph.AspectRatioPolicy.EXTEND
        self._camera.projection_matrix = Matrix4.perspective_projection(
            fov=Deg(35.0), aspect_ratio=1.0, near=0.01, far=100.0)
        self._camera.viewport = self.framebuffer_size

        # Base object, parent of all (for easy manipulation)
        self._manipulator = Object3D(parent=self._scene)

        # Setup renderer and shader defaults
        gl.Renderer.enable(gl.Renderer.Feature.DEPTH_TEST)
        gl.Renderer.enable(gl.Renderer.Feature.FACE_CULLING)
        colored_shader = shaders.Phong()
        colored_shader.ambient_color = Color3(0.06667)
        colored_shader.shininess = 80.0

        # Import Suzanne head and eyes (yes, sorry, it's all hardcoded here)
        importer = trade.ImporterManager().load_and_instantiate(
            'TinyGltfImporter')
        importer.open_file(
            os.path.join(os.path.dirname(__file__), '../viewer/scene.glb'))
        suzanne_object = Object3D(parent=self._manipulator)
        suzanne_mesh = meshtools.compile(
            importer.mesh(importer.mesh_for_name('Suzanne')))
        suzanne_eyes_mesh = meshtools.compile(
            importer.mesh(importer.mesh_for_name('Eyes')))
        self._suzanne = ColoredDrawable(suzanne_object, self._drawables,
                                        suzanne_mesh, colored_shader,
                                        Color3(0.15, 0.49, 1.0))
        self._suzanne_eyes = ColoredDrawable(suzanne_object, self._drawables,
                                             suzanne_eyes_mesh, colored_shader,
                                             Color3(0.95))

        self._previous_mouse_position = Vector2i()