First Scene

This example creates geometry data, inserts it into the scene, and demonstrates materials, hierarchy, local/world transforms, quaternion input, and debug axes.

import numpy as np


class MyApp(ke.App):
    def setup(self):
        self.standard_materials = self.create_standard_materials()
        self.scene.add_ground(path="/ground", scale=30.0)

        box: ke.RenderablePrimView = self.scene.add_mesh(
            path="/box",
            mesh_data=ke.geometry.create_cube_data(scale=1.0),
            material=self.standard_materials.common,
            color=ke.Vec4(0.8, 0.3, 0.02, 1.0),
        )
        box.set_local_translation(translation=ke.Vec3(0.0, 2.0, 0.0))
        box.set_local_rotation_axis_angle(
            axis=ke.Vec3(0.0, 1.0, 0.0),
            angle_radians=np.deg2rad(25.0),
        )

The important separation is:

• ke.geometry.create_cube_data(...) creates mesh data only.

• app.scene.add_mesh(...) creates a scene prim and renderable view.

• The returned box view controls common rendering and transform operations.

• box.prim remains available for lower-level scene graph operations.

Parent and child transforms

An absolute prim path establishes hierarchy. /box/box2 is a child of /box, so its local transform is relative to the first box.

box2: ke.RenderablePrimView = self.scene.add_mesh(
    path="/box/box2",
    mesh_data=ke.geometry.create_cube_data(scale=1.0),
    material=self.standard_materials.common,
)
box2.set_local_translation(translation=ke.Vec3(0.0, 1.5, 0.0))
box2.set_local_scale(scale=ke.Vec3(0.5, 0.5, 0.5))

local_position = box2.get_local_translation()
world_position = box2.get_world_translation()

Use set_world_translation(...) when a value is already expressed in scene coordinates. Otherwise, prefer local transforms so children follow their parent naturally.

Quaternion ordering

ke.Quat and NumPy inputs to quaternion object APIs use wxyz ordering.

# Approximately 45 degrees around Z, in wxyz order.
box2.set_local_rotation(
    np.array([0.924, 0.0, 0.0, 0.383], dtype=np.float32)
)

rotation = box2.get_world_rotation()
rotation_wxyz = rotation.to_wxyz()
rotation_xyzw = rotation.to_xyzw()

Physics and simulation state arrays named rot_xyzw retain xyzw ordering. Use ke.Quat.from_xyzw(...) when moving such a value into a scene quaternion API.

Inspect transform axes

For a lightweight render overlay that does not create a scene prim:

self.debug_overlay.axes(
    "/debug/world_axes",
    origin=np.array([0.0, 1.0, 0.0]),
    rotation=np.eye(3),
    length=1.0,
)

To create axes that appear in the SceneGraph, use the scene-backed helper:

self.scene.debug_geometry.add_axes(
    "/debug/box2_axes",
    box2.get_world_translation(),
    box2.get_world_rotation(),
    length=0.8,
    radius=0.01,
)

debug_overlay draws directly through the graphics debug renderer and does not create scene prims. scene.debug_geometry creates mesh-based renderables that appear in the SceneGraph and returns a DebugPrimitiveView.

Run the complete example:

python ./python/examples/render_prim_scene.py

Complete source: render_prim_scene.py

"""
Render Prim Scene — Python equivalent of test_prim_scene.cpp.
Demonstrates the material-first Prim scene graph.
"""

import numpy as np

import kangengine as ke


class MyApp(ke.App):
    def setup(self):
        self.standard_materials = self.create_standard_materials()

        self.debug_overlay.axes(
            "/debug/box_axes",  # is not shown in the scene graph.
            origin=np.array([0.0, 1.0, 0.0]),
            rotation=np.eye(3),
            length=1.0,
            width=5.0,
        )

        # Ground plane (Y-up)
        self.scene.add_ground("/ground", scale=30.0)

        # Box
        box = self.scene.add_mesh(
            "/box",
            ke.geometry.create_cube_data(1.0),
            self.standard_materials.common,
            color=ke.Vec4(0.8, 0.3, 0.02, 1.0),
        )
        box.set_local_translation(ke.Vec3(0.0, 2.0, 0.0))
        box.set_local_rotation_axis_angle(ke.Vec3(0.0, 1.0, 0.0), np.deg2rad(25.0))

        # Box2
        box2 = self.scene.add_mesh(
            "/box/box2",
            ke.geometry.create_cube_data(1.0),
            self.standard_materials.common,
            color=ke.Vec4(0.3, 0.3, 0.02, 1.0),
        )
        box2.set_local_translation(ke.Vec3(0.0, 1.5, 0.0))
        box2.set_local_rotation(np.array([0.924, 0, 0, 0.383]))
        box2.set_local_scale(ke.Vec3(0.5, 0.5, 0.5))

        w_trans = box2.get_world_translation()
        w_ori = box2.get_world_rotation()
        self.scene.debug_geometry.add_axes(
            "/debug/box2_axes",
            w_trans,
            w_ori,
            length=0.8,
            radius=0.01,
            segments=8,
        )
        # self.scene.remove_prim("/debug/box2_axes")

        print(box2.get_local_translation())
        print(box2.get_local_rotation())
        print(box2.get_local_rotation().to_wxyz())
        print(box2.get_local_rotation().to_xyzw())
        print(box2.get_world_translation())
        print(np.array(w_ori))
        # box2.remove()

        # Sphere
        sphere = self.scene.add_mesh(
            "/sphere",
            ke.geometry.create_sphere_data(0.5, 16, 12),
            self.standard_materials.common,
            color=ke.Vec4(0.2, 0.4, 0.9, 1.0),
        )
        sphere.set_local_translation(ke.Vec3(2.5, 0.5, 0.0))

        self.check_error()

    def pre_render(self):
        self.check_error()

    def render(self):
        pass

    def post_render(self):
        pass


if __name__ == "__main__":
    app = MyApp()
    app.initialize(1920, 1080, False, ke.UpAxis.Y)
    app.start()

Next: First Simulation or Scene and Rendering.