# moderngl_window.loaders

class moderngl_window.loaders.base.BaseLoader(meta: ResourceDescription)

  Bases: `object`

  Base loader class for all resources

  property ctx: Context

    ModernGL context

    Type:

      moderngl.Context

  file_extensions: list[list[str]] = []

    A list defining the file extensions accepted by this loader.

    Example:

        # Loader will match .xyz and .xyz.gz files.
        file_extensions = [
            ['.xyz'],
            ['.xyz', '.gz'],
        ]

  find_data(path: str | Path | None) → Path | None

    Find resource using data finders.

    This is mainly a shortcut method to simplify the task.

    Parameters:

      path – Path to resource

  find_program(path: str | Path | None) → Path | None

    Find resource using program finders.

    This is mainly a shortcut method to simplify the task.

    Parameters:

      path – Path to resource

  find_scene(path: str | Path | None) → Path | None

    Find resource using scene finders.

    This is mainly a shortcut method to simplify the task.

    Parameters:

      path – Path to resource

  find_texture(path: str | Path | None) → Path | None

    Find resource using texture finders.

    This is mainly a shortcut method to simplify the task.

    Parameters:

      path – Path to resource

  kind = 'unknown'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Any

    Loads a resource.

    When creating a loader this is the only method that needs to be implemented.

    Returns:

      The loaded resource

  classmethod supports_file(meta: ResourceDescription) → bool

    Check if the loader has a supported file extension.

    What extensions are supported can be defined in the `file_extensions` class attribute.

## Text

class moderngl_window.loaders.data.text.Loader(meta: ResourceDescription)

  Bases: `BaseLoader`

  file_extensions: list[list[str]] = [['.txt']]

    A list defining the file extensions accepted by this loader.

    Example:

        # Loader will match .xyz and .xyz.gz files.
        file_extensions = [
            ['.xyz'],
            ['.xyz', '.gz'],
        ]

  kind = 'text'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → str

    Load a file in text mode.

    Returns:

      The string contents of the file

    Return type:

      str

## JSON

class moderngl_window.loaders.data.json.Loader(meta: ResourceDescription)

  Bases: `BaseLoader`

  file_extensions: list[list[str]] = [['.json']]

    A list defining the file extensions accepted by this loader.

    Example:

        # Loader will match .xyz and .xyz.gz files.
        file_extensions = [
            ['.xyz'],
            ['.xyz', '.gz'],
        ]

  kind = 'json'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → dict[Any, Any]

    Load a file as json

    Returns:

      The json contents

    Return type:

      dict

## Binary

class moderngl_window.loaders.data.binary.Loader(meta: ResourceDescription)

  Bases: `BaseLoader`

  kind = 'binary'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → bytes

    Load a file in binary mode

    Returns:

      The bytes contents of the file

    Return type:

      bytes

## Program (Separate)

class moderngl_window.loaders.program.separate.Loader(meta: ResourceDescription)

  Bases: `BaseLoader`

  kind = 'separate'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Program | ComputeShader | ReloadableProgram

    Loads a shader program were each shader is a separate file.

    This detected and dictated by the `kind` in the `ProgramDescription`.

    Returns:

      The Program instance

    Return type:

      moderngl.Program

  meta: ProgramDescription

## Program (Single)

class moderngl_window.loaders.program.single.Loader(meta: ResourceDescription)

  Bases: `BaseLoader`

  kind = 'single'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Program

    Loads a shader program from a single glsl file.

    Each shader type is separated by preprocessors

    - VERTEX_SHADER

    - FRAGMENT_SHADER

    - GEOMETRY_SHADER

    - TESS_CONTROL_SHADER

    - TESS_EVALUATION_SHADER

    Example:

        #version 330

        #if defined VERTEX_SHADER

        in vec3 in_position;
        in vec2 in_texcoord_0;
        out vec2 uv0;

        void main() {
            gl_Position = vec4(in_position, 1);
            uv0 = in_texcoord_0;
        }

        #elif defined FRAGMENT_SHADER

        out vec4 fragColor;
        uniform sampler2D texture0;
        in vec2 uv0;

        void main() {
            fragColor = texture(texture0, uv0);
        }
        #endif

    Returns:

      The Program instance

    Return type:

      moderngl.Program

  meta: ProgramDescription

## GLTF2

class moderngl_window.loaders.scene.gltf2.Loader(meta: SceneDescription)

  Bases: `BaseLoader`

  Loader for GLTF 2.0 files

  file_extensions: list[list[str]] = [['.gltf'], ['.glb']]

    A list defining the file extensions accepted by this loader.

    Example:

        # Loader will match .xyz and .xyz.gz files.
        file_extensions = [
            ['.xyz'],
            ['.xyz', '.gz'],
        ]

  kind = 'gltf'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Scene

    Load a GLTF 2 scene including referenced textures.

    Returns:

      The scene instance

    Return type:

      Scene

  load_glb() → None

    Loads a binary gltf file parsing its contents

  load_gltf() → None

    Loads a gltf json file parsing its contents

  load_images() → None

    Load images referenced in gltf metadata

  load_materials() → None

    Load materials referenced in gltf metadata

  load_meshes() → None

    Load meshes referenced in gltf metadata

  load_node(meta: GLTFNode, parent: Node | None = None) → Node

    Load a single node

  load_nodes() → None

    Load nodes referenced in gltf metadata

  load_samplers() → None

    Load samplers referenced in gltf metadata

  load_textures() → None

    Load textures referenced in gltf metadata

  meta: SceneDescription
  supported_extensions: list[str] = ['KHR_draco_mesh_compression', 'KHR_materials_unlit']

    Supported GLTF extensions https://github.com/KhronosGroup/glTF/tree/master/extensions

## Wavefront / OBJ

class moderngl_window.loaders.scene.wavefront.Loader(meta: SceneDescription)

  Bases: `BaseLoader`

  Load wavefront/obj files

  file_extensions: list[list[str]] = [['.obj'], ['.obj', '.gz'], ['.bin']]

    A list defining the file extensions accepted by this loader.

    Example:

        # Loader will match .xyz and .xyz.gz files.
        file_extensions = [
            ['.xyz'],
            ['.xyz', '.gz'],
        ]

  kind = 'wavefront'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Scene

    Loads a wavefront/obj file including materials and textures

    Returns:

      The Scene instance

    Return type:

      Scene

  meta: SceneDescription

## STL

class moderngl_window.loaders.scene.stl.Loader(meta: ResourceDescription)

  Bases: `BaseLoader`

  file_extensions: list[list[str]] = [['.stl'], ['.stl', '.gz']]

    A list defining the file extensions accepted by this loader.

    Example:

        # Loader will match .xyz and .xyz.gz files.
        file_extensions = [
            ['.xyz'],
            ['.xyz', '.gz'],
        ]

  kind = 'stl'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Scene

    Loads and stl scene/file

    Returns:

      The Scene instance

    Return type:

      Scene

## TextureArray

class moderngl_window.loaders.texture.array.Loader(meta: ResourceDescription)

  Bases: `PillowLoader`

  kind = 'array'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → TextureArray

    Load a texture array as described by the supplied `TextureDescription``

    Returns:

      The TextureArray instance

    Return type:

      moderngl.TextureArray

  meta: TextureDescription

## TextureCube

class moderngl_window.loaders.texture.cube.Loader(meta: ResourceDescription)

  Bases: `PillowLoader`

  kind = 'cube'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → TextureCube

    Load a texture cube as described by the supplied `TextureDescription``

    Returns:

      The TextureArray instance

    Return type:

      moderngl.TextureCube

  meta: TextureDescription

## Icon

class moderngl_window.loaders.texture.icon.IconLoader(meta: ResourceDescription)

  Bases: `BaseLoader`

  find_icon() → Path

    Find resource using texture finders.

    This is mainly a shortcut method to simplify the task.

    Parameters:

      path – Path to resource

  kind = 'icon'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  meta: TextureDescription

## Texture2D

class moderngl_window.loaders.texture.t2d.Loader(meta: ResourceDescription)

  Bases: `PillowLoader`

  kind = '2d'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Texture

    Load a 2d texture as configured in the supplied `TextureDescription`

    Returns:

      The Texture instance

    Return type:

      moderngl.Texture

## Pillow

class moderngl_window.loaders.texture.pillow.PillowLoader(meta: ResourceDescription)

  Bases: `BaseLoader`

  Base loader using PIL/Pillow

  image: Image
  kind = '__unknown__'

    The kind of resource this loaded supports. This can be used when file extensions is not enough to decide what loader should be selected.

  load() → Texture | TextureArray | TextureCube | Texture3D

    Loads a resource.

    When creating a loader this is the only method that needs to be implemented.

    Returns:

      The loaded resource

  meta: TextureDescription