# Spec: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#asset
from __future__ import annotations
import base64
import io
import json
import logging
import struct
from collections import namedtuple
from pathlib import Path
from typing import Any, Optional, Union
import glm
import moderngl
import numpy
import numpy.typing as npt
from PIL import Image
import moderngl_window
from moderngl_window.exceptions import ImproperlyConfigured
from moderngl_window.loaders.base import BaseLoader
from moderngl_window.loaders.texture import t2d
from moderngl_window.meta import SceneDescription, TextureDescription
from moderngl_window.opengl.vao import VAO
from moderngl_window.scene import Material, MaterialTexture, Mesh, Node, Scene
logger = logging.getLogger(__name__)
GLTF_MAGIC_HEADER = b"glTF"
# Texture wrap values
REPEAT = 10497
CLAMP_TO_EDGE = 33071
MIRRORED_REPEAT = 33648
# numpy dtype mapping
NP_COMPONENT_DTYPE = {
5121: numpy.uint8, # GL_UNSIGNED_BYTE
5123: numpy.uint16, # GL_UNSIGNED_SHORT
5125: numpy.uint32, # GL_UNSIGNED_INT
5126: numpy.float32, # GL_FLOAT
}
ComponentType = namedtuple("ComponentType", ["name", "value", "size"])
COMPONENT_TYPE = {
5120: ComponentType("BYTE", 5120, 1),
5121: ComponentType("UNSIGNED_BYTE", 5121, 1),
5122: ComponentType("SHORT", 5122, 2),
5123: ComponentType("UNSIGNED_SHORT", 5123, 2),
5125: ComponentType("UNSIGNED_INT", 5125, 4),
5126: ComponentType("FLOAT", 5126, 4),
}
# dtype to moderngl buffer format
DTYPE_BUFFER_TYPE = {
numpy.uint8: "u1", # GL_UNSIGNED_BYTE
numpy.uint16: "u2", # GL_UNSIGNED_SHORT
numpy.uint32: "u4", # GL_UNSIGNED_INT
numpy.float32: "f4", # GL_FLOAT
}
ACCESSOR_TYPE = {
"SCALAR": 1,
"VEC2": 2,
"VEC3": 3,
"VEC4": 4,
}
[docs]
class Loader(BaseLoader):
"""Loader for GLTF 2.0 files"""
kind = "gltf"
file_extensions = [
[".gltf"],
[".glb"],
]
#: Supported GLTF extensions
#: https://github.com/KhronosGroup/glTF/tree/master/extensions
supported_extensions: list[str] = [
"KHR_draco_mesh_compression",
"KHR_materials_unlit",
]
meta: SceneDescription
def __init__(self, meta: SceneDescription):
"""Initialize loading GLTF 2 scene.
Supported formats:
- gltf json format with external resources
- gltf embedded buffers
- glb Binary format
"""
super().__init__(meta)
self.scenes: list[Scene] = []
self.nodes: list[Node] = []
self.meshes: list[list[Mesh]] = []
self.materials: list[Material] = []
self.images: list[moderngl.Texture] = []
self.samplers: list[moderngl.Sampler] = []
self.textures: list[MaterialTexture] = []
self.path: Optional[Path] = None
self.scene: Scene
self.gltf: GLTFMeta
[docs]
def load(self) -> Scene:
"""Load a GLTF 2 scene including referenced textures.
Returns:
Scene: The scene instance
"""
assert self.meta.path is not None, "The path to this resource is empty"
self.path = self.find_scene(self.meta.path)
if not self.path:
raise ImproperlyConfigured("Scene '{}' not found".format(self.meta.path))
self.scene = Scene(str(self.path))
# Load gltf json file
if self.path.suffix == ".gltf":
self.load_gltf()
# Load binary gltf file
if self.path.suffix == ".glb":
self.load_glb()
assert self.gltf is not None, "There is a problem with your file, could not load gltf"
self.gltf.check_version()
self.gltf.check_extensions(self.supported_extensions)
self.load_images()
self.load_samplers()
self.load_textures()
self.load_materials()
self.load_meshes()
self.load_nodes()
self.scene.calc_scene_bbox()
self.scene.prepare()
return self.scene
[docs]
def load_gltf(self) -> None:
"""Loads a gltf json file parsing its contents"""
with open(str(self.path)) as fd:
self.gltf = GLTFMeta(str(self.path), json.load(fd), self.meta)
[docs]
def load_glb(self) -> None:
"""Loads a binary gltf file parsing its contents"""
with open(str(self.path), "rb") as fd:
# Check header
magic = fd.read(4)
if magic != GLTF_MAGIC_HEADER:
raise ValueError(
"{} has incorrect header {!r} != {!r}".format(
self.path, magic, GLTF_MAGIC_HEADER
)
)
version = struct.unpack("<I", fd.read(4))[0]
if version != 2:
raise ValueError(f"{self.path} has unsupported version {version}")
# Total file size including headers
_ = struct.unpack("<I", fd.read(4))[0] # noqa
# Chunk 0 - json
chunk_0_length = struct.unpack("<I", fd.read(4))[0]
chunk_0_type = fd.read(4)
if chunk_0_type != b"JSON":
raise ValueError(
"Expected JSON chunk, not {!r} in file {}".format(chunk_0_type, self.path)
)
json_meta = fd.read(chunk_0_length).decode()
# chunk 1 - binary buffer
chunk_1_length = struct.unpack("<I", fd.read(4))[0]
chunk_1_type = fd.read(4)
if chunk_1_type != b"BIN\x00":
raise ValueError(
"Expected BIN chunk, not {!r} in file {}".format(chunk_1_type, self.path)
)
self.gltf = GLTFMeta(
str(self.path),
json.loads(json_meta),
self.meta,
binary_buffer=fd.read(chunk_1_length),
)
[docs]
def load_images(self) -> None:
"""Load images referenced in gltf metadata"""
for image in self.gltf.images:
self.images.append(image.load(self.path.parent))
[docs]
def load_samplers(self) -> None:
"""Load samplers referenced in gltf metadata"""
for sampler in self.gltf.samplers:
# Use a sane default sampler if the sampler data is empty
# Samplers can simply just be json data: "{}"
if sampler.minFilter is sampler.magFilter is None:
self.samplers.append(
self.ctx.sampler(
filter=(moderngl.LINEAR_MIPMAP_LINEAR, moderngl.LINEAR),
repeat_x=False,
repeat_y=False,
anisotropy=16.0,
)
)
else:
self.samplers.append(
self.ctx.sampler(
filter=(sampler.minFilter, sampler.magFilter),
repeat_x=sampler.wrapS in [REPEAT, MIRRORED_REPEAT],
repeat_y=sampler.wrapT in [REPEAT, MIRRORED_REPEAT],
anisotropy=16.0,
)
)
[docs]
def load_textures(self) -> None:
"""Load textures referenced in gltf metadata"""
for texture_meta in self.gltf.textures:
texture = MaterialTexture()
if texture_meta.source is not None:
texture.texture = self.images[texture_meta.source]
if texture_meta.sampler is not None:
texture.sampler = self.samplers[texture_meta.sampler]
self.textures.append(texture)
[docs]
def load_meshes(self) -> None:
"""Load meshes referenced in gltf metadata"""
for meta_mesh in self.gltf.meshes:
# Returns a list of meshes
meshes = meta_mesh.load(self.materials)
self.meshes.append(meshes)
for mesh in meshes:
self.scene.meshes.append(mesh)
[docs]
def load_materials(self) -> None:
"""Load materials referenced in gltf metadata"""
# Create material objects
for meta_mat in self.gltf.materials:
mat = Material(meta_mat.name)
mat.color = meta_mat.baseColorFactor or (1.0, 1.0, 1.0, 1.0)
mat.double_sided = meta_mat.doubleSided
if meta_mat.baseColorTexture is not None:
mat.mat_texture = self.textures[meta_mat.baseColorTexture["index"]]
self.materials.append(mat)
self.scene.materials.append(mat)
[docs]
def load_nodes(self) -> None:
"""Load nodes referenced in gltf metadata"""
# Start with root nodes in the scene
for node_id in self.gltf.scenes[0].nodes:
node = self.load_node(self.gltf.nodes[node_id])
self.scene.root_nodes.append(node)
[docs]
def load_node(self, meta: GLTFNode, parent: Optional[Node] = None) -> Node:
"""Load a single node"""
# Create the node
node = Node(name=meta.name, matrix=meta.matrix)
self.scene.nodes.append(node)
if meta.mesh is not None:
# Since we split up meshes with multiple primitives, this can be a list
# If only one mesh we set it on the node as normal
if len(self.meshes[meta.mesh]) == 1:
node.mesh = self.meshes[meta.mesh][0]
# If multiple meshes we add them as new child node
elif len(self.meshes[meta.mesh]) > 1:
for mesh in self.meshes[meta.mesh]:
node.add_child(Node(mesh=mesh))
if meta.camera is not None:
# FIXME: Use a proper camera class
node.camera = self.gltf.cameras[meta.camera]
if parent:
parent.add_child(node)
# Follow children
if meta.has_children:
for node_id in meta.children:
self.load_node(self.gltf.nodes[node_id], parent=node)
return node
class GLTFMeta:
"""Container for gltf metadata"""
def __init__(
self,
path: Union[Path, str],
data: dict[Any, Any],
meta: SceneDescription,
binary_buffer: Optional[bytes] = None,
) -> None:
"""
:param file: GLTF file name loaded
:param data: Metadata (json loaded)
:param binary_buffer: Binary buffer when loading glb files
"""
self.path = Path(path) if isinstance(path, str) else path
self.data = data
self.meta = meta
self.asset = GLTFAsset(data["asset"])
self.materials = (
[GLTFMaterial(m) for m in data["materials"]] if data.get("materials") else []
)
self.images = [GLTFImage(i) for i in data["images"]] if data.get("images") else []
self.samplers = [GLTFSampler(s) for s in data["samplers"]] if data.get("samplers") else []
self.textures = [GLTFTexture(t) for t in data["textures"]] if data.get("textures") else []
self.scenes = [GLTFScene(s) for s in data["scenes"]] if data.get("scenes") else []
self.nodes = [GLTFNode(n) for n in data["nodes"]] if data.get("nodes") else []
self.meshes = [GLTFMesh(m, self.meta) for m in data["meshes"]] if data.get("meshes") else []
self.cameras = [GLTFCamera(c) for c in data["cameras"]] if data.get("cameras") else []
self.buffer_views = (
[GLTFBufferView(i, v) for i, v in enumerate(data["bufferViews"])]
if data.get("bufferViews")
else []
)
self.buffers = (
[GLTFBuffer(i, b, self.path.parent) for i, b in enumerate(data["buffers"])]
if data.get("buffers")
else []
)
self.accessors = (
[GLTFAccessor(i, a) for i, a in enumerate(data["accessors"])]
if data.get("accessors")
else []
)
# glb files can contain buffer 0 data
if binary_buffer:
self.buffers[0].data = binary_buffer
self._link_data()
self.buffers_exist()
self.images_exist()
def _link_data(self) -> None:
"""Add references"""
# accessors -> buffer_views -> buffers
for acc in self.accessors:
acc.bufferView = self.buffer_views[acc.bufferViewId]
for buffer_view in self.buffer_views:
buffer_view.buffer = self.buffers[buffer_view.bufferId]
# Link accessors to mesh primitives
for mesh in self.meshes:
for primitive in mesh.primitives:
# Link the bufferview for draco compressed buffers
if primitive.extensions.get("KHR_draco_mesh_compression"):
ext = primitive.extensions["KHR_draco_mesh_compression"]
buffer_view_id = ext["bufferView"]
ext["bufferView"] = self.buffer_views[buffer_view_id]
if primitive.indices is not None:
primitive.accessor = self.accessors[primitive.indices]
for name, value in primitive.attributes.items():
primitive.attributes[name] = self.accessors[value]
# Link buffer views to images
for image in self.images:
if image.bufferViewId is not None:
image.bufferView = self.buffer_views[image.bufferViewId]
@property
def version(self) -> str:
return self.asset.version
def check_version(self, required: str = "2.0") -> None:
if not self.version == required:
msg = (
f"GLTF Format version is not 2.0. Version states '{self.version}' "
f"in file {self.path}"
)
raise ValueError(msg)
def check_extensions(self, supported: list[str]) -> None:
"""
"extensionsRequired": ["KHR_draco_mesh_compression"],
"extensionsUsed": ["KHR_draco_mesh_compression"]
"""
extReq = self.data.get("extensionsRequired")
if extReq is not None:
for ext in extReq:
if ext not in supported:
raise ValueError(f"Extension '{ext}' not supported")
extUse = self.data.get("extensionsUsed")
if extUse is not None:
for ext in extUse:
if ext not in supported:
raise ValueError(f"Extension '{ext}' not supported")
def buffers_exist(self) -> None:
"""Checks if the bin files referenced exist"""
for buff in self.buffers:
if not buff.is_separate_file:
continue
path = self.path.parent / buff.uri
if not path.exists():
raise FileNotFoundError(
f"Buffer {path} referenced in {self.path} not found"
)
def images_exist(self) -> None:
"""checks if the images references in textures exist"""
pass
class GLTFAsset:
"""Asset Information"""
def __init__(self, data: dict[str, Any]):
self.version = data.get("version")
self.generator = data.get("generator")
self.copyright = data.get("copyright")
class GLTFMesh:
class Primitives:
def __init__(self, data: dict[str, Any]):
self.attributes: dict[str, Any] = data.get("attributes")
self.indices: int = data.get("indices")
self.mode: int = data.get("mode")
self.material = data.get("material")
self.extensions = data.get("extensions", {})
self.accessor: GLTFAccessor
def __init__(self, data: dict[str, Any], meta: SceneDescription):
self.meta = meta
self.name = data.get("name", "")
self.primitives = [GLTFMesh.Primitives(p) for p in data["primitives"]]
def load(self, materials: list[Material]) -> list[Mesh]:
name_map = {
"POSITION": self.meta.attr_names.POSITION,
"NORMAL": self.meta.attr_names.NORMAL,
"TEXCOORD_0": self.meta.attr_names.TEXCOORD_0,
"TANGENT": self.meta.attr_names.TANGENT,
"JOINTS_0": self.meta.attr_names.JOINTS_0,
"WEIGHTS_0": self.meta.attr_names.WEIGHTS_0,
"COLOR_0": self.meta.attr_names.COLOR_0,
}
ctx = moderngl_window.ctx()
meshes: list[Mesh] = []
# FIXME: Split this up in methods
# Read all primitives as separate meshes for now
# According to the spec they can have different materials and vertex format
for primitive in self.primitives:
# Handle draco compressed meshes
if primitive.extensions.get("KHR_draco_mesh_compression"):
buffer_view = primitive.extensions["KHR_draco_mesh_compression"]["bufferView"]
data = buffer_view.read_raw()
try:
import DracoPy
except ImportError:
raise ImportError("DracoPy is required to load draco compressed meshes")
mesh = DracoPy.decode(data)
attributes = {
'POSITION': {
'name': name_map["POSITION"],
'components': 3,
'type': 5126,
}
}
vao = VAO(self.name, mode=primitive.mode or moderngl.TRIANGLES)
if mesh.faces is not None and mesh.faces.any():
vao.index_buffer(ctx.buffer(mesh.faces.astype("i4")))
vao.buffer(mesh.points.astype("f4"), "3f", name_map["POSITION"])
if mesh.tex_coord is not None and mesh.tex_coord.any():
vao.buffer(
ctx.buffer(mesh.tex_coord.astype("f4")),
"2f",
name_map["TEXCOORD_0"],
)
attributes["TEXCOORD_0"] = {
'name': name_map["TEXCOORD_0"],
'components': 2,
'type': 5126,
}
if mesh.normals is not None and mesh.normals.any():
vao.buffer(ctx.buffer(mesh.normals.astype("f4")), "3f", name_map["NORMAL"])
attributes["NORMAL"] = {
'name': name_map["NORMAL"],
'components': 3,
'type': 5126,
}
if mesh.colors is not None and mesh.colors.any():
vao.buffer(ctx.buffer(mesh.colors.astype("f4")), "4f", name_map["COLOR_0"])
attributes["COLOR_0"] = {
'name': name_map["COLOR_0"],
'components': 4,
'type': 5126,
}
bbox_min, bbox_max = self.get_bbox(primitive)
meshes.append(
Mesh(
self.name,
vao=vao,
attributes=attributes,
material=(
materials[primitive.material]
if primitive.material is not None else None
),
bbox_min=bbox_min,
bbox_max=bbox_max,
)
)
else:
vao = VAO(self.name, mode=primitive.mode or moderngl.TRIANGLES)
# Index buffer
component_type, index_vbo = self.load_indices(primitive)
if index_vbo is not None:
vao.index_buffer(
ctx.buffer(index_vbo.tobytes()),
index_element_size=component_type.size,
)
attributes = {}
vbos = self.prepare_attrib_mapping(primitive)
for vbo_info in vbos:
dtype, buffer = vbo_info.create()
vao.buffer(
buffer,
" ".join(
[
"{}{}".format(attr[1], DTYPE_BUFFER_TYPE[dtype])
for attr in vbo_info.attributes
]
),
[name_map[attr[0]] for attr in vbo_info.attributes],
)
for attr in vbo_info.attributes:
attributes[attr[0]] = {
"name": name_map[attr[0]],
"components": attr[1],
"type": vbo_info.component_type.value,
}
bbox_min, bbox_max = self.get_bbox(primitive)
meshes.append(
Mesh(
self.name,
vao=vao,
attributes=attributes,
material=(
materials[primitive.material]
if primitive.material is not None else None
),
bbox_min=bbox_min,
bbox_max=bbox_max,
)
)
return meshes
def load_indices(
self, primitive: Primitives
) -> tuple[ComponentType, npt.NDArray[Any]] | tuple[None, None]:
"""Loads the index buffer / polygon list for a primitive"""
if primitive.indices is None or primitive.accessor is None:
return None, None
_, component_type, buffer = primitive.accessor.read()
return component_type, buffer
def prepare_attrib_mapping(self, primitive: Primitives) -> list[VBOInfo]:
"""Pre-parse buffer mappings for each VBO to detect interleaved data for a primitive"""
buffer_info: list[VBOInfo] = []
for name, accessor in primitive.attributes.items():
info = VBOInfo(*accessor.info())
info.attributes.append((name, info.components))
if buffer_info and buffer_info[-1].buffer_view == info.buffer_view:
if buffer_info[-1].interleaves(info):
buffer_info[-1].merge(info)
continue
buffer_info.append(info)
return buffer_info
def get_bbox(self, primitive: Primitives) -> tuple[glm.vec3, glm.vec3]:
"""Get the bounding box for the mesh"""
accessor = primitive.attributes.get("POSITION")
return glm.vec3(accessor.min), glm.vec3(accessor.max)
class VBOInfo:
"""Resolved data about each VBO"""
def __init__(
self,
buffer: Optional[GLTFBuffer] = None,
buffer_view: Optional[GLTFBuffer] = None,
byte_length: int = 0,
byte_offset: int = 0,
component_type: ComponentType = ComponentType("", 0, 0),
components: int = 0,
count: int = 0,
):
self.buffer = buffer # reference to the buffer
self.buffer_view = buffer_view
self.byte_length = byte_length # Raw byte buffer length
self.byte_offset = byte_offset # Raw byte offset
self.component_type = component_type # Datatype of each component
self.components = components
self.count = count # number of elements of the component type size
# list of (name, components) tuples
self.attributes: list[Any] = []
def interleaves(self, info: VBOInfo) -> bool:
"""Does the buffer interleave with this one?"""
return bool(info.byte_offset == (self.component_type.size * self.components))
def merge(self, info: VBOInfo) -> None:
# NOTE: byte length is the same
self.components += info.components
self.attributes += info.attributes
def create(self) -> tuple[type[object], npt.NDArray[Any]]:
"""Create the VBO"""
assert self.buffer is not None, "No buffer defined"
dtype = NP_COMPONENT_DTYPE[self.component_type.value]
data = numpy.frombuffer(
self.buffer.read(byte_length=self.byte_length, byte_offset=self.byte_offset),
count=self.count * self.components,
dtype=dtype,
)
return dtype, data
def __str__(self) -> str:
assert self.buffer is not None, "No buffer defined"
assert self.buffer_view is not None, "No buffer_view defined"
return (
"VBOInfo<buffer={}, buffer_view={},\n"
" length={}, offset={}, count={}\n"
" component_type={}, components={}, \n"
" attribs={}".format(
self.buffer.id,
self.buffer_view.id,
self.byte_length,
self.byte_offset,
self.count,
self.component_type.value,
self.components,
self.attributes,
)
)
def __repr__(self) -> str:
return str(self)
class GLTFAccessor:
def __init__(self, accessor_id: int, data: dict[str, Any]):
self.id = accessor_id
self.bufferViewId = data.get("bufferView", 0)
self.bufferView: GLTFBufferView
self.byteOffset = data.get("byteOffset", 0)
self.componentType = COMPONENT_TYPE[data["componentType"]]
self.count = data.get("count", 1)
self.type: str = data.get("type", "")
self.min = numpy.array(data.get("min") or [-0.5, -0.5, -0.5], dtype="f4")
self.max = numpy.array(data.get("max") or [0.5, 0.5, 0.5], dtype="f4")
def read(self) -> tuple[int, ComponentType, npt.NDArray[Any]]:
"""
Reads buffer data
Return:
component count, component type, data
"""
# ComponentType helps us determine the datatype
dtype = NP_COMPONENT_DTYPE[self.componentType.value]
return (
ACCESSOR_TYPE[self.type],
self.componentType,
self.bufferView.read(
byte_offset=self.byteOffset,
dtype=dtype,
count=self.count * ACCESSOR_TYPE[self.type],
),
)
def read_raw(self) -> bytes:
"""
Read the raw bytes. Useful for draco compressed meshes or any data that
is not a simple vertex buffer.
"""
return self.bufferView.read_raw(byte_offset=self.byteOffset)
def info(self) -> tuple[GLTFBuffer, GLTFBufferView, int, int, ComponentType, int, int]:
"""
Get underlying buffer info for this accessor
Return:
buffer, byte_length, byte_offset, component_type, count
"""
buffer, byte_length, byte_offset = self.bufferView.info(byte_offset=self.byteOffset)
return (
buffer,
self.bufferView,
byte_length,
byte_offset,
self.componentType,
ACCESSOR_TYPE[self.type],
self.count,
)
def __str__(self) -> str:
return "Accessor<id={}, bufferView={}, byteOffset={}, componentType={}, count={}>".format(
self.id, self.bufferViewId, self.byteOffset, self.componentType.name, self.count
)
class GLTFBufferView:
def __init__(self, view_id: int, data: dict[str, Any]):
self.id = view_id
self.bufferId = data.get("buffer", 0)
self.buffer: GLTFBuffer
self.byteOffset = data.get("byteOffset", 0)
self.byteLength = data.get("byteLength", 0)
self.byteStride = data.get("byteStride", 0)
# Valid: 34962 (ARRAY_BUFFER) and 34963 (ELEMENT_ARRAY_BUFFER) or None
def read(
self, byte_offset: int = 0, dtype: Optional[type[object]] = None, count: int = 0
) -> npt.NDArray[Any]:
data = self.buffer.read(
byte_offset=byte_offset + self.byteOffset,
byte_length=self.byteLength,
)
vbo = numpy.frombuffer(data, count=count, dtype=dtype)
return vbo
def read_raw(self, byte_offset: int = 0) -> bytes:
return self.buffer.read(
byte_offset=self.byteOffset + byte_offset,
byte_length=self.byteLength,
)
def info(self, byte_offset: int = 0) -> tuple[GLTFBuffer, int, int]:
"""
Get the underlying buffer info
:param byte_offset: byte offset from accessor
:return: buffer, byte_length, byte_offset
"""
return self.buffer, self.byteLength, byte_offset + self.byteOffset
def __str__(self) -> str:
return "BufferView<id={}, buffer={}, byteOffset={}, byteLength={}>".format(
self.id, self.bufferId, self.byteOffset, self.byteLength
)
class GLTFBuffer:
def __init__(self, buffer_id: int, data: dict[str, str], path: Path):
self.id = buffer_id
self.path = path
self.byteLength = data.get("byteLength")
uri = data.get("uri")
if uri is None:
uri = ""
self.uri = uri
self.data = b""
@property
def has_data_uri(self) -> bool:
"""Is data embedded in json?"""
if self.uri == "":
return False
return self.uri.startswith("data:")
@property
def is_separate_file(self) -> bool:
"""Buffer represents an independent bin file?"""
return self.uri is not None and not self.has_data_uri
def open(self) -> None:
if self.data != b"":
return
if self.has_data_uri:
self.data = base64.b64decode(self.uri[self.uri.find(",") + 1 :])
return
with open(str(self.path / (self.uri if self.uri is not None else "")), "rb") as fd:
self.data = fd.read()
def read(self, byte_offset: int = 0, byte_length: int = 0) -> bytes:
self.open()
return self.data[byte_offset : byte_offset + byte_length]
class GLTFScene:
def __init__(self, data: dict[str, list[int]]):
self.nodes = data["nodes"]
class GLTFNode:
def __init__(self, data: dict[str, Any]) -> None:
self.name = data.get("name")
self.children = data.get("children")
self.mesh = data.get("mesh")
self.camera = data.get("camera")
_matrix = data.get("matrix")
self.matrix = glm.mat4(*_matrix) if _matrix is not None else glm.mat4()
self.translation = data.get("translation")
self.rotation = data.get("rotation")
self.scale = data.get("scale")
if self.translation is not None:
self.matrix = glm.translate(self.matrix, glm.vec3(*self.translation))
if self.rotation is not None:
quat = glm.quat(
x=self.rotation[0],
y=self.rotation[1],
z=self.rotation[2],
w=self.rotation[3],
)
self.matrix = self.matrix * glm.mat4_cast(quat)
if self.scale is not None:
self.matrix = glm.scale(self.matrix, glm.vec3(*self.scale))
@property
def has_children(self) -> bool:
return self.children is not None and len(self.children) > 0
@property
def is_resource_node(self) -> bool:
"""Is this just a reference node to a resource?"""
return self.camera is not None or self.mesh is not None
class GLTFMaterial:
def __init__(self, data: dict[str, Any]):
self.name = data.get("name")
# Defaults to true if not defined
self.doubleSided = data.get("doubleSided") or True
pbr = data["pbrMetallicRoughness"]
self.baseColorFactor = pbr.get("baseColorFactor")
self.baseColorTexture = pbr.get("baseColorTexture")
self.metallicFactor = pbr.get("metallicFactor")
self.emissiveFactor = data.get("emissiveFactor")
class GLTFImage:
"""
Represent texture data.
May be a file, embedded data or pointer to data in bufferview
"""
def __init__(self, data: dict[str, Any]):
self.uri = data.get("uri")
self.bufferViewId = data.get("bufferView")
self.bufferView = None
self.mimeType = data.get("mimeType")
def load(self, path: Path) -> moderngl.Texture:
# data:image/png;base64,iVBOR
# Image is stored in bufferView
if self.bufferView is not None:
image = Image.open(io.BytesIO(self.bufferView.read_raw()))
# Image is embedded
elif self.uri and self.uri.startswith("data:"):
data = self.uri[self.uri.find(",") + 1 :]
image = Image.open(io.BytesIO(base64.b64decode(data)))
logger.info("Loading embedded image")
else:
path = path / Path(self.uri if self.uri is not None else "")
logger.info("Loading: %s", self.uri)
image = Image.open(path)
texture = t2d.Loader(
TextureDescription(
label="gltf",
image=image,
flip=False,
mipmap=True,
anisotropy=16.0,
)
).load()
return texture
class GLTFTexture:
def __init__(self, data: dict[str, int]):
self.sampler: Optional[int] = data.get("sampler")
self.source: Optional[int] = data.get("source")
class GLTFSampler:
def __init__(self, data):
self.magFilter = data.get("magFilter")
self.minFilter = data.get("minFilter")
self.wrapS = data.get("wrapS")
self.wrapT = data.get("wrapT")
class GLTFCamera:
def __init__(self, data: dict[str, str]):
self.data = data
# "perspective": {
# "aspectRatio": 1.0,
# "yfov": 0.266482561826706,
# "zfar": 1000000.0,
# "znear": 0.04999999701976776
# },
# "type": "perspective"