You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1467 lines
68 KiB
1467 lines
68 KiB
# |
|
# This file is part of Magnum. |
|
# |
|
# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, |
|
# 2020, 2021, 2022 Vladimír Vondruš <mosra@centrum.cz> |
|
# |
|
# Permission is hereby granted, free of charge, to any person obtaining a |
|
# copy of this software and associated documentation files (the "Software"), |
|
# to deal in the Software without restriction, including without limitation |
|
# the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
# and/or sell copies of the Software, and to permit persons to whom the |
|
# Software is furnished to do so, subject to the following conditions: |
|
# |
|
# The above copyright notice and this permission notice shall be included |
|
# in all copies or substantial portions of the Software. |
|
# |
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
# DEALINGS IN THE SOFTWARE. |
|
# |
|
|
|
import os |
|
import platform |
|
import sys |
|
import tempfile |
|
import unittest |
|
|
|
from corrade import pluginmanager |
|
from magnum import * |
|
from magnum import primitives, trade |
|
import magnum |
|
|
|
class ImageData(unittest.TestCase): |
|
def test(self): |
|
# The only way to get an image instance is through a manager |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), "rgb.png")) |
|
|
|
image = importer.image2d(0) |
|
image_refcount = sys.getrefcount(image) |
|
self.assertFalse(image.is_compressed) |
|
self.assertEqual(image.storage.alignment, 1) # libPNG has 4 tho |
|
self.assertEqual(image.format, PixelFormat.RGB8_UNORM) |
|
self.assertEqual(image.pixel_size, 3) |
|
self.assertEqual(image.size, Vector2i(3, 2)) |
|
# TODO: ugh, report as bytes, not chars |
|
self.assertEqual(ord(image.pixels[1, 2, 2]), 181) |
|
self.assertEqual(ord(image.data[9 + 6 + 2]), 181) # libPNG has 12 + |
|
|
|
data = image.data |
|
self.assertEqual(len(data), 3*3*2) |
|
self.assertIs(data.owner, image) |
|
self.assertEqual(sys.getrefcount(image), image_refcount + 1) |
|
|
|
del data |
|
self.assertEqual(sys.getrefcount(image), image_refcount) |
|
|
|
def test_compressed(self): |
|
# The only way to get an image instance is through a manager |
|
importer = trade.ImporterManager().load_and_instantiate('DdsImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), "rgba_dxt1.dds")) |
|
image = importer.image2d(0) |
|
self.assertEqual(len(image.data), 8) |
|
self.assertTrue(image.is_compressed) |
|
# TODO: compressed properties |
|
|
|
# No compressed-image-related APIs exposed ATM, so just verifying the |
|
# uncompressed ones fail properly |
|
with self.assertRaisesRegex(AttributeError, "image is compressed"): |
|
image.storage |
|
with self.assertRaisesRegex(AttributeError, "image is compressed"): |
|
image.format |
|
with self.assertRaisesRegex(AttributeError, "image is compressed"): |
|
image.pixel_size |
|
with self.assertRaisesRegex(AttributeError, "image is compressed"): |
|
image.pixels |
|
|
|
def test_convert_view(self): |
|
# The only way to get an image instance is through a manager |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), "rgb.png")) |
|
image = importer.image2d(0) |
|
|
|
view = ImageView2D(image) |
|
mutable_view = MutableImageView2D(image) |
|
|
|
def test_convert_view_compressed(self): |
|
# The only way to get an image instance is through a manager |
|
importer = trade.ImporterManager().load_and_instantiate('DdsImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), "rgba_dxt1.dds")) |
|
image = importer.image2d(0) |
|
|
|
# No compressed-image-related APIs exposed ATM, so just verifying the |
|
# uncompressed ones fail properly |
|
with self.assertRaisesRegex(RuntimeError, "image is compressed"): |
|
view = ImageView2D(image) |
|
with self.assertRaisesRegex(RuntimeError, "image is compressed"): |
|
mutable_view = MutableImageView2D(image) |
|
|
|
class MeshData(unittest.TestCase): |
|
def test_custom_attribute(self): |
|
# Creating a custom attribute |
|
a = trade.MeshAttribute.CUSTOM(17) |
|
self.assertTrue(a.is_custom) |
|
if hasattr(a, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(a.value, 32768 + 17) |
|
self.assertEqual(a.custom_value, 17) |
|
self.assertEqual(a.name, "CUSTOM(17)") |
|
self.assertEqual(str(a), "MeshAttribute.CUSTOM(17)") |
|
self.assertEqual(repr(a), "<MeshAttribute.CUSTOM(17): 32785>") |
|
|
|
# Lowest possible custom value, test that it's correctly recognized as |
|
# custom by all APIs |
|
zero = trade.MeshAttribute.CUSTOM(0) |
|
self.assertTrue(zero.is_custom) |
|
if hasattr(zero, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(zero.value, 32768) |
|
self.assertEqual(zero.custom_value, 0) |
|
self.assertEqual(zero.name, "CUSTOM(0)") |
|
self.assertEqual(str(zero), "MeshAttribute.CUSTOM(0)") |
|
self.assertEqual(repr(zero), "<MeshAttribute.CUSTOM(0): 32768>") |
|
|
|
# Largest possible custom value |
|
largest = trade.MeshAttribute.CUSTOM(32767) |
|
self.assertTrue(largest.is_custom) |
|
if hasattr(largest, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(largest.value, 65535) |
|
self.assertEqual(largest.custom_value, 32767) |
|
|
|
# Creating a custom attribute with a value that won't fit |
|
with self.assertRaisesRegex(ValueError, "custom value too large"): |
|
trade.MeshAttribute.CUSTOM(32768) |
|
|
|
# Accessing properties on builtin values should still work as expected |
|
b = trade.MeshAttribute.BITANGENT |
|
self.assertFalse(b.is_custom) |
|
if hasattr(b, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(b.value, 3) |
|
with self.assertRaisesRegex(AttributeError, "not a custom value"): |
|
b.custom_value |
|
self.assertEqual(b.name, "BITANGENT") |
|
self.assertEqual(str(b), "MeshAttribute.BITANGENT") |
|
self.assertEqual(repr(b), "<MeshAttribute.BITANGENT: 3>") |
|
|
|
def test(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.primitive, MeshPrimitive.TRIANGLES) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
self.assertEqual(mesh.vertex_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
|
|
# Index properties |
|
self.assertTrue(mesh.is_indexed) |
|
self.assertEqual(mesh.index_count, 3) |
|
self.assertEqual(mesh.index_type, MeshIndexType.UNSIGNED_SHORT) |
|
self.assertEqual(mesh.index_offset, 0) |
|
self.assertEqual(mesh.index_stride, 2) |
|
|
|
self.assertEqual(mesh.vertex_count, 3) |
|
|
|
# TODO once configuration is exposed, disable the JOINTS/WEIGHTS |
|
# backwards compatibility to avoid this mess |
|
if magnum.BUILD_DEPRECATED: |
|
self.assertEqual(mesh.attribute_count(), 11) |
|
|
|
# Attribute properties by ID |
|
self.assertEqual(mesh.attribute_name(3), trade.MeshAttribute.POSITION) |
|
# Custom attribute |
|
self.assertEqual(mesh.attribute_name(8), trade.MeshAttribute.CUSTOM(10)) |
|
self.assertEqual(mesh.attribute_id(3), 0) |
|
# Attribute 5 is the second TEXTURE_COORDINATES attribute |
|
self.assertEqual(mesh.attribute_id(5), 1) |
|
self.assertEqual(mesh.attribute_format(0), VertexFormat.VECTOR3UB_NORMALIZED) |
|
self.assertEqual(mesh.attribute_format(10), VertexFormat.UNSIGNED_INT) |
|
self.assertEqual(mesh.attribute_offset(0), 20) |
|
self.assertEqual(mesh.attribute_offset(3), 0) |
|
self.assertEqual(mesh.attribute_stride(2), 28) |
|
self.assertEqual(mesh.attribute_array_size(0), 0) |
|
# Attribute 1 is JOINT_IDS |
|
self.assertEqual(mesh.attribute_array_size(1), 4) |
|
|
|
# Attribute properties by name |
|
self.assertTrue(mesh.has_attribute(trade.MeshAttribute.COLOR)) |
|
self.assertTrue(mesh.has_attribute(trade.MeshAttribute.POSITION)) |
|
self.assertFalse(mesh.has_attribute(trade.MeshAttribute.TANGENT)) |
|
self.assertEqual(mesh.attribute_count(trade.MeshAttribute.POSITION), 1) |
|
self.assertEqual(mesh.attribute_count(trade.MeshAttribute.TEXTURE_COORDINATES), 2) |
|
self.assertEqual(mesh.attribute_count(trade.MeshAttribute.TANGENT), 0) |
|
self.assertEqual(mesh.attribute_id(trade.MeshAttribute.POSITION), 3) |
|
self.assertEqual(mesh.attribute_id(trade.MeshAttribute.TEXTURE_COORDINATES, 1), 5) |
|
self.assertEqual(mesh.attribute_format(trade.MeshAttribute.COLOR), VertexFormat.VECTOR3UB_NORMALIZED) |
|
self.assertEqual(mesh.attribute_format(trade.MeshAttribute.OBJECT_ID), VertexFormat.UNSIGNED_INT) |
|
self.assertEqual(mesh.attribute_offset(trade.MeshAttribute.COLOR), 20) |
|
self.assertEqual(mesh.attribute_offset(trade.MeshAttribute.POSITION), 0) |
|
self.assertEqual(mesh.attribute_stride(trade.MeshAttribute.WEIGHTS), 28) |
|
self.assertEqual(mesh.attribute_array_size(trade.MeshAttribute.POSITION), 0) |
|
self.assertEqual(mesh.attribute_array_size(trade.MeshAttribute.WEIGHTS), 4) |
|
else: |
|
self.assertEqual(mesh.attribute_count(), 9) |
|
|
|
# Attribute properties by ID |
|
self.assertEqual(mesh.attribute_name(2), trade.MeshAttribute.POSITION) |
|
# Custom attribute |
|
self.assertEqual(mesh.attribute_name(6), trade.MeshAttribute.CUSTOM(8)) |
|
self.assertEqual(mesh.attribute_id(2), 0) |
|
# Attribute 4 is the second TEXTURE_COORDINATES attribute |
|
self.assertEqual(mesh.attribute_id(4), 1) |
|
self.assertEqual(mesh.attribute_format(0), VertexFormat.VECTOR3UB_NORMALIZED) |
|
self.assertEqual(mesh.attribute_format(8), VertexFormat.UNSIGNED_INT) |
|
self.assertEqual(mesh.attribute_offset(0), 20) |
|
self.assertEqual(mesh.attribute_offset(2), 0) |
|
self.assertEqual(mesh.attribute_stride(3), 28) |
|
self.assertEqual(mesh.attribute_array_size(0), 0) |
|
# Attribute 1 is JOINT_IDS |
|
self.assertEqual(mesh.attribute_array_size(1), 4) |
|
|
|
# Attribute properties by name |
|
self.assertTrue(mesh.has_attribute(trade.MeshAttribute.COLOR)) |
|
self.assertTrue(mesh.has_attribute(trade.MeshAttribute.POSITION)) |
|
self.assertFalse(mesh.has_attribute(trade.MeshAttribute.TANGENT)) |
|
self.assertEqual(mesh.attribute_count(trade.MeshAttribute.POSITION), 1) |
|
self.assertEqual(mesh.attribute_count(trade.MeshAttribute.TEXTURE_COORDINATES), 2) |
|
self.assertEqual(mesh.attribute_count(trade.MeshAttribute.TANGENT), 0) |
|
self.assertEqual(mesh.attribute_id(trade.MeshAttribute.POSITION), 2) |
|
self.assertEqual(mesh.attribute_id(trade.MeshAttribute.TEXTURE_COORDINATES, 1), 4) |
|
self.assertEqual(mesh.attribute_format(trade.MeshAttribute.COLOR), VertexFormat.VECTOR3UB_NORMALIZED) |
|
self.assertEqual(mesh.attribute_format(trade.MeshAttribute.OBJECT_ID), VertexFormat.UNSIGNED_INT) |
|
self.assertEqual(mesh.attribute_offset(trade.MeshAttribute.COLOR), 20) |
|
self.assertEqual(mesh.attribute_offset(trade.MeshAttribute.POSITION), 0) |
|
self.assertEqual(mesh.attribute_stride(trade.MeshAttribute.WEIGHTS), 28) |
|
self.assertEqual(mesh.attribute_array_size(trade.MeshAttribute.POSITION), 0) |
|
self.assertEqual(mesh.attribute_array_size(trade.MeshAttribute.WEIGHTS), 4) |
|
|
|
def test_index_data_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
mesh_refcount = sys.getrefcount(mesh) |
|
|
|
index_data = mesh.index_data |
|
self.assertEqual(len(index_data), 6) |
|
self.assertIs(index_data.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del index_data |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
mutable_index_data = mesh.mutable_index_data |
|
self.assertEqual(len(mutable_index_data), 6) |
|
self.assertIs(mutable_index_data.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del mutable_index_data |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
def test_vertex_data_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
mesh_refcount = sys.getrefcount(mesh) |
|
|
|
vertex_data = mesh.vertex_data |
|
self.assertEqual(len(vertex_data), 84) |
|
self.assertIs(vertex_data.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del vertex_data |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
mutable_vertex_data = mesh.mutable_vertex_data |
|
self.assertEqual(len(mutable_vertex_data), 84) |
|
self.assertIs(mutable_vertex_data.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del mutable_vertex_data |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
def test_indices_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
mesh_refcount = sys.getrefcount(mesh) |
|
|
|
indices = mesh.indices |
|
self.assertEqual(indices.size, (3, )) |
|
self.assertEqual(indices.stride, (2, )) |
|
self.assertEqual(indices.format, 'H') |
|
self.assertEqual(list(indices), [0, 2, 1]) |
|
self.assertIs(indices.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del indices |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
mutable_indices = mesh.mutable_indices |
|
self.assertEqual(mutable_indices.size, (3, )) |
|
self.assertEqual(mutable_indices.stride, (2, )) |
|
self.assertEqual(mutable_indices.format, 'H') |
|
self.assertEqual(list(mutable_indices), [0, 2, 1]) |
|
self.assertIs(mutable_indices.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del mutable_indices |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
def test_attribute_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
mesh_refcount = sys.getrefcount(mesh) |
|
position_id = mesh.attribute_id(trade.MeshAttribute.POSITION) |
|
|
|
positions = mesh.attribute(position_id) |
|
self.assertEqual(positions.size, (3, )) |
|
self.assertEqual(positions.stride, (28, )) |
|
self.assertEqual(positions.format, '3f') |
|
self.assertEqual(list(positions), [ |
|
Vector3(-1, -1, 0.25), |
|
Vector3(0, 1, 0.5), |
|
Vector3(1, -1, 0.25) |
|
]) |
|
self.assertIs(positions.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del positions |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
object_ids = mesh.attribute(trade.MeshAttribute.OBJECT_ID) |
|
self.assertEqual(object_ids.size, (3, )) |
|
self.assertEqual(object_ids.stride, (28, )) |
|
self.assertEqual(object_ids.format, 'I') |
|
self.assertEqual(list(object_ids), [216, 16777235, 2872872013]) |
|
self.assertIs(object_ids.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del object_ids |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
mutable_positions = mesh.mutable_attribute(position_id) |
|
self.assertEqual(mutable_positions.size, (3, )) |
|
self.assertEqual(mutable_positions.stride, (28, )) |
|
self.assertEqual(mutable_positions.format, '3f') |
|
self.assertEqual(list(mutable_positions), [ |
|
Vector3(-1, -1, 0.25), |
|
Vector3(0, 1, 0.5), |
|
Vector3(1, -1, 0.25) |
|
]) |
|
self.assertIs(mutable_positions.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del mutable_positions |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
mutable_object_ids = mesh.mutable_attribute(trade.MeshAttribute.OBJECT_ID) |
|
self.assertEqual(mutable_object_ids.size, (3, )) |
|
self.assertEqual(mutable_object_ids.stride, (28, )) |
|
self.assertEqual(mutable_object_ids.format, 'I') |
|
self.assertEqual(list(mutable_object_ids), [216, 16777235, 2872872013]) |
|
self.assertIs(mutable_object_ids.owner, mesh) |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1) |
|
|
|
del mutable_object_ids |
|
self.assertEqual(sys.getrefcount(mesh), mesh_refcount) |
|
|
|
def test_mutable_index_data_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
|
|
index_data = mesh.index_data |
|
mutable_index_data = mesh.mutable_index_data |
|
# Second index is 2, it's a 16-bit LE number |
|
# TODO: ugh, report as bytes, not chars |
|
self.assertEqual(ord(index_data[2]), 2) |
|
self.assertEqual(ord(mutable_index_data[2]), 2) |
|
|
|
mutable_index_data[2] = chr(76) |
|
self.assertEqual(ord(index_data[2]), 76) |
|
|
|
def test_mutable_vertex_data_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.vertex_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
|
|
vertex_data = mesh.vertex_data |
|
mutable_vertex_data = mesh.mutable_vertex_data |
|
# The color attribute is at offset 20, G channel is the next byte |
|
# TODO: ugh, report as bytes, not chars |
|
self.assertEqual(ord(vertex_data[21]), 51) |
|
self.assertEqual(ord(mutable_vertex_data[21]), 51) |
|
|
|
mutable_vertex_data[21] = chr(76) |
|
self.assertEqual(vertex_data[21], chr(76)) |
|
|
|
def test_mutable_indices_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
|
|
indices = mesh.indices |
|
mutable_indices = mesh.mutable_indices |
|
self.assertEqual(indices[1], 2) |
|
self.assertEqual(mutable_indices[1], 2) |
|
|
|
mutable_indices[1] = 76 |
|
self.assertEqual(indices[1], 76) |
|
|
|
def test_mutable_attributes_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
position_id = mesh.attribute_id(trade.MeshAttribute.POSITION) |
|
|
|
positions = mesh.attribute(position_id) |
|
mutable_positions = mesh.mutable_attribute(position_id) |
|
self.assertEqual(positions[1], Vector3(0, 1, 0.5)) |
|
self.assertEqual(mutable_positions[1], Vector3(0, 1, 0.5)) |
|
|
|
mutable_positions[1] *= 2 |
|
self.assertEqual(positions[1], Vector3(0, 2, 1)) |
|
|
|
object_ids = mesh.attribute(trade.MeshAttribute.OBJECT_ID) |
|
mutable_object_ids = mesh.mutable_attribute(trade.MeshAttribute.OBJECT_ID) |
|
self.assertEqual(object_ids[1], 16777235) |
|
self.assertEqual(mutable_object_ids[1], 16777235) |
|
|
|
mutable_object_ids[1] //= 1000 |
|
self.assertEqual(object_ids[1], 16777) |
|
|
|
def test_packed_attribute_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
packed_attribute = importer.mesh_attribute_for_name("_CUSTOM_PACKED_ATTRIBUTE") |
|
self.assertEqual(mesh.attribute_format(packed_attribute), VertexFormat.VECTOR3UB) |
|
|
|
packed = mesh.attribute(packed_attribute) |
|
mutable_packed = mesh.mutable_attribute(packed_attribute) |
|
self.assertEqual(packed[1], Vector3i(51, 102, 255)) |
|
self.assertEqual(mutable_packed[1], Vector3i(51, 102, 255)) |
|
|
|
mutable_packed[1] -= Vector3i(12, 56, 200) |
|
self.assertEqual(packed[1], Vector3(39, 46, 55)) |
|
|
|
def test_normalized_attribute_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
self.assertEqual(mesh.attribute_format(trade.MeshAttribute.COLOR), VertexFormat.VECTOR3UB_NORMALIZED) |
|
|
|
normalized = mesh.attribute(trade.MeshAttribute.COLOR) |
|
mutable_normalized = mesh.mutable_attribute(trade.MeshAttribute.COLOR) |
|
self.assertEqual(normalized[1], Vector3(0.2, 0.4, 1)) |
|
self.assertEqual(mutable_normalized[1], Vector3(0.2, 0.4, 1)) |
|
|
|
mutable_normalized[1] *= 0.5 |
|
# Rounding errors are expected |
|
self.assertEqual(normalized[1], Vector3(0.101961, 0.2, 0.501961)) |
|
|
|
def test_data_access_not_mutable(self): |
|
mesh = primitives.cube_solid() |
|
# TODO split this once there's a mesh where only one or the other would |
|
# be true (maybe with zero-copy loading of PLYs / STLs?) |
|
self.assertEqual(mesh.index_data_flags, trade.DataFlag(0)) |
|
self.assertEqual(mesh.vertex_data_flags, trade.DataFlag(0)) |
|
|
|
with self.assertRaisesRegex(AttributeError, "mesh index data is not mutable"): |
|
mesh.mutable_index_data |
|
with self.assertRaisesRegex(AttributeError, "mesh index data is not mutable"): |
|
mesh.mutable_indices |
|
with self.assertRaisesRegex(AttributeError, "mesh vertex data is not mutable"): |
|
mesh.mutable_vertex_data |
|
with self.assertRaisesRegex(AttributeError, "mesh vertex data is not mutable"): |
|
mesh.mutable_attribute(0) |
|
with self.assertRaisesRegex(AttributeError, "mesh vertex data is not mutable"): |
|
mesh.mutable_attribute(trade.MeshAttribute.POSITION) |
|
|
|
def test_nonindexed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(1) |
|
self.assertFalse(mesh.is_indexed) |
|
|
|
# Accessing the index data should be possible, they're just empty |
|
self.assertEqual(len(mesh.index_data), 0) |
|
|
|
# Accessing any other index-related info should cause an exception |
|
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"): |
|
mesh.index_count |
|
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"): |
|
mesh.index_type |
|
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"): |
|
mesh.index_offset |
|
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"): |
|
mesh.index_stride |
|
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"): |
|
mesh.indices |
|
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"): |
|
mesh.mutable_indices |
|
|
|
def test_attribute_oob(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
|
|
# Access by OOB ID |
|
with self.assertRaises(IndexError): |
|
mesh.attribute_name(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.attribute_id(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.attribute_format(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.attribute_offset(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.attribute_stride(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.attribute_array_size(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.attribute(mesh.attribute_count()) |
|
with self.assertRaises(IndexError): |
|
mesh.mutable_attribute(mesh.attribute_count()) |
|
|
|
# Access by nonexistent name |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_id(trade.MeshAttribute.TANGENT) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_format(trade.MeshAttribute.TANGENT) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_offset(trade.MeshAttribute.TANGENT) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_stride(trade.MeshAttribute.TANGENT) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_array_size(trade.MeshAttribute.TANGENT) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute(trade.MeshAttribute.TANGENT) |
|
with self.assertRaises(KeyError): |
|
mesh.mutable_attribute(trade.MeshAttribute.TANGENT) |
|
|
|
# Access by existing name + OOB ID |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_id(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_format(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_offset(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_stride(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute_array_size(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
with self.assertRaises(KeyError): |
|
mesh.attribute(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
with self.assertRaises(KeyError): |
|
mesh.mutable_attribute(trade.MeshAttribute.TEXTURE_COORDINATES, 2) |
|
|
|
def test_attribute_access_array(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh(0) |
|
joint_ids_id = mesh.attribute_id(trade.MeshAttribute.JOINT_IDS) |
|
|
|
with self.assertRaisesRegex(NotImplementedError, "array attributes not implemented yet, sorry"): |
|
mesh.attribute(joint_ids_id) |
|
with self.assertRaisesRegex(NotImplementedError, "array attributes not implemented yet, sorry"): |
|
mesh.mutable_attribute(joint_ids_id) |
|
with self.assertRaisesRegex(NotImplementedError, "array attributes not implemented yet, sorry"): |
|
mesh.attribute(trade.MeshAttribute.JOINT_IDS) |
|
with self.assertRaisesRegex(NotImplementedError, "array attributes not implemented yet, sorry"): |
|
mesh.mutable_attribute(trade.MeshAttribute.JOINT_IDS) |
|
|
|
def test_attribute_access_unsupported_format(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
custom_attribute = importer.mesh_attribute_for_name("_CUSTOM_MATRIX_ATTRIBUTE"); |
|
self.assertIsNotNone(custom_attribute) |
|
|
|
mesh = importer.mesh(0) |
|
custom_attribute_id = mesh.attribute_id(custom_attribute) |
|
|
|
with self.assertRaisesRegex(NotImplementedError, "access to this vertex format is not implemented yet, sorry"): |
|
mesh.attribute(custom_attribute_id) |
|
with self.assertRaisesRegex(NotImplementedError, "access to this vertex format is not implemented yet, sorry"): |
|
mesh.mutable_attribute(custom_attribute_id) |
|
with self.assertRaisesRegex(NotImplementedError, "access to this vertex format is not implemented yet, sorry"): |
|
mesh.attribute(custom_attribute) |
|
with self.assertRaisesRegex(NotImplementedError, "access to this vertex format is not implemented yet, sorry"): |
|
mesh.mutable_attribute(custom_attribute) |
|
|
|
class SceneData(unittest.TestCase): |
|
def test_custom_field(self): |
|
# Creating a custom attribute |
|
a = trade.SceneField.CUSTOM(17) |
|
self.assertTrue(a.is_custom) |
|
if hasattr(a, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(a.value, 0x80000000 + 17) |
|
self.assertEqual(a.custom_value, 17) |
|
self.assertEqual(a.name, "CUSTOM(17)") |
|
self.assertEqual(str(a), "SceneField.CUSTOM(17)") |
|
self.assertEqual(repr(a), "<SceneField.CUSTOM(17): 2147483665>") |
|
|
|
# Lowest possible custom value, test that it's correctly recognized as |
|
# custom by all APIs |
|
zero = trade.SceneField.CUSTOM(0) |
|
self.assertTrue(zero.is_custom) |
|
if hasattr(zero, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(zero.value, 0x80000000) |
|
self.assertEqual(zero.custom_value, 0) |
|
self.assertEqual(zero.name, "CUSTOM(0)") |
|
self.assertEqual(str(zero), "SceneField.CUSTOM(0)") |
|
self.assertEqual(repr(zero), "<SceneField.CUSTOM(0): 2147483648>") |
|
|
|
# Largest possible custom value |
|
largest = trade.SceneField.CUSTOM(0x7fffffff) |
|
self.assertTrue(largest.is_custom) |
|
if hasattr(largest, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(largest.value, 0xffffffff) |
|
self.assertEqual(largest.custom_value, 0x7fffffff) |
|
|
|
# Creating a custom attribute with a value that won't fit |
|
with self.assertRaisesRegex(ValueError, "custom value too large"): |
|
trade.SceneField.CUSTOM(0x80000000) |
|
|
|
# Accessing properties on builtin values should still work as expected |
|
b = trade.SceneField.SKIN |
|
self.assertFalse(b.is_custom) |
|
if hasattr(b, 'value'): # only since pybind11 2.6.2 |
|
self.assertEqual(b.value, 10) |
|
with self.assertRaisesRegex(AttributeError, "not a custom value"): |
|
b.custom_value |
|
self.assertEqual(b.name, "SKIN") |
|
self.assertEqual(str(b), "SceneField.SKIN") |
|
self.assertEqual(repr(b), "<SceneField.SKIN: 10>") |
|
|
|
def test(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
self.assertEqual(scene.mapping_type, trade.SceneMappingType.UNSIGNED_INT) |
|
self.assertEqual(scene.mapping_bound, 4) |
|
self.assertEqual(scene.field_count, 7) |
|
# TODO add some array extras once supported to have this different from |
|
# the mapping bound |
|
self.assertEqual(scene.field_size_bound, 4) |
|
self.assertFalse(scene.is_2d) |
|
self.assertTrue(scene.is_3d) |
|
|
|
# Field properties by ID |
|
self.assertEqual(scene.field_name(2), trade.SceneField.TRANSFORMATION) |
|
self.assertEqual(scene.field_name(6), trade.SceneField.CUSTOM(1)) |
|
# TODO some field flags in glTF please? |
|
self.assertEqual(scene.field_flags(2), trade.SceneFieldFlag(0)) |
|
self.assertEqual(scene.field_type(2), trade.SceneFieldType.MATRIX4X4) |
|
self.assertEqual(scene.field_size(3), 3) |
|
# TODO add some array extras once supported to have this non-zero for |
|
# some fields |
|
self.assertEqual(scene.field_array_size(2), 0) |
|
self.assertTrue(scene.has_field_object(2, 3)) |
|
self.assertFalse(scene.has_field_object(4, 1)) |
|
self.assertEqual(scene.field_object_offset(2, 3), 2) |
|
self.assertEqual(scene.field_object_offset(2, 3, 1), 2) |
|
|
|
# Field properties by name |
|
self.assertEqual(scene.field_id(trade.SceneField.CUSTOM(0)), 5) |
|
self.assertTrue(scene.has_field(trade.SceneField.IMPORTER_STATE)) |
|
self.assertFalse(scene.has_field(trade.SceneField.SKIN)) |
|
self.assertTrue(scene.has_field_object(trade.SceneField.TRANSFORMATION, 3)) |
|
self.assertFalse(scene.has_field_object(trade.SceneField.CAMERA, 1)) |
|
self.assertEqual(scene.field_object_offset(trade.SceneField.TRANSFORMATION, 3), 2) |
|
self.assertEqual(scene.field_object_offset(trade.SceneField.TRANSFORMATION, 3, 1), 2) |
|
# TODO some field flags in glTF please? |
|
self.assertEqual(scene.field_flags(trade.SceneField.PARENT), trade.SceneFieldFlag(0)) |
|
self.assertEqual(scene.field_type(trade.SceneField.CUSTOM(1)), trade.SceneFieldType.STRING_OFFSET32) |
|
self.assertEqual(scene.field_size(trade.SceneField.CUSTOM(0)), 1) |
|
# TODO add some array extras once supported to have this non-zero for |
|
# some fields |
|
self.assertEqual(scene.field_array_size(trade.SceneField.TRANSLATION), 0) |
|
|
|
def test_mapping_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
scene_refcount = sys.getrefcount(scene) |
|
translation_id = scene.field_id(trade.SceneField.TRANSLATION) |
|
|
|
translations = scene.mapping(translation_id) |
|
self.assertEqual(translations.size, (3, )) |
|
self.assertEqual(translations.stride, (4, )) |
|
self.assertEqual(translations.format, 'I') |
|
self.assertEqual(list(translations), [1, 3, 0]) |
|
self.assertIs(translations.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del translations |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
cameras = scene.mapping(trade.SceneField.CAMERA) |
|
self.assertEqual(cameras.size, (2, )) |
|
self.assertEqual(cameras.stride, (4, )) |
|
self.assertEqual(cameras.format, 'I') |
|
self.assertEqual(list(cameras), [2, 3]) |
|
self.assertIs(cameras.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del cameras |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
mutable_translations = scene.mutable_mapping(translation_id) |
|
self.assertEqual(mutable_translations.size, (3, )) |
|
self.assertEqual(mutable_translations.stride, (4, )) |
|
self.assertEqual(mutable_translations.format, 'I') |
|
self.assertEqual(list(mutable_translations), [1, 3, 0]) |
|
self.assertIs(mutable_translations.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del mutable_translations |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
mutable_cameras = scene.mutable_mapping(trade.SceneField.CAMERA) |
|
self.assertEqual(mutable_cameras.size, (2, )) |
|
self.assertEqual(mutable_cameras.stride, (4, )) |
|
self.assertEqual(mutable_cameras.format, 'I') |
|
self.assertEqual(list(mutable_cameras), [2, 3]) |
|
self.assertIs(mutable_cameras.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del mutable_cameras |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
def test_field_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
scene_refcount = sys.getrefcount(scene) |
|
translation_id = scene.field_id(trade.SceneField.TRANSLATION) |
|
|
|
translations = scene.field(translation_id) |
|
self.assertEqual(translations.size, (3, )) |
|
self.assertEqual(translations.stride, (12, )) |
|
self.assertEqual(translations.format, '3f') |
|
self.assertEqual(list(translations), [ |
|
Vector3(1, 2, 3), |
|
Vector3(4, 5, 6), |
|
Vector3(7, 8, 9) |
|
]) |
|
self.assertIs(translations.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del translations |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
cameras = scene.field(trade.SceneField.CAMERA) |
|
self.assertEqual(cameras.size, (2, )) |
|
self.assertEqual(cameras.stride, (4, )) |
|
self.assertEqual(cameras.format, 'I') |
|
self.assertEqual(list(cameras), [1, 0]) |
|
self.assertIs(cameras.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del cameras |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
mutable_translations = scene.mutable_field(translation_id) |
|
self.assertEqual(mutable_translations.size, (3, )) |
|
self.assertEqual(mutable_translations.stride, (12, )) |
|
self.assertEqual(mutable_translations.format, '3f') |
|
self.assertEqual(list(mutable_translations), [ |
|
Vector3(1, 2, 3), |
|
Vector3(4, 5, 6), |
|
Vector3(7, 8, 9) |
|
]) |
|
self.assertIs(mutable_translations.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del mutable_translations |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
mutable_cameras = scene.mutable_field(trade.SceneField.CAMERA) |
|
self.assertEqual(mutable_cameras.size, (2, )) |
|
self.assertEqual(mutable_cameras.stride, (4, )) |
|
self.assertEqual(mutable_cameras.format, 'I') |
|
self.assertEqual(list(mutable_cameras), [1, 0]) |
|
self.assertIs(mutable_cameras.owner, scene) |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount + 1) |
|
|
|
del mutable_cameras |
|
self.assertEqual(sys.getrefcount(scene), scene_refcount) |
|
|
|
def test_mutable_mapping_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
self.assertEqual(scene.data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
translation_id = scene.field_id(trade.SceneField.TRANSLATION) |
|
|
|
translations = scene.mapping(translation_id) |
|
mutable_translations = scene.mutable_mapping(translation_id) |
|
self.assertEqual(translations[1], 3) |
|
self.assertEqual(mutable_translations[1], 3) |
|
|
|
mutable_translations[1] = 776 |
|
self.assertEqual(translations[1], 776) |
|
|
|
cameras = scene.mapping(trade.SceneField.CAMERA) |
|
mutable_cameras = scene.mutable_mapping(trade.SceneField.CAMERA) |
|
self.assertEqual(cameras[1], 3) |
|
self.assertEqual(mutable_cameras[1], 3) |
|
|
|
mutable_cameras[1] = 13378 |
|
self.assertEqual(cameras[1], 13378) |
|
|
|
def test_mutable_field_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
self.assertEqual(scene.data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
translation_id = scene.field_id(trade.SceneField.TRANSLATION) |
|
|
|
translations = scene.field(translation_id) |
|
mutable_translations = scene.mutable_field(translation_id) |
|
self.assertEqual(translations[1], Vector3(4, 5, 6)) |
|
self.assertEqual(mutable_translations[1], Vector3(4, 5, 6)) |
|
|
|
mutable_translations[1] *= 0.5 |
|
self.assertEqual(translations[1], Vector3(2, 2.5, 3)) |
|
|
|
cameras = scene.field(trade.SceneField.CAMERA) |
|
mutable_cameras = scene.mutable_field(trade.SceneField.CAMERA) |
|
self.assertEqual(cameras[1], 0) |
|
self.assertEqual(mutable_cameras[1], 0) |
|
|
|
mutable_cameras[1] = 13378 |
|
self.assertEqual(cameras[1], 13378) |
|
|
|
def test_pointer_field_access(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
self.assertEqual(scene.data_flags, trade.DataFlag.OWNED|trade.DataFlag.MUTABLE) |
|
|
|
pointer = scene.field(trade.SceneField.IMPORTER_STATE) |
|
mutable_pointer = scene.mutable_field(trade.SceneField.IMPORTER_STATE) |
|
self.assertEqual(pointer.format, 'P') |
|
self.assertEqual(mutable_pointer.format, 'P') |
|
self.assertNotEqual(pointer[1], 0x0) |
|
self.assertEqual(mutable_pointer[1], pointer[1]) |
|
|
|
mutable_pointer[1] = 0xdeadbeef |
|
self.assertEqual(pointer[1], 0xdeadbeef) |
|
|
|
def test_data_access_not_mutable(self): |
|
pass |
|
# TODO implement once there's a way to get immutable SceneData, either |
|
# by "deserializing" a binary blob or via some SceneTools API |
|
|
|
def test_field_oob(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene(0) |
|
|
|
# Access by OOB field ID |
|
with self.assertRaises(IndexError): |
|
scene.field_name(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.field_flags(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.field_type(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.field_size(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.field_array_size(scene.field_count) |
|
with self.assertRaisesRegex(IndexError, "field out of range"): |
|
scene.has_field_object(scene.field_count, 0) |
|
with self.assertRaisesRegex(IndexError, "field out of range"): |
|
scene.field_object_offset(scene.field_count, 0) |
|
with self.assertRaises(IndexError): |
|
scene.mapping(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.mutable_mapping(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.field(scene.field_count) |
|
with self.assertRaises(IndexError): |
|
scene.mutable_field(scene.field_count) |
|
|
|
# Access by nonexistent field name |
|
with self.assertRaises(KeyError): |
|
scene.field_id(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.field_flags(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.field_type(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.field_size(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.field_array_size(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.has_field_object(trade.SceneField.SCALING, 0) |
|
with self.assertRaises(KeyError): |
|
scene.field_object_offset(trade.SceneField.SCALING, 0) |
|
with self.assertRaises(KeyError): |
|
scene.mapping(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.mutable_mapping(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.field(trade.SceneField.SCALING) |
|
with self.assertRaises(KeyError): |
|
scene.mutable_field(trade.SceneField.SCALING) |
|
|
|
# OOB object ID |
|
with self.assertRaisesRegex(IndexError, "object out of range"): |
|
scene.has_field_object(0, 4) # PARENT |
|
with self.assertRaisesRegex(IndexError, "object out of range"): |
|
scene.has_field_object(trade.SceneField.PARENT, 4) |
|
with self.assertRaisesRegex(IndexError, "object out of range"): |
|
scene.field_object_offset(0, 4) # PARENT |
|
with self.assertRaisesRegex(IndexError, "object out of range"): |
|
scene.field_object_offset(trade.SceneField.PARENT, 4) |
|
|
|
# Lookup error |
|
with self.assertRaises(LookupError): |
|
scene.field_object_offset(4, 1) # CAMERA |
|
with self.assertRaises(LookupError): |
|
scene.field_object_offset(trade.SceneField.CAMERA, 1) |
|
|
|
# Lookup error due to field offset being at the end |
|
with self.assertRaises(LookupError): |
|
scene.field_object_offset(0, 1, scene.field_size(0)) # PARENT |
|
with self.assertRaises(LookupError): |
|
scene.field_object_offset(trade.SceneField.PARENT, 1, scene.field_size(trade.SceneField.PARENT)) |
|
|
|
# OOB field offset (offset == size is allowed, tested above) |
|
with self.assertRaisesRegex(IndexError, "offset out of range"): |
|
scene.field_object_offset(0, 1, scene.field_size(0) + 1) # PARENT |
|
with self.assertRaisesRegex(IndexError, "offset out of range"): |
|
scene.field_object_offset(trade.SceneField.PARENT, 1, scene.field_size(trade.SceneField.PARENT) + 1) |
|
|
|
def test_field_access_array(self): |
|
pass |
|
# TODO implement once there's some importer that gives back arrays |
|
# (gltf? not sure) |
|
|
|
def test_field_access_unsupported_type(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
string_field = importer.scene_field_for_name('aString') |
|
self.assertIsNotNone(string_field) |
|
|
|
scene = importer.scene(0) |
|
string_field_id = scene.field_id(string_field) |
|
|
|
with self.assertRaisesRegex(NotImplementedError, "access to this scene field type is not implemented yet, sorry"): |
|
scene.field(string_field_id) |
|
with self.assertRaisesRegex(NotImplementedError, "access to this scene field type is not implemented yet, sorry"): |
|
scene.mutable_field(string_field_id) |
|
with self.assertRaisesRegex(NotImplementedError, "access to this scene field type is not implemented yet, sorry"): |
|
scene.field(string_field) |
|
with self.assertRaisesRegex(NotImplementedError, "access to this scene field type is not implemented yet, sorry"): |
|
scene.mutable_field(string_field) |
|
|
|
class Importer(unittest.TestCase): |
|
def test_manager(self): |
|
manager = trade.ImporterManager() |
|
self.assertIn('cz.mosra.magnum.Trade.AbstractImporter', manager.plugin_interface) |
|
self.assertIn('importers', manager.plugin_directory) |
|
self.assertIn('StbImageImporter', manager.plugin_list) |
|
self.assertIn('PngImporter', manager.alias_list) |
|
self.assertEqual(manager.load_state('StbImageImporter'), pluginmanager.LoadState.NOT_LOADED) |
|
|
|
self.assertTrue(manager.load('StbImageImporter') & pluginmanager.LoadState.LOADED) |
|
self.assertEqual(manager.unload('StbImageImporter'), pluginmanager.LoadState.NOT_LOADED) |
|
|
|
with self.assertRaisesRegex(RuntimeError, "can't load plugin"): |
|
manager.load('NonexistentImporter') |
|
with self.assertRaisesRegex(RuntimeError, "can't unload plugin"): |
|
manager.unload('NonexistentImporter') |
|
|
|
def test(self): |
|
manager = trade.ImporterManager() |
|
|
|
self.assertIn('cz.mosra.magnum.Trade.AbstractImporter', trade.AbstractImporter.plugin_interface) |
|
self.assertIn(manager.plugin_directory, trade.AbstractImporter.plugin_search_paths) |
|
if platform.system() == 'Windows': |
|
self.assertEqual(trade.AbstractImporter.plugin_suffix, '.dll') |
|
else: |
|
self.assertEqual(trade.AbstractImporter.plugin_suffix, '.so') |
|
self.assertEqual(trade.AbstractImporter.plugin_metadata_suffix, '.conf') |
|
|
|
importer = manager.load_and_instantiate('StbImageImporter') |
|
self.assertEqual(importer.plugin, 'StbImageImporter') |
|
|
|
def test_set_plugin_directory(self): |
|
manager = trade.ImporterManager() |
|
|
|
plugin_directory = manager.plugin_directory |
|
self.assertIn('PngImporter', manager.alias_list) |
|
|
|
manager.plugin_directory = "/nonexistent" |
|
self.assertNotIn('PngImporter', manager.alias_list) |
|
|
|
manager.plugin_directory = plugin_directory |
|
self.assertIn('PngImporter', manager.alias_list) |
|
|
|
def test_set_preferred_plugins(self): |
|
manager = trade.ImporterManager() |
|
# TODO test this better once we can verify it gets actually loaded |
|
manager.set_preferred_plugins('TgaImporter', ['StbImageImporter', 'DevIlImageImporter']) |
|
self.assertIn('StbImageImporter', manager.alias_list) |
|
|
|
def test_set_preferred_plugins_alias_not_found(self): |
|
manager = trade.ImporterManager() |
|
with self.assertRaises(KeyError): |
|
manager.set_preferred_plugins('ApngImporter', []) |
|
|
|
def test_metadata(self): |
|
manager = trade.ImporterManager() |
|
manager.set_preferred_plugins('PngImporter', ['StbImageImporter']) |
|
manager_refcount = sys.getrefcount(manager) |
|
|
|
metadata = manager.metadata('PngImporter') |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount + 1) |
|
self.assertEqual(metadata.name, 'StbImageImporter') |
|
self.assertEqual(metadata.provides, ['BmpImporter', 'GifImporter', 'HdrImporter', 'JpegImporter', 'PgmImporter', 'PicImporter', 'PngImporter', 'PpmImporter', 'PsdImporter', 'TgaImporter']) |
|
|
|
del metadata |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount) |
|
|
|
metadata = manager.metadata('GltfImporter') |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount + 1) |
|
self.assertEqual(metadata.depends, ['AnyImageImporter']) |
|
|
|
importer = manager.load_and_instantiate('GltfImporter') |
|
importer_refcount = sys.getrefcount(importer) |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount + 2) |
|
|
|
metadata = manager.metadata('AnyImageImporter') |
|
# Replacing the previous metadata instance so it stays the same |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount + 2) |
|
self.assertEqual(metadata.used_by, ['GltfImporter']) |
|
|
|
# Retrieving metadata from the plugin instance should be the same |
|
# instance |
|
metadata_from_plugin = importer.metadata |
|
self.assertEqual(sys.getrefcount(importer), importer_refcount + 1) |
|
self.assertEqual(metadata_from_plugin.depends, ['AnyImageImporter']) |
|
|
|
del metadata_from_plugin |
|
self.assertEqual(sys.getrefcount(importer), importer_refcount) |
|
|
|
del importer |
|
del metadata |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount) |
|
|
|
def test_configuration(self): |
|
manager = trade.ImporterManager() |
|
|
|
metadata = manager.metadata('StbImageImporter') |
|
metadata_refcount = sys.getrefcount(metadata) |
|
|
|
# Setting the value from initial configuration should make the plugin |
|
# inherit that |
|
initial_configuration = metadata.configuration |
|
self.assertEqual(sys.getrefcount(metadata), metadata_refcount + 1) |
|
self.assertEqual(initial_configuration['forceChannelCount'], '0') |
|
initial_configuration['forceChannelCount'] = '7' |
|
|
|
del initial_configuration |
|
self.assertEqual(sys.getrefcount(metadata), metadata_refcount) |
|
|
|
importer = manager.load_and_instantiate('StbImageImporter') |
|
importer_refcount = sys.getrefcount(importer) |
|
|
|
configuration = importer.configuration |
|
self.assertEqual(sys.getrefcount(importer), importer_refcount + 1) |
|
self.assertEqual(configuration['forceChannelCount'], '7') |
|
|
|
configuration['forceChannelCount'] = '2' |
|
|
|
del configuration |
|
self.assertEqual(sys.getrefcount(importer), importer_refcount) |
|
|
|
# Verify the config change is actually used and not being done on some |
|
# copy that gets thrown away |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png')) |
|
image = importer.image2d(0) |
|
self.assertEqual(image.format, PixelFormat.RG8_UNORM) # not RGB8 |
|
|
|
def test_no_file_opened(self): |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
self.assertFalse(importer.is_opened) |
|
|
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.default_scene |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.scene_count |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.object_count |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.scene_for_name('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.object_for_name('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.scene_name(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.object_name(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.scene(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.scene('') |
|
|
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.mesh_count |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.mesh_level_count(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.mesh_for_name('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.mesh_name(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.mesh(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.mesh('') |
|
|
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image1d_count |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image2d_count |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image3d_count |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image1d_level_count(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image2d_level_count(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image3d_level_count(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image1d_for_name('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image2d_for_name('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image3d_for_name('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image1d_name(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image2d_name(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image3d_name(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image1d(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image1d('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image2d(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image2d('') |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image3d(0) |
|
with self.assertRaisesRegex(AssertionError, "no file opened"): |
|
importer.image3d('') |
|
|
|
def test_index_oob(self): |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png')) |
|
|
|
with self.assertRaises(IndexError): |
|
importer.scene_name(0) |
|
with self.assertRaises(IndexError): |
|
importer.object_name(0) |
|
with self.assertRaises(IndexError): |
|
importer.scene(0) |
|
|
|
with self.assertRaises(IndexError): |
|
importer.mesh_level_count(0) |
|
with self.assertRaises(IndexError): |
|
importer.mesh_name(0) |
|
with self.assertRaisesRegex(IndexError, "ID out of bounds"): |
|
importer.mesh(0) |
|
|
|
with self.assertRaises(IndexError): |
|
importer.image1d_level_count(0) |
|
with self.assertRaises(IndexError): |
|
importer.image2d_level_count(1) |
|
with self.assertRaises(IndexError): |
|
importer.image3d_level_count(0) |
|
|
|
with self.assertRaises(IndexError): |
|
importer.image1d_name(0) |
|
with self.assertRaises(IndexError): |
|
importer.image2d_name(1) |
|
with self.assertRaises(IndexError): |
|
importer.image3d_name(0) |
|
|
|
with self.assertRaisesRegex(IndexError, "ID out of bounds"): |
|
importer.image1d(0) |
|
with self.assertRaisesRegex(IndexError, "level out of bounds"): |
|
importer.image2d(0, 1) |
|
with self.assertRaisesRegex(IndexError, "ID out of bounds"): |
|
importer.image2d(1) |
|
with self.assertRaisesRegex(IndexError, "ID out of bounds"): |
|
importer.image3d(0) |
|
|
|
def test_open_failed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
|
|
with self.assertRaisesRegex(RuntimeError, "opening nonexistent.png failed"): |
|
importer.open_file('nonexistent.png') |
|
with self.assertRaisesRegex(RuntimeError, "opening data failed"): |
|
importer.open_data(b'') |
|
|
|
def test_scene(self): |
|
# importer refcounting tested in image2d |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
|
|
# Asking for custom scene field names should work even if not opened, |
|
# returns None |
|
self.assertIsNone(importer.scene_field_name(trade.SceneField.CUSTOM(1))) |
|
self.assertIsNone(importer.scene_field_for_name('aString')) |
|
|
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
self.assertEqual(importer.default_scene, 1) |
|
self.assertEqual(importer.scene_count, 3) |
|
self.assertEqual(importer.scene_name(1), "A default scene that's empty") |
|
self.assertEqual(importer.scene_for_name("A default scene that's empty"), 1) |
|
self.assertEqual(importer.object_count, 5) |
|
self.assertEqual(importer.object_name(2), "Camera node") |
|
self.assertEqual(importer.object_for_name("Camera node"), 2) |
|
|
|
# It should work after opening |
|
self.assertEqual(importer.scene_field_name(trade.SceneField.CUSTOM(1)), 'aString') |
|
self.assertEqual(importer.scene_field_for_name('aString'), trade.SceneField.CUSTOM(1)) |
|
|
|
scene = importer.scene(0) |
|
self.assertEqual(scene.field_count, 7) |
|
self.assertTrue(scene.has_field(importer.scene_field_for_name('aString'))) |
|
|
|
def test_scene_by_name(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
scene = importer.scene("A scene") |
|
self.assertEqual(scene.field_count, 7) |
|
|
|
def test_scene_by_name_not_found(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
with self.assertRaises(KeyError): |
|
importer.scene('Nonexistent') |
|
|
|
def test_scene_failed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf')) |
|
|
|
with self.assertRaisesRegex(RuntimeError, "import failed"): |
|
importer.scene(2) |
|
with self.assertRaisesRegex(RuntimeError, "import failed"): |
|
importer.scene("A broken scene") |
|
|
|
def test_mesh(self): |
|
# importer refcounting tested in image2d |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
|
|
# Asking for custom mesh attribute names should work even if not |
|
# opened, returns None |
|
# TODO once configuration is exposed, disable the JOINTS/WEIGHTS |
|
# backwards compatibility to avoid this mess |
|
if magnum.BUILD_DEPRECATED: |
|
self.assertIsNone(importer.mesh_attribute_name(trade.MeshAttribute.CUSTOM(9))) |
|
else: |
|
self.assertIsNone(importer.mesh_attribute_name(trade.MeshAttribute.CUSTOM(7))) |
|
self.assertIsNone(importer.mesh_attribute_for_name("_CUSTOM_ATTRIBUTE")) |
|
|
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
self.assertEqual(importer.mesh_count, 3) |
|
self.assertEqual(importer.mesh_level_count(0), 1) |
|
self.assertEqual(importer.mesh_name(0), 'Indexed mesh') |
|
self.assertEqual(importer.mesh_for_name('Indexed mesh'), 0) |
|
|
|
# It should work after opening |
|
# TODO once configuration is exposed, disable the JOINTS/WEIGHTS |
|
# backwards compatibility to avoid this mess |
|
if magnum.BUILD_DEPRECATED: |
|
self.assertEqual(importer.mesh_attribute_name(trade.MeshAttribute.CUSTOM(10)), "_CUSTOM_MATRIX_ATTRIBUTE") |
|
self.assertEqual(importer.mesh_attribute_for_name("_CUSTOM_MATRIX_ATTRIBUTE"), trade.MeshAttribute.CUSTOM(10)) |
|
else: |
|
self.assertEqual(importer.mesh_attribute_name(trade.MeshAttribute.CUSTOM(8)), "_CUSTOM_MATRIX_ATTRIBUTE") |
|
self.assertEqual(importer.mesh_attribute_for_name("_CUSTOM_MATRIX_ATTRIBUTE"), trade.MeshAttribute.CUSTOM(8)) |
|
|
|
mesh = importer.mesh(0) |
|
self.assertEqual(mesh.primitive, MeshPrimitive.TRIANGLES) |
|
self.assertTrue(mesh.has_attribute(importer.mesh_attribute_for_name("_CUSTOM_MATRIX_ATTRIBUTE"))) |
|
|
|
def test_mesh_level_oob(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
with self.assertRaises(IndexError): |
|
importer.mesh(0, 1) |
|
|
|
def test_mesh_by_name(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
mesh = importer.mesh('Non-indexed mesh') |
|
self.assertEqual(mesh.primitive, MeshPrimitive.TRIANGLES) |
|
|
|
def test_mesh_by_name_not_found(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
with self.assertRaises(KeyError): |
|
importer.mesh('Nonexistent') |
|
|
|
def test_mesh_by_name_level_oob(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
with self.assertRaisesRegex(IndexError, "level out of bounds"): |
|
importer.mesh('Non-indexed mesh', 1) |
|
|
|
def test_mesh_failed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
|
|
with self.assertRaisesRegex(RuntimeError, "import failed"): |
|
importer.mesh(2) |
|
with self.assertRaisesRegex(RuntimeError, "import failed"): |
|
importer.mesh('A broken mesh') |
|
|
|
def test_image2d(self): |
|
manager = trade.ImporterManager() |
|
manager_refcount = sys.getrefcount(manager) |
|
|
|
# Importer references the manager to ensure it doesn't get GC'd before |
|
# the plugin instances |
|
importer = manager.load_and_instantiate('StbImageImporter') |
|
self.assertIs(importer.manager, manager) |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount + 1) |
|
|
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png')) |
|
self.assertEqual(importer.image2d_count, 1) |
|
self.assertEqual(importer.image2d_level_count(0), 1) |
|
self.assertEqual(importer.image2d_name(0), '') |
|
self.assertEqual(importer.image2d_for_name(''), -1) |
|
|
|
image = importer.image2d(0) |
|
self.assertEqual(image.size, Vector2i(3, 2)) |
|
|
|
# Deleting the importer should decrease manager refcount again |
|
del importer |
|
self.assertEqual(sys.getrefcount(manager), manager_refcount) |
|
|
|
def test_image_level_oob(self): |
|
# importer refcounting tested in image2d |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png')) |
|
|
|
with self.assertRaisesRegex(IndexError, "level out of bounds"): |
|
importer.image2d(0, 1) |
|
|
|
def test_image2d_by_name(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'image.gltf')) |
|
|
|
image = importer.image2d('A named image') |
|
self.assertEqual(image.size, Vector2i(3, 2)) |
|
|
|
def test_image2d_by_name_not_found(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'image.gltf')) |
|
|
|
with self.assertRaises(KeyError): |
|
importer.image2d('Nonexistent') |
|
|
|
def test_image2d_data(self): |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
|
|
with open(os.path.join(os.path.dirname(__file__), "rgb.png"), 'rb') as f: |
|
importer.open_data(f.read()) |
|
|
|
image = importer.image2d(0) |
|
self.assertEqual(image.size, Vector2i(3, 2)) |
|
|
|
def test_image2d_failed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'image.gltf')) |
|
|
|
with self.assertRaisesRegex(RuntimeError, "import failed"): |
|
importer.image2d(0) |
|
with self.assertRaisesRegex(RuntimeError, "import failed"): |
|
importer.image2d('A broken image') |
|
|
|
class ImageConverter(unittest.TestCase): |
|
def test_image2d(self): |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png')) |
|
image = importer.image2d(0) |
|
|
|
converter = trade.ImageConverterManager().load_and_instantiate('StbImageConverter') |
|
|
|
with tempfile.TemporaryDirectory() as tmp: |
|
converter.convert_to_file(image, os.path.join(tmp, "image.png")) |
|
self.assertTrue(os.path.exists(os.path.join(tmp, "image.png"))) |
|
|
|
def test_image2d_failed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png')) |
|
image = importer.image2d(0) |
|
|
|
converter = trade.ImageConverterManager().load_and_instantiate('StbImageConverter') |
|
|
|
with tempfile.TemporaryDirectory() as tmp: |
|
with self.assertRaisesRegex(RuntimeError, "conversion failed"): |
|
converter.convert_to_file(image, os.path.join(tmp, "image.hdr")) |
|
|
|
class SceneConverter(unittest.TestCase): |
|
def test_mesh(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
mesh = importer.mesh(1) |
|
|
|
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter') |
|
|
|
with tempfile.TemporaryDirectory() as tmp: |
|
converter.convert_to_file(mesh, os.path.join(tmp, "mesh.ply")) |
|
self.assertTrue(os.path.exists(os.path.join(tmp, "mesh.ply"))) |
|
|
|
def test_mesh_failed(self): |
|
importer = trade.ImporterManager().load_and_instantiate('GltfImporter') |
|
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf')) |
|
mesh = importer.mesh(1) |
|
|
|
converter = trade.SceneConverterManager().load_and_instantiate('AnySceneConverter') |
|
|
|
with tempfile.TemporaryDirectory() as tmp: |
|
with self.assertRaisesRegex(RuntimeError, "conversion failed"): |
|
converter.convert_to_file(mesh, os.path.join(tmp, "mesh.obj"))
|
|
|