Examples

Primitives, using a scene graph

Same behavior as above, but this time handling transformations using the scene graph. Compared to doing the same in C++ there’s less worrying about data ownership, as the reference counting handles most of it.

from magnum import *
from magnum import gl, meshtools, primitives, scenegraph, shaders
from magnum.platform.sdl2 import Application
from magnum.scenegraph.matrix import Scene3D, Object3D

class CubeDrawable(scenegraph.Drawable3D):
    def __init__(self, object: Object3D, drawables: scenegraph.DrawableGroup3D,
                 mesh: gl.Mesh, shader: shaders.PhongGL, color: Color4):
        scenegraph.Drawable3D.__init__(self, object, drawables)

        self._mesh = mesh
        self._shader = shader
        self.color = color # Settable from outside

    def draw(self, transformation_matrix: Matrix4, camera: scenegraph.Camera3D):
        self._shader.light_positions = [
            Vector4(camera.camera_matrix.transform_point((-3.0, 5.0, 10.0)), 0.0)
        ]
        self._shader.light_colors = [Color3(1.0)]
        self._shader.diffuse_color = self.color
        self._shader.ambient_color = Color3.from_hsv(self.color.hue(), 1.0, 0.3)
        self._shader.transformation_matrix = transformation_matrix
        self._shader.normal_matrix = transformation_matrix.rotation_scaling()
        self._shader.projection_matrix = camera.projection_matrix
        self._shader.draw(self._mesh)

class PrimitivesSceneGraphExample(Application):
    def __init__(self):
        configuration = self.Configuration()
        configuration.title = "Magnum Python Primitives + SceneGraph 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()

        # Camera setup
        camera_object = Object3D(parent=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(parent=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.PhongGL(),
            Color3.from_hsv(Deg(35.0), 1.0, 1.0))

    def draw_event(self):
        gl.default_framebuffer.clear(gl.FramebufferClear.COLOR|
                                     gl.FramebufferClear.DEPTH)

        self._camera.draw(self._drawables)
        self.swap_buffers()

    def pointer_release_event(self, event: Application.PointerEvent):
        if not event.is_primary or \
           not (event.pointer & (self.Pointer.MOUSE_LEFT|self.Pointer.FINGER)):
            return

        self._cube_drawable.color = Color3.from_hsv(
            self._cube_drawable.color.hue() + Deg(50.0), 1.0, 1.0)
        self.redraw()

    def pointer_move_event(self, event: Application.PointerMoveEvent):
        if not event.is_primary or \
           not (event.pointers & (self.Pointer.MOUSE_LEFT|self.Pointer.FINGER)):
            return

        delta = 1.0*event.relative_position/Vector2(self.window_size)
        self._cube.rotate_y_local(Rad(delta.x))
        self._cube.rotate_x(Rad(delta.y))
        self.redraw()

exit(PrimitivesSceneGraphExample().exec())