# moderngl_window.scene

class moderngl_window.scene.Camera(fov: float = 60.0, aspect_ratio: float = 1.0, near: float = 1.0, far: float = 100.0)

  Simple camera class containing projection.

      # create a camera
      camera = Camera(fov=60.0, aspect_ratio=1.0, near=1.0, far=100.0)

      # Get the current camera matrix as numpy array
      print(camera.matrix)

      # Get projection matrix as numpy array
      print(camera.projection.matrix)

  look_at(vec: vec3 | None = None, pos: tuple[float, float, float] | None = None) → mat4x4

    Look at a specific point

    Either `vec` or `pos` needs to be supplied.

    Keyword Arguments:

      - vec (glm.vec3) – position

      - pos (tuple/list) – list of tuple `[x, y, x]` / `(x, y, x)`

    Returns:

      Camera matrix

    Return type:

      glm.mat4x4

  property matrix: mat4x4

    The current view matrix for the camera

    Type:

      glm.mat4

  property pitch: float

    The current pitch angle.

    Type:

      float

  property projection: Projection3D

    The 3D projection

    Type:

      `Projection3D`

  set_position(x: float, y: float, z: float) → None

    Set the 3D position of the camera.

    Parameters:

      - x (float) – x position

      - y (float) – y position

      - z (float) – z position

  set_rotation(yaw: float, pitch: float) → None

    Set the rotation of the camera.

    Parameters:

      - yaw (float) – yaw rotation

      - pitch (float) – pitch rotation

  property yaw: float

    The current yaw angle.

    Type:

      float

class moderngl_window.scene.KeyboardCamera(keys: ~moderngl_window.context.base.keys.BaseKeys, keymap: ~typing.Callable[[~moderngl_window.context.base.keys.BaseKeys], ~moderngl_window.utils.keymaps.KeyMap] = <function <lambda>>, fov: float = 60.0, aspect_ratio: float = 1.0, near: float = 1.0, far: float = 100.0)

  Bases: `Camera`

  Camera controlled by mouse and keyboard. The class interacts with the key constants in the built in window types.

  Creating a keyboard camera:

      camera = KeyboardCamera(
          self.wnd.keys,
          fov=75.0,
          aspect_ratio=self.wnd.aspect_ratio,
          near=0.1,
          far=1000.0,
      )

  We can also interact with the belonging `Projection3D` instance.

      # Update aspect ratio
      camera.projection.update(aspect_ratio=1.0)

      # Get projection matrix in bytes (f4)
      camera.projection.tobytes()

  key_input(key: str, action: str, modifiers: Any) → None

    Process key inputs and move camera

    Parameters:

      - key – The key

      - action – key action release/press

      - modifiers – key modifier states such as ctrl or shit

  property matrix: mat4x4

    The current view matrix for the camera

    Type:

      glm.mat4x4

  property mouse_sensitivity: float

    Mouse sensitivity (rotation speed).

    This property can also be set:

        camera.mouse_sensitivity = 2.5

    Type:

      float

  move_backward(activate: bool) → None

    The camera should be continiously moving backwards.

    Parameters:

      activate (bool) – Activate or deactivate this state

  move_down(activate: bool) → None

    The camera should be continiously moving down.

    Parameters:

      activate (bool) – Activate or deactivate this state

  move_forward(activate: bool) → None

    The camera should be continiously moving forward.

    Parameters:

      activate (bool) – Activate or deactivate this state

  move_left(activate: bool) → None

    The camera should be continiously moving to the left.

    Parameters:

      activate (bool) – Activate or deactivate this state

  move_right(activate: bool) → None

    The camera should be continiously moving to the right.

    Parameters:

      activate (bool) – Activate or deactivate this state

  move_state(direction: int, activate: bool) → None

    Set the camera position move state.

    Parameters:

      - direction – What direction to update

      - activate – Start or stop moving in the direction

  move_up(activate: bool) → None

    The camera should be continiously moving up.

    Parameters:

      activate (bool) – Activate or deactivate this state

  rot_state(dx: float, dy: float) → None

    Update the rotation of the camera.

    This is done by passing in the relative mouse movement change on x and y (delta x, delta y).

    In the past this method took the viewport position of the mouse. This does not work well when mouse exclusivity mode is enabled.

    Parameters:

      - dx – Relative mouse position change on x

      - dy – Relative mouse position change on y

  property velocity: float

    The speed this camera move based on key inputs

    The property can also be modified:

        camera.velocity = 5.0

    Type:

      float

