import codecs
from enum import Enum
import base64
import json
import os
import re
import struct
import gltf2usdUtils
from gltf2 import Skin, Node, Animation, Scene, Mesh, Material, GLTFImage, Asset
class AccessorType(Enum):
SCALAR = 'SCALAR'
VEC2 = 'VEC2'
VEC3 = 'VEC3'
VEC4 = 'VEC4'
MAT2 = 'MAT2'
MAT3 = 'MAT3'
MAT4 = 'MAT4'
class AccessorComponentType(Enum):
BYTE = 5120
UNSIGNED_BYTE = 5121
SHORT = 5122
UNSIGNED_SHORT = 5123
UNSIGNED_INT = 5125
FLOAT = 5126
class TextureWrap(Enum):
CLAMP_TO_EDGE = 33071
MIRRORED_REPEAT = 33648
REPEAT = 10497
class MagFilter(Enum):
NEAREST = 9728
LINEAR = 9729
class MinFilter(Enum):
NEAREST = 9728
LINEAR = 9729
NEAREST_MIPMAP_NEAREST = 9984
LINEAR_MIPMAP_NEAREST = 9985
NEAREST_MIPMAP_LINEAR = 9986
LINEAR_MIPMAP_LINEAR = 9987
class AccessorTypeCount(Enum):
SCALAR = 1
VEC2 = 2
VEC3 = 3
VEC4 = 4
MAT2 = 4
MAT3 = 9
MAT4 = 16
def accessor_type_count(x):
return {
'SCALAR': 1,
'VEC2': 2,
'VEC3': 3,
'VEC4': 4,
'MAT2': 4,
'MAT3': 9,
'MAT4': 16
}[x]
def PrimitiveMode(Enum):
POINTS = 0
LINES = 1
LINE_LOOP = 2
LINE_STRIP = 3
TRIANGLES = 4
TRIANGLE_STRIP = 5
TRIANGLE_FAN = 6
def accessor_component_type_bytesize(x):
return {
AccessorComponentType.BYTE: 1,
AccessorComponentType.UNSIGNED_BYTE: 1,
AccessorComponentType.SHORT: 2,
AccessorComponentType.UNSIGNED_SHORT: 2,
AccessorComponentType.UNSIGNED_INT: 4,
AccessorComponentType.FLOAT: 4,
}[x]
class GLTF2Loader(object):
"""A very simple glTF loader. It is essentially a utility to load data from accessors
"""
def __init__(self, gltf_file, optimize_textures=False, generate_texture_transform_texture=True):
"""Initializes the glTF 2.0 loader
Arguments:
gltf_file {str} -- Path to glTF file
"""
if not os.path.isfile(gltf_file):
raise Exception("file {} does not exist".format(gltf_file))
if not gltf_file.endswith('.gltf'):
raise Exception('Can only accept .gltf files')
self._accessor_data_map = {}
self.root_dir = os.path.dirname(gltf_file)
self._optimize_textures = optimize_textures
self._generate_texture_transform_texture = generate_texture_transform_texture
try:
with codecs.open(gltf_file, encoding='utf-8', errors='strict') as f:
self.json_data = json.load(f)
except UnicodeDecodeError:
with open(gltf_file) as f:
self.json_data = json.load(f)
self._initialize()
def _initialize(self):
"""Initializes the glTF loader
"""
self._initialize_asset()
self._initialize_images()
self._initialize_materials()
self._initialize_meshes()
self._initialize_nodes()
self._initialize_skins()
self._initialize_scenes()
self._initialize_animations()
def _initialize_asset(self):
if 'asset' in self.json_data:
self._asset = Asset.Asset(self.json_data['asset'])
else:
self._asset = None
def _initialize_images(self):
self._images = []
if 'images' in self.json_data:
for i, image_entry in enumerate(self.json_data['images']):
self._images.append(GLTFImage.GLTFImage(image_entry, i, self, self._optimize_textures, self._generate_texture_transform_texture))
def _initialize_nodes(self):
self.nodes = []
if 'nodes' in self.json_data:
for i, node_entry in enumerate(self.json_data['nodes']):
node = Node(node_entry, i, self)
self.nodes.append(node)
for i, node_entry in enumerate(self.json_data['nodes']):
if 'children' in node_entry:
parent = self.nodes[i]
for child_index in node_entry['children']:
child = self.nodes[child_index]
child._parent = parent
parent._children.append(child)
def _initialize_materials(self):
self._materials = []
if 'materials' in self.json_data:
for i, material_entry in enumerate(self.json_data['materials']):
material = Material(material_entry, i, self)
self._materials.append(material)
def _initialize_scenes(self):
self._scenes = []
self._main_scene = None
if 'scenes' in self.json_data:
for i, scene_entry in enumerate(self.json_data['scenes']):
scene = Scene(scene_entry, i, self.nodes)
self._scenes.append(scene)
if 'scene' in self.json_data:
self._main_scene = self._scenes[self.json_data['scene']]
else:
self._main_scene = self._scenes[0]
def get_images(self):
return self._images
def get_scenes(self):
"""Get the scene objects from the glTF file
Returns:
Scene[] -- glTF scene objects
"""
return self._scenes
def get_main_scene(self):
"""Returns the main scene in the glTF file, or none if there are no scenes
Returns:
Scene -- glTF scene
"""
return self._main_scene
def get_materials(self):
return self._materials
def get_meshes(self):
return self._meshes
def _initialize_meshes(self):
self._meshes = []
if 'meshes' in self.json_data:
for i, mesh_entry in enumerate(self.json_data['meshes']):
mesh = Mesh(mesh_entry, i, self)
self._meshes.append(mesh)
def _initialize_animations(self):
self.animations = []
if 'animations' in self.json_data:
for i, animation_entry in enumerate(self.json_data['animations']):
animation = Animation(animation_entry, i, self)
self.animations.append(animation)
def _initialize_skins(self):
self.skins = []
if 'skins' in self.json_data:
self.skins = [Skin(self, skin) for skin in self.json_data['skins']]
for node in self.nodes:
if node._skin_index != None:
node._skin = self.skins[node._skin_index]
def get_asset(self):
return self._asset
def get_nodes(self):
return self.nodes
def get_skins(self):
return self.skins
def get_animations(self):
return self.animations
def align(self, value, size):
remainder = value % size
return value if (remainder == 0) else (value + size - remainder)
def get_data(self, accessor, accessor_index):
if accessor_index in self._accessor_data_map.keys():
return self._accessor_data_map[accessor_index]
bufferview = self.json_data['bufferViews'][accessor['bufferView']]
buffer = self.json_data['buffers'][bufferview['buffer']]
accessor_type = AccessorType(accessor['type'])
uri = buffer['uri']
buffer_data = ''
if re.match(r'^data:.*?;base64,', uri):
uri_data = uri.split(',')[1]
buffer_data = base64.b64decode(uri_data)
if 'byteOffset' in bufferview:
buffer_data = buffer_data[bufferview['byteOffset']:]
else:
buffer_file = os.path.join(self.root_dir, uri)
with open(buffer_file, 'rb') as buffer_fptr:
if 'byteOffset' in bufferview:
buffer_fptr.seek(bufferview['byteOffset'], 1)
buffer_data = buffer_fptr.read(bufferview['byteLength'])
data_arr = []
accessor_component_type = AccessorComponentType(accessor['componentType'])
accessor_type_size = accessor_type_count(accessor['type'])
accessor_component_type_size = accessor_component_type_bytesize(accessor_component_type)
bytestride = int(bufferview['byteStride']) if ('byteStride' in bufferview) else (accessor_type_size * accessor_component_type_size)
offset = int(accessor['byteOffset']) if 'byteOffset' in accessor else 0
data_type = ''
data_type_size = 4
normalize_divisor = 1.0 #used if the value needs to be normalized
if accessor_component_type == AccessorComponentType.FLOAT:
data_type = 'f'
data_type_size = 4
elif accessor_component_type == AccessorComponentType.UNSIGNED_INT:
data_type = 'I'
data_type_size = 4
elif accessor_component_type == AccessorComponentType.UNSIGNED_SHORT:
data_type = 'H'
data_type_size = 2
normalize_divisor = 65535.0 if 'normalized' in accessor and accessor['normalized'] == True else 1.0
elif accessor_component_type == AccessorComponentType.UNSIGNED_BYTE:
data_type = 'B'
data_type_size = 1
normalize_divisor = 255.0 if 'normalized' in accessor and accessor['normalized'] == True else 1.0
else:
raise Exception('unsupported accessor component type!')
for i in range(0, accessor['count']):
entries = []
for j in range(0, accessor_type_size):
x = offset + j * accessor_component_type_size
window = buffer_data[x:x + data_type_size]
entries.append((struct.unpack(data_type, window)[0])/normalize_divisor)
if len(entries) > 1:
data_arr.append(tuple(entries))
else:
data_arr.append(entries[0])
offset = offset + bytestride
self._accessor_data_map[accessor_index] = data_arr
return data_arr
