1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
import io
import logging
import os
from pathlib import Path
import moderngl
import numpy
import pywavefront
from pywavefront import cache
from pywavefront.obj import ObjParser
from moderngl_window import resources
from moderngl_window.exceptions import ImproperlyConfigured
from moderngl_window.geometry.attributes import AttributeNames
from moderngl_window.loaders.base import BaseLoader
from moderngl_window.meta import SceneDescription, TextureDescription
from moderngl_window.opengl.vao import VAO
from moderngl_window.resources.decorators import texture_dirs
from moderngl_window.scene import Material, MaterialTexture, Mesh, Node, Scene
logger = logging.getLogger(__name__)
def translate_buffer_format(
vertex_format: str, attr_names: AttributeNames
) -> tuple[str, list[str], list[tuple[str, str, int]]]:
"""Translate the buffer format"""
buffer_format = []
attributes = []
mesh_attributes = []
if "T2F" in vertex_format:
buffer_format.append("2f")
attributes.append(attr_names.TEXCOORD_0)
mesh_attributes.append(("TEXCOORD_0", attr_names.TEXCOORD_0, 2))
if "C3F" in vertex_format:
buffer_format.append("3f")
attributes.append(attr_names.COLOR_0)
mesh_attributes.append(("COLOR_0", attr_names.COLOR_0, 3))
if "N3F" in vertex_format:
buffer_format.append("3f")
attributes.append(attr_names.NORMAL)
mesh_attributes.append(("NORMAL", attr_names.NORMAL, 3))
buffer_format.append("3f")
attributes.append(attr_names.POSITION)
mesh_attributes.append(("POSITION", attr_names.POSITION, 3))
return " ".join(buffer_format), attributes, mesh_attributes
class VAOCacheLoader(cache.CacheLoader):
"""Load geometry data directly into vaos"""
attr_names: AttributeNames
def load_vertex_buffer(
self, fd: io.TextIOWrapper, material: pywavefront.material.Material, length: int
) -> None:
buffer_format, attributes, mesh_attributes = translate_buffer_format(
material.vertex_format, self.attr_names
)
vao = VAO(material.name, mode=moderngl.TRIANGLES)
# FIXME: Are we actually reading from text or byte stream here?
vao.buffer(fd.read(length), buffer_format, attributes)
setattr(material, "vao", vao)
setattr(material, "buffer_format", buffer_format)
setattr(material, "attributes", attributes)
setattr(material, "mesh_attributes", mesh_attributes)
ObjParser.cache_loader_cls = VAOCacheLoader
class Loader(BaseLoader):
"""Load wavefront/obj files"""
kind = "wavefront"
file_extensions = [
[".obj"],
[".obj", ".gz"],
[".bin"],
]
meta: SceneDescription
def __init__(self, meta: SceneDescription):
super().__init__(meta)
def load(self) -> Scene:
"""Loads a wavefront/obj file including materials and textures
Returns:
Scene: The Scene instance
"""
path = self.find_scene(Path(self.meta.path if self.meta.path is not None else ""))
logger.info("loading %s", path)
if not path:
raise ImproperlyConfigured("Scene '{}' not found".format(self.meta.path))
if path.suffix == ".bin":
path = path.parent / path.stem
VAOCacheLoader.attr_names = self.meta.attr_names
data = pywavefront.Wavefront(str(path), create_materials=True, cache=self.meta.cache)
scene = Scene(
self.meta.resolved_path.as_posix() if self.meta.resolved_path is not None else ""
)
texture_cache: dict[str, pywavefront.material.Material] = {}
for _, mat in data.materials.items():
mesh = Mesh(mat.name)
# Traditional loader
if mat.vertices:
buffer_format, attributes, mesh_attributes = translate_buffer_format(
mat.vertex_format, self.meta.attr_names
)
vbo = numpy.array(mat.vertices, dtype="f4")
vao = VAO(mat.name, mode=moderngl.TRIANGLES)
vao.buffer(vbo, buffer_format, attributes)
mesh.vao = vao
for attrs in mesh_attributes:
mesh.add_attribute(*attrs)
# Binary cache loader
elif hasattr(mat, "vao"):
mesh = Mesh(mat.name)
mesh.vao = mat.vao
for attrs in mat.mesh_attributes:
mesh.add_attribute(*attrs)
else:
# Empty
continue
scene.meshes.append(mesh)
mesh.material = Material(mat.name)
scene.materials.append(mesh.material)
mesh.material.color = mat.diffuse
if mat.texture:
# A texture can be referenced multiple times, so we need to cache loaded ones
texture = texture_cache.get(mat.texture.path)
if not texture:
# HACK: pywavefront only give us an absolute path
rel_path = os.path.relpath(mat.texture.find(), str(path.parent))
logger.info("Loading: %s", rel_path)
with texture_dirs([path.parent]):
texture = resources.textures.load(
TextureDescription(
label=rel_path,
path=rel_path,
mipmap=True,
anisotropy=16.0,
)
)
texture_cache[rel_path] = texture
mesh.material.mat_texture = MaterialTexture(
texture=texture,
sampler=None,
)
node = Node(mesh=mesh)
scene.root_nodes.append(node)
# Not supported yet for obj
# self.calc_scene_bbox()
scene.prepare()
return scene
|