class moderngl_window.scene.OrbitCamera(target: vec3 | tuple[float, float, float] = (0.0, 0.0, 0.0), radius: float = 2.0, angles: tuple[float, float] = (45.0, -45.0), **kwargs: Any)

  Bases: `Camera`

  Camera controlled by the mouse to pan around the target.

  The functions :py:function:`~camera.OrbitCamera.rot_state` and :py:function:`~camera.OrbitCamera.rot_state` are used to update the rotation and zoom.

  Creating a orbit camera:

      camera = OrbitCamera(
          target=(0., 0., 0.),
          radius=2.0
          fov=75.0,
          aspect_ratio=self.wnd.aspect_ratio,
          near=0.1,
          far=1000.0,
      )

  We can also interact with the belonging `Projection3D` instance.

      # Update aspect ratio
      camera.projection.update(aspect_ratio=1.0)

      # Get projection matrix in bytes (f4)
      camera.projection.tobytes()

  property angle_x: float

    camera angle x in degrees.

    This property can also be set::

      camera.angle_x = 45.

    Type:

      float

  property angle_y: float

    camera angle y in degrees.

    This property can also be set::

      camera.angle_y = 45.

    Type:

      float

  property matrix: mat4x4

    The current view matrix for the camera

    Type:

      glm.mat4

  property mouse_sensitivity: float

    Mouse sensitivity (rotation speed).

    This property can also be set::

      camera.mouse_sensitivity = 2.5

    Type:

      float

  rot_state(dx: float, dy: float) → None

    Update the rotation of the camera around the target point.

    This is done by passing relative mouse change in the x and y axis (delta x, delta y)

    Parameters:

      - dx – Relative mouse position change on x axis

      - dy – Relative mouse position change on y axis

  property zoom_sensitivity: float

    Mousewheel zooming sensitivity (zoom speed).

    This property can also be set::

      camera.zoom_sensitivity = 2.5

    Type:

      float

class moderngl_window.scene.Scene(name: str | None, **kwargs: Any)

  Generic scene

  apply_mesh_programs(mesh_programs: list[MeshProgram] | None = None, clear: bool = True) → None

    Applies mesh programs to meshes. If not mesh programs are passed in we assign default ones.

    Parameters:

      - mesh_programs (list) – List of mesh programs to assign

      - clear (bool) – Clear all assigned mesh programs

  calc_scene_bbox() → None

    Calculate scene bbox

  property ctx: Context

    The current context

    Type:

      moderngl.Context

  destroy() → None

    Destroys the scene data and vertex buffers

  draw(projection_matrix: mat4x4 | None, camera_matrix: mat4x4 | None, time: float = 0.0) → None

    Draw all the nodes in the scene.

    Parameters:

      - projection_matrix (ndarray) – projection matrix (bytes)

      - camera_matrix (ndarray) – camera_matrix (bytes)

      - time (float) – The current time

  draw_bbox(projection_matrix: mat4x4 | None = None, camera_matrix: mat4x4 | None = None, children: float = True, color: tuple[float, float, float] = (0.75, 0.75, 0.75)) → None

    Draw scene and mesh bounding boxes.

    Parameters:

      - projection_matrix (glm.mat4) – mat4 projection

      - camera_matrix (glm.mat4) – mat4 camera matrix

      - children (bool) – Will draw bounding boxes for meshes as well

      - color (tuple) – Color of the bounding boxes

  draw_wireframe(projection_matrix: mat4x4 | None = None, camera_matrix: mat4x4 | None = None, color: tuple[float, float, float, float] = (0.75, 0.75, 0.75, 1.0)) → None

    Render the scene in wireframe mode.

    Parameters:

      - projection_matrix (ndarray) – mat4 projection

      - camera_matrix (ndarray) – mat4 camera matrix

      - children (bool) – Will draw bounding boxes for meshes as well

      - color (tuple) – Color of the wireframes

  find_material(name: str | None = None) → Material | None

    Finds a `Material`

    Keyword Arguments:

      name (str) – Case sensitive material name

    Returns:

      A `Material` or `None`

  find_node(name: str | None = None) → Node | None

    Finds a `Node`

    Keyword Arguments:

      name (str) – Case sensitive name

    Returns:

      A `Node` or `None` if not found.

  get_center() → vec3

    Calculate the center of the scene using bounding boxes

  property matrix: mat4x4

    The current model matrix

    This property is settable.

    Type:

      glm.mat4x4

  prepare() → None

    prepare the scene for rendering.

    Calls `apply_mesh_programs()` assigning default meshprograms if needed and sets the model matrix.

  release() → None

    Destroys the scene data and vertex buffers

class moderngl_window.scene.Node(name: str | None = None, camera: Camera | None = None, mesh: Mesh | None = None, matrix: mat4x4 | None = None)

  A generic scene node containing a mesh or camera and/or a container for other nodes. Nodes and their children represents the scene tree.

  add_child(node: Node) → None

    Add a child to this node

    Parameters:

      node (Node) – Node to add as a child

  calc_global_bbox(view_matrix: mat4x4, bbox_min: vec3 | None, bbox_max: vec3 | None) → tuple[vec3, vec3]

    Recursive calculation of scene bbox.

    Keyword Arguments:

      - view_matrix (numpy.ndarray) – view matrix

      - bbox_min – min bbox values

      - bbox_max – max bbox values

  calc_model_mat(parent_matrix: mat4x4) → None

    Calculate the model matrix related to all parents.

    Parameters:

      parent_matrix – Matrix for parent node

  property camera: Camera | None

    The camera if present

    Type:

      `Camera`

  property children: list[Node]

    List of children

    Type:

      list

  draw(projection_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw node and children.

    Keyword Arguments:

      - projection_matrix – projection matrix

      - camera_matrix – camera_matrix

      - time – The current time

  draw_bbox(projection_matrix: mat4x4 | None, camera_matrix: mat4x4 | None, program: Program, vao: VAO) → None

    Draw bounding box around the node and children.

    Keyword Arguments:

      - projection_matrix – projection matrix

      - camera_matrix – camera_matrix

      - program (moderngl.Program) – The program to render the bbox

      - vao – The vertex array representing the bounding box

  draw_wireframe(projection_matrix: mat4x4 | None, camera_matrix: mat4x4 | None, program: Program) → None

    Render the node as wireframe.

    Keyword Arguments:

      - projection_matrix (bytes) – projection matrix

      - camera_matrix (bytes) – camera_matrix

      - program (moderngl.Program) – The program to render wireframe

  property matrix: mat4x4 | None

    Note matrix (local)

    Type:

      glm.mat4x4

  property matrix_global: mat4x4 | None

    The global node matrix containing transformations from parent nodes

    Type:

      glm.matx4

  property mesh: Mesh | None

    The mesh if present

    Type:

      `Mesh`

  property name: str | None

    Get or set the node name

    Type:

      str

class moderngl_window.scene.Mesh(name: str, vao: VAO | None = None, material: Material | None = None, attributes: dict[str, Any] | None = None, bbox_min: vec3 = vec3(0, 0, 0), bbox_max: vec3 = vec3(0, 0, 0))

  Mesh info and geometry

  add_attribute(attr_type: str, name: str, components: int) → None

    Add metadata about the mesh :param attr_type: POSITION, NORMAL etc :param name: The attribute name used in the program :param components: Number of floats

  calc_global_bbox(view_matrix: mat4x4, bbox_min: vec3 | None, bbox_max: vec3 | None) → tuple[vec3, vec3]

    Calculates the global bounding.

    Parameters:

      - view_matrix – View matrix

      - bbox_min – xyz min

      - bbox_max – xyz max

    Returns:

      Combined bbox

    Return type:

      bbox_min, bbox_max

  draw(projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw the mesh using the assigned mesh program

    Keyword Arguments:

      - projection_matrix (bytes) – projection_matrix

      - view_matrix (bytes) – view_matrix

      - camera_matrix (bytes) – camera_matrix

  draw_bbox(proj_matrix: mat4x4, model_matrix: mat4x4, cam_matrix: mat4x4, program: Program, vao: VAO) → None

    Renders the bounding box for this mesh.

    Parameters:

      - proj_matrix – Projection matrix

      - model_matrix – View/model matrix

      - cam_matrix – Camera matrix

      - program – The moderngl.Program rendering the bounding box

      - vao – The vao mesh for the bounding box

  draw_wireframe(proj_matrix: mat4x4, model_matrix: mat4x4, program: Program) → None

    Render the mesh as wireframe.

    proj_matrix: Projection matrix model_matrix: View/model matrix program: The moderngl.Program rendering the wireframe

  has_normals() → bool
    Returns:

      Does the mesh have a normals?

    Return type:

      bool

  has_uvs(layer: int = 0) → bool
    Returns:

      Does the mesh have texture coordinates?

    Return type:

      bool

class moderngl_window.scene.Material(name: str = '')

  Generic material

  property color: tuple[float, float, float, float]

    RGBA color

    Type:

      tuple[float, float, float, float]

  property double_sided: bool

    Material surface is double sided?

    Type:

      bool

  property mat_texture: MaterialTexture | None

    instance

    Type:

      MaterialTexture

  property name: str

    Name of the material

    Type:

      str

class moderngl_window.scene.MaterialTexture(texture: Texture | None = None, sampler: Sampler | None = None)

  Wrapper for textures used in materials. Contains a texture and a sampler object.

  property sampler: Sampler | None

    Sampler instance

    Type:

      moderngl.Sampler

  property texture: Texture | None

    Texture instance

    Type:

      moderngl.Texture

class moderngl_window.scene.MeshProgram(program: Program | None = None, **kwargs: Any)

  Describes how a mesh is rendered using a specific shader program

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  property ctx: Context

    The current context

    Type:

      moderngl.Context

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time

## Mesh Programs

class moderngl_window.scene.programs.VertexColorProgram(program: Program | None = None, **kwargs: Any)

  Bases: `MeshProgram`

  Vertex color program

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time

class moderngl_window.scene.programs.ColorLightProgram(program: Program | None = None, **kwargs: Any)

  Bases: `MeshProgram`

  Simple color program with light

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time

class moderngl_window.scene.programs.TextureProgram(program: Program | None = None, **kwargs: Any)

  Bases: `MeshProgram`

  Plan textured

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time

class moderngl_window.scene.programs.TextureVertexColorProgram(program: Program | None = None, **kwargs: Any)

  Bases: `MeshProgram`

  textured object with vertex color

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time

class moderngl_window.scene.programs.TextureLightProgram(program: Program | None = None, **kwargs: Any)

  Bases: `MeshProgram`

  Simple texture program

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time

class moderngl_window.scene.programs.TextureLightColorProgram

  Bases: `object`

class moderngl_window.scene.programs.FallbackProgram(program: Program | None = None, **kwargs: Any)

  Bases: `MeshProgram`

  Fallback program only rendering positions in white

  apply(mesh: Mesh) → MeshProgram | None

    Determine if this `MeshProgram` should be applied to the mesh. Can return self or some `MeshProgram` instance to support dynamic `MeshProgram` creation

    Parameters:

      mesh – The mesh to inspect

  draw(mesh: Mesh, projection_matrix: mat4x4, model_matrix: mat4x4, camera_matrix: mat4x4, time: float = 0.0) → None

    Draw code for the mesh

    Parameters:

      mesh (Mesh) – The mesh to render

    Keyword Arguments:

      - projection_matrix (numpy.ndarray) – projection_matrix (bytes)

      - model_matrix (numpy.ndarray) – view_matrix (bytes)

      - camera_matrix (numpy.ndarray) – camera_matrix (bytes)

      - time (float) – The current time