ic
/
magnum-bindings
6
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
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.
601 Commits
4 Branches
2 Tags
2.4 MiB
Tree: c2284590e2
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c2284590e2'
${ noResults }
magnum-bindings/src/python/magnum/test/test_trade.py

3529 lines
187 KiB
Raw Normal View History Unescape

python: *very* little from Trade.
7 years ago
#
# This file is part of Magnum.
#
Updated copyright year.
6 years ago
# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
It's 2023 already!
3 years ago
# 2020, 2021, 2022, 2023 Vladimír Vondruš <mosra@centrum.cz>
python: *very* little from Trade.
7 years ago
#
# 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.
#
python: expose trade.MeshAttributeData. To be eventually used for creating MeshData from scratch.
2 years ago
import array
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
import os
python: expose static AbstractPlugin properties as well.
3 years ago
import platform
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
import sys
python: exposed basics of trade.AbstractImageConverter.
4 years ago
import tempfile
python: *very* little from Trade.
7 years ago
import unittest
python: support bit field access in SceneData.
3 years ago
from corrade import containers, pluginmanager
python: *very* little from Trade.
7 years ago
from magnum import *
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
from magnum import primitives, scenetools, trade
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
import magnum
python: *very* little from Trade.
7 years ago
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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"))
python: properly test trade.ImageData.data refcounting. Was tested for the Image/ImageView classes but not here.
4 years ago
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
image = importer.image2d(0)
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))
python: add an ability for referencing owner of trade.*Data memory. This is important in case the data aren't owned by the instance but instead referencing something else, for example the importer, a memory-mapped file or another instance. Will get increasingly important for zero-copy data import.
3 years ago
self.assertIsNone(image.owner)
python: properly test trade.ImageData.data refcounting. Was tested for the Image/ImageView classes but not here.
4 years ago
python: expose the CompressedPixelFormat enum. And related Trade::ImageData APIs.
3 years ago
with self.assertRaisesRegex(AttributeError, "image is not compressed"):
image.compressed_format
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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)
python: expose the CompressedPixelFormat enum. And related Trade::ImageData APIs.
3 years ago
self.assertEqual(image.compressed_format, CompressedPixelFormat.BC1_RGBA_UNORM)
# TODO: remaining compressed properties
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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
python: expose trade.TextureData and related importer APIs.
3 years ago
with self.assertRaisesRegex(AttributeError, "image is compressed"):
image.mutable_pixels
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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)
python: exposed CompressedImage and ImageView classes.
3 years ago
with self.assertRaisesRegex(RuntimeError, "image is not compressed"):
CompressedImageView2D(image)
with self.assertRaisesRegex(RuntimeError, "image is not compressed"):
MutableCompressedImageView2D(image)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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)
python: exposed CompressedImage and ImageView classes.
3 years ago
view = CompressedImageView2D(image)
mutable_view = MutableCompressedImageView2D(image)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
with self.assertRaisesRegex(RuntimeError, "image is compressed"):
view = ImageView2D(image)
with self.assertRaisesRegex(RuntimeError, "image is compressed"):
mutable_view = MutableImageView2D(image)
python: typed access to Image*.pixels. Basically mirroring what's done for MeshData and SceneData already.
3 years ago
def test_data_access(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.assertEqual(image.storage.alignment, 1) # libPNG has 4 tho
self.assertEqual(image.format, PixelFormat.RGB8_UNORM)
self.assertEqual(image.size, Vector2i(3, 2))
data = image.data
self.assertEqual(len(data), 3*3*2)
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
self.assertEqual(data[9 + 6 + 2], 181) # libPNG has 12 +
python: typed access to Image*.pixels. Basically mirroring what's done for MeshData and SceneData already.
3 years ago
self.assertIs(data.owner, image)
self.assertEqual(sys.getrefcount(image), image_refcount + 1)
del data
self.assertEqual(sys.getrefcount(image), image_refcount)
mutable_data = image.data
self.assertEqual(len(mutable_data), 3*3*2)
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
self.assertEqual(mutable_data[9 + 6 + 2], 181) # libPNG has 12 +
python: typed access to Image*.pixels. Basically mirroring what's done for MeshData and SceneData already.
3 years ago
self.assertIs(mutable_data.owner, image)
self.assertEqual(sys.getrefcount(image), image_refcount + 1)
del mutable_data
self.assertEqual(sys.getrefcount(image), image_refcount)
def test_mutable_data_access(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)
self.assertEqual(image.data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
data = image.data
mutable_data = image.mutable_data
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
self.assertEqual(data[13], 254)
self.assertEqual(mutable_data[13], 254)
python: typed access to Image*.pixels. Basically mirroring what's done for MeshData and SceneData already.
3 years ago
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
mutable_data[13] = 76
self.assertEqual(data[13], 76)
python: typed access to Image*.pixels. Basically mirroring what's done for MeshData and SceneData already.
3 years ago
def test_pixels_access(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.assertEqual(image.storage.alignment, 1) # libPNG has 4 tho
self.assertEqual(image.format, PixelFormat.RGB8_UNORM)
self.assertEqual(image.size, Vector2i(3, 2))
pixels = image.pixels
self.assertEqual(pixels.size, (2, 3))
self.assertEqual(pixels.stride, (9, 3))
self.assertEqual(pixels.format, '3B')
self.assertEqual(pixels[0, 2], Color3(0.792157, 0.996078, 0.466667))
self.assertEqual(pixels[1, 0], Color3(0.870588, 0.678431, 0.709804))
self.assertIs(pixels.owner, image)
self.assertEqual(sys.getrefcount(image), image_refcount + 1)
del pixels
self.assertEqual(sys.getrefcount(image), image_refcount)
def test_mutable_pixels_access(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)
self.assertEqual(image.data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
pixels = image.pixels
mutable_pixels = image.mutable_pixels
self.assertEqual(pixels[0, 2], Color3(0.792157, 0.996078, 0.466667))
self.assertEqual(mutable_pixels[0, 2], Color3(0.792157, 0.996078, 0.466667))
mutable_pixels[0, 2] *= 0.5
self.assertEqual(pixels[0, 2], Color3(0.396078, 0.498039, 0.235294))
def test_data_access_not_mutable(self):
pass
# TODO implement once there's a way to get immutable ImageData, either
# by "deserializing" a binary blob, or by mmapping a KTX file etc.
def test_pixels_access_unsupported_format(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__), "dxt10-depth32f-stencil8ui.dds"))
image = importer.image2d(0)
self.assertEqual(image.format, PixelFormat.DEPTH32F_STENCIL8UI)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to PixelFormat.DEPTH32F_STENCIL8UI is not implemented yet, sorry"):
python: typed access to Image*.pixels. Basically mirroring what's done for MeshData and SceneData already.
3 years ago
image.pixels
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
class MaterialData(unittest.TestCase):
def test_layer_properties(self):
self.assertEqual(trade.MaterialLayer.CLEAR_COAT.string, "ClearCoat")
def test_attribute_properties(self):
self.assertEqual(trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE.string, "LayerFactorTextureSwizzle")
def test_texture_swizzle_properties(self):
self.assertEqual(trade.MaterialTextureSwizzle.GB.component_count, 2)
def test(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
# This adds extra Diffuse attributes for BaseColor, don't want
importer.configuration['phongMaterialFallback'] = False
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material(0)
material_empty = importer.material(1)
self.assertEqual(material.attribute_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
self.assertEqual(material.layer_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
self.assertEqual(material.types, trade.MaterialTypes.PBR_METALLIC_ROUGHNESS|trade.MaterialTypes.PBR_CLEAR_COAT)
self.assertEqual(material.layer_count, 2)
self.assertEqual(material.attribute_data_offset(1), 3)
self.assertEqual(material.attribute_data_offset(2), 11)
self.assertTrue(material.has_layer("ClearCoat"))
self.assertFalse(material_empty.has_layer("ClearCoat"))
self.assertTrue(material.has_layer(trade.MaterialLayer.CLEAR_COAT))
self.assertFalse(material_empty.has_layer(trade.MaterialLayer.CLEAR_COAT))
self.assertEqual(material.layer_id("ClearCoat"), 1)
self.assertEqual(material.layer_id(trade.MaterialLayer.CLEAR_COAT), 1)
self.assertEqual(material.layer_name(1), "ClearCoat")
self.assertAlmostEqual(material.layer_factor(1), 0.7)
self.assertAlmostEqual(material.layer_factor("ClearCoat"), 0.7)
self.assertAlmostEqual(material.layer_factor(trade.MaterialLayer.CLEAR_COAT), 0.7)
self.assertEqual(material.layer_factor_texture(1), 2)
self.assertEqual(material.layer_factor_texture("ClearCoat"), 2)
self.assertEqual(material.layer_factor_texture(trade.MaterialLayer.CLEAR_COAT), 2)
# TODO test with something where the swizzle isn't default to verify
# it's querying the right layer
self.assertEqual(material.layer_factor_texture_swizzle(1), trade.MaterialTextureSwizzle.R)
self.assertEqual(material.layer_factor_texture_swizzle("ClearCoat"), trade.MaterialTextureSwizzle.R)
self.assertEqual(material.layer_factor_texture_swizzle(trade.MaterialLayer.CLEAR_COAT), trade.MaterialTextureSwizzle.R)
self.assertEqual(material.layer_factor_texture_matrix(1), Matrix3.translation((0.25, -0.5)))
self.assertEqual(material.layer_factor_texture_matrix("ClearCoat"), Matrix3.translation((0.25, -0.5)))
self.assertEqual(material.layer_factor_texture_matrix(trade.MaterialLayer.CLEAR_COAT), Matrix3.translation((0.25, -0.5)))
self.assertEqual(material.layer_factor_texture_coordinates(1), 13)
self.assertEqual(material.layer_factor_texture_coordinates("ClearCoat"), 13)
self.assertEqual(material.layer_factor_texture_coordinates(trade.MaterialLayer.CLEAR_COAT), 13)
# TODO test with something where the layer isn't 0, KHR_image_ktx is
# too annoying
self.assertEqual(material.layer_factor_texture_layer(1), 0)
self.assertEqual(material.layer_factor_texture_layer("ClearCoat"), 0)
self.assertEqual(material.layer_factor_texture_layer(trade.MaterialLayer.CLEAR_COAT), 0)
self.assertEqual(material.attribute_count(1), 8)
self.assertEqual(material.attribute_count("ClearCoat"), 8)
self.assertEqual(material.attribute_count(trade.MaterialLayer.CLEAR_COAT), 8)
self.assertEqual(material.attribute_count(1), 8)
self.assertEqual(material.attribute_count(), 3)
self.assertTrue(material.has_attribute(1, "LayerFactorTexture"))
self.assertFalse(material.has_attribute(1, "LayerFactorTextureSwizzle"))
self.assertTrue(material.has_attribute(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE))
self.assertFalse(material.has_attribute(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE))
self.assertTrue(material.has_attribute("ClearCoat", "LayerFactorTexture"))
self.assertFalse(material.has_attribute("ClearCoat", "LayerFactorTextureSwizzle"))
self.assertTrue(material.has_attribute("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE))
self.assertFalse(material.has_attribute("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE))
self.assertTrue(material.has_attribute(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTexture"))
self.assertFalse(material.has_attribute(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTextureSwizzle"))
self.assertTrue(material.has_attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE))
self.assertFalse(material.has_attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE))
self.assertTrue(material.has_attribute("DoubleSided"))
self.assertFalse(material.has_attribute("BaseColorTexture"))
self.assertTrue(material.has_attribute(trade.MaterialAttribute.DOUBLE_SIDED))
self.assertFalse(material.has_attribute(trade.MaterialAttribute.BASE_COLOR_TEXTURE))
self.assertEqual(material.attribute_id(1, "RoughnessTexture"), 6)
self.assertEqual(material.attribute_id(1, trade.MaterialAttribute.ROUGHNESS_TEXTURE), 6)
self.assertEqual(material.attribute_id("ClearCoat", "RoughnessTexture"), 6)
self.assertEqual(material.attribute_id("ClearCoat", trade.MaterialAttribute.ROUGHNESS_TEXTURE), 6)
self.assertEqual(material.attribute_id(trade.MaterialLayer.CLEAR_COAT, "RoughnessTexture"), 6)
self.assertEqual(material.attribute_id(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.ROUGHNESS_TEXTURE), 6)
self.assertEqual(material.attribute_id("DoubleSided"), 2)
self.assertEqual(material.attribute_id(trade.MaterialAttribute.DOUBLE_SIDED), 2)
self.assertEqual(material.attribute_name(1, 6), "RoughnessTexture")
self.assertEqual(material.attribute_name("ClearCoat", 6), "RoughnessTexture")
self.assertEqual(material.attribute_name(trade.MaterialLayer.CLEAR_COAT, 6), "RoughnessTexture")
self.assertEqual(material.attribute_name(2), "DoubleSided")
self.assertEqual(material.attribute_type(1, 4), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type(1, "LayerFactorTextureMatrix"), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_MATRIX), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type("ClearCoat", 4), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type("ClearCoat", "LayerFactorTextureMatrix"), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_MATRIX), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type(trade.MaterialLayer.CLEAR_COAT, 4), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTextureMatrix"), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_MATRIX), trade.MaterialAttributeType.MATRIX3X3)
self.assertEqual(material.attribute_type(2), trade.MaterialAttributeType.BOOL)
self.assertEqual(material.attribute_type("DoubleSided"), trade.MaterialAttributeType.BOOL)
self.assertEqual(material.attribute_type(trade.MaterialAttribute.DOUBLE_SIDED), trade.MaterialAttributeType.BOOL)
self.assertEqual(material.attribute(1, 3), 13)
self.assertEqual(material.attribute(1, "LayerFactorTextureCoordinates"), 13)
self.assertEqual(material.attribute(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_COORDINATES), 13)
self.assertEqual(material.attribute("ClearCoat", 3), 13)
self.assertEqual(material.attribute("ClearCoat", "LayerFactorTextureCoordinates"), 13)
self.assertEqual(material.attribute("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_COORDINATES), 13)
self.assertEqual(material.attribute(trade.MaterialLayer.CLEAR_COAT, 3), 13)
self.assertEqual(material.attribute(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTextureCoordinates"), 13)
self.assertEqual(material.attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_COORDINATES), 13)
self.assertEqual(material.attribute(2), True)
self.assertEqual(material.attribute("DoubleSided"), True)
self.assertEqual(material.attribute(trade.MaterialAttribute.DOUBLE_SIDED), True)
self.assertTrue(material.is_double_sided)
self.assertEqual(material.alpha_mode, trade.MaterialAlphaMode.MASK)
self.assertEqual(material.alpha_mask, 0.36899998784065247)
def test_attribute_access(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material(0)
# Boolean, scalar, vector, matrix
self.assertEqual(material.attribute(trade.MaterialAttribute.DOUBLE_SIDED), True)
self.assertEqual(material.attribute(trade.MaterialAttribute.ALPHA_MASK), 0.36899998784065247)
self.assertEqual(material.attribute(trade.MaterialAttribute.BASE_COLOR), Vector4(0.3, 0.4, 0.5, 0.8))
self.assertEqual(material.attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_MATRIX), Matrix3(
(1.0, 0.0, 0.0),
(0.0, 1.0, 0.0),
(0.25, -0.5, 1.0)))
# Texture swizzle, string
self.assertEqual(material.attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.ROUGHNESS_TEXTURE_SWIZZLE), trade.MaterialTextureSwizzle.G)
self.assertEqual(material.attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_NAME), "ClearCoat")
def test_attribute_access_unsupported_format(self):
# TODO test this once Assimp or Ufbx or serialized data loading exists
# to have a Buffer or a Pointer attribute
pass
def test_layer_oob(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
# This adds extra Diffuse attributes for BaseColor, don't want
importer.configuration['phongMaterialFallback'] = False
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material(0)
material_empty = importer.material(1)
material_empty_layer = importer.material(2)
# TODO these are all printed with '' around except for an IndexError,
# why? Is that implicit behavior of the KeyError? Ugh??
# https://stackoverflow.com/a/24999035
with self.assertRaisesRegex(IndexError, "index 3 out of range for 2 layers"):
# Passing 2 works
material.attribute_data_offset(3)
with self.assertRaisesRegex(KeyError, "FlearFoat not found among 2 layers"):
material.layer_id("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_id(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_name(2)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_factor(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.layer_factor("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_factor(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_factor_texture(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.layer_factor_texture("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_factor_texture(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_factor_texture_swizzle(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.layer_factor_texture_swizzle("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_factor_texture_swizzle(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_factor_texture_matrix(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.layer_factor_texture_matrix("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_factor_texture_matrix(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_factor_texture_coordinates(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.layer_factor_texture_coordinates("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_factor_texture_coordinates(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.layer_factor_texture_layer(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.layer_factor_texture_layer("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.layer_factor_texture_layer(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_count(2)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_count("FlearFoat")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_count(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.has_attribute(2, "LayerFactor")
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.has_attribute(2, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.has_attribute("FlearFoat", "LayerFactor")
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.has_attribute("FlearFoat", trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.has_attribute(trade.MaterialLayer.CLEAR_COAT, "LayerFactor")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.has_attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_id(2, "LayerFactor")
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_id(2, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_id("FlearFoat", "LayerFactor")
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_id("FlearFoat", trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_id(trade.MaterialLayer.CLEAR_COAT, "LayerFactor")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_id(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_name(2, 0)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_name("FlearFoat", 0)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_name(trade.MaterialLayer.CLEAR_COAT, 0)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_type(2, 0)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_type(2, "LayerFactor")
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute_type(2, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_type("FlearFoat", 0)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_type("FlearFoat", "LayerFactor")
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute_type("FlearFoat", trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_type(trade.MaterialLayer.CLEAR_COAT, 0)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_type(trade.MaterialLayer.CLEAR_COAT, "LayerFactor")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute_type(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute(2, 0)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute(2, "LayerFactor")
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 layers"):
material.attribute(2, trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute("FlearFoat", 0)
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute("FlearFoat", "LayerFactor")
with self.assertRaisesRegex(KeyError, "name FlearFoat not found among 2 layers"):
material.attribute("FlearFoat", trade.MaterialAttribute.LAYER_FACTOR)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute(trade.MaterialLayer.CLEAR_COAT, 0)
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute(trade.MaterialLayer.CLEAR_COAT, "LayerFactor")
with self.assertRaisesRegex(KeyError, "MaterialLayer.CLEAR_COAT not found among 1 layers"):
material_empty.attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR)
def test_attribute_oob(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
# This adds extra Diffuse attributes for BaseColor, don't want
importer.configuration['phongMaterialFallback'] = False
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material(0)
material_empty_layer = importer.material(2)
# TODO these are all printed with '' around except for an IndexError,
# why? Is that implicit behavior of the KeyError? Ugh??
# https://stackoverflow.com/a/24999035
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer 0"):
material.layer_factor_texture(0)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer ClearCoat"):
material_empty_layer.layer_factor_texture("ClearCoat")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in MaterialLayer.CLEAR_COAT"):
material_empty_layer.layer_factor_texture(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer 0"):
material.layer_factor_texture_swizzle(0)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer ClearCoat"):
material_empty_layer.layer_factor_texture_swizzle("ClearCoat")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in MaterialLayer.CLEAR_COAT"):
material_empty_layer.layer_factor_texture_swizzle(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer 0"):
material.layer_factor_texture_matrix(0)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer ClearCoat"):
material_empty_layer.layer_factor_texture_matrix("ClearCoat")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in MaterialLayer.CLEAR_COAT"):
material_empty_layer.layer_factor_texture_matrix(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer 0"):
material.layer_factor_texture_coordinates(0)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer ClearCoat"):
material_empty_layer.layer_factor_texture_coordinates("ClearCoat")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in MaterialLayer.CLEAR_COAT"):
material_empty_layer.layer_factor_texture_coordinates(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer 0"):
material.layer_factor_texture_layer(0)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in layer ClearCoat"):
material_empty_layer.layer_factor_texture_layer("ClearCoat")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE not found in MaterialLayer.CLEAR_COAT"):
material_empty_layer.layer_factor_texture_layer(trade.MaterialLayer.CLEAR_COAT)
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in layer 1"):
material.attribute_id(1, "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in layer 1"):
material.attribute_id(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in layer ClearCoat"):
material.attribute_id("ClearCoat", "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in layer ClearCoat"):
material.attribute_id("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in MaterialLayer.CLEAR_COAT"):
material.attribute_id(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in MaterialLayer.CLEAR_COAT"):
material.attribute_id(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "attribute DiffuseTexure not found in the base material"):
material.attribute_id("DiffuseTexure")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.DIFFUSE_TEXTURE not found in the base material"):
material.attribute_id(trade.MaterialAttribute.DIFFUSE_TEXTURE)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in layer 1"):
material.attribute_name(1, 8)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in layer ClearCoat"):
material.attribute_name("ClearCoat", 8)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in MaterialLayer.CLEAR_COAT"):
material.attribute_name(trade.MaterialLayer.CLEAR_COAT, 8)
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 attributes in the base material"):
material.attribute_name(3)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in layer 1"):
material.attribute_type(1, 8)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in layer ClearCoat"):
material.attribute_type("ClearCoat", 8)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in MaterialLayer.CLEAR_COAT"):
material.attribute_type(trade.MaterialLayer.CLEAR_COAT, 8)
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in layer 1"):
material.attribute_type(1, "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in layer ClearCoat"):
material.attribute_type("ClearCoat", "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in MaterialLayer.CLEAR_COAT"):
material.attribute_type(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in layer 1"):
material.attribute_type(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in layer ClearCoat"):
material.attribute_type("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in MaterialLayer.CLEAR_COAT"):
material.attribute_type(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 attributes in the base material"):
material.attribute_type(3)
with self.assertRaisesRegex(KeyError, "attribute DiffuseTexure not found in the base material"):
material.attribute_type("DiffuseTexure")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.DIFFUSE_TEXTURE not found in the base material"):
material.attribute_type(trade.MaterialAttribute.DIFFUSE_TEXTURE)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in layer 1"):
material.attribute(1, 8)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in layer ClearCoat"):
material.attribute("ClearCoat", 8)
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 attributes in MaterialLayer.CLEAR_COAT"):
material.attribute(trade.MaterialLayer.CLEAR_COAT, 8)
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in layer 1"):
material.attribute(1, "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in layer ClearCoat"):
material.attribute("ClearCoat", "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "attribute LayerFactorTextureSwizzle not found in MaterialLayer.CLEAR_COAT"):
material.attribute(trade.MaterialLayer.CLEAR_COAT, "LayerFactorTextureSwizzle")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in layer 1"):
material.attribute(1, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in layer ClearCoat"):
material.attribute("ClearCoat", trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(KeyError, "MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE not found in MaterialLayer.CLEAR_COAT"):
material.attribute(trade.MaterialLayer.CLEAR_COAT, trade.MaterialAttribute.LAYER_FACTOR_TEXTURE_SWIZZLE)
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 attributes in the base material"):
material.attribute(3)
with self.assertRaisesRegex(KeyError, "attribute DiffuseTexure not found in the base material"):
material.attribute("DiffuseTexure")
with self.assertRaisesRegex(KeyError, "MaterialAttribute.DIFFUSE_TEXTURE not found in the base material"):
material.attribute(trade.MaterialAttribute.DIFFUSE_TEXTURE)
python: expose trade.MeshAttributeData. To be eventually used for creating MeshData from scratch.
2 years ago
class MeshAttributeData(unittest.TestCase):
def test_init_1d(self):
a = array.array('H', [3, 7, 16, 29998])
a_refcount = sys.getrefcount(a)
b = trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_SHORT, a)
b_refcount = sys.getrefcount(b)
self.assertEqual(b.name, trade.MeshAttribute.OBJECT_ID)
self.assertEqual(b.format, VertexFormat.UNSIGNED_SHORT)
self.assertEqual(b.array_size, 0)
self.assertEqual(b.morph_target_id, -1)
self.assertIs(b.owner, a)
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
data = b.data
self.assertEqual(data.size, (4, 1))
self.assertEqual(data.stride, (2, 2))
self.assertEqual(data.format, 'H')
self.assertIs(data.owner, a)
# Returns a 2D view always, transpose and take the first element to
# "flatten" it.
self.assertEqual(list(data.transposed(0, 1)[0]), [3, 7, 16, 29998])
# The data reference the original array, not the MeshAttributeData
# instance
self.assertEqual(sys.getrefcount(b), b_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
del b
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
del data
self.assertEqual(sys.getrefcount(a), a_refcount)
def test_init_2d(self):
a = array.array('f', [1.0, 0.0, 0.0,
0.0, -1.0, 0.0])
a_refcount = sys.getrefcount(a)
b = trade.MeshAttributeData(trade.MeshAttribute.NORMAL, VertexFormat.VECTOR3, containers.StridedArrayView1D(a).expanded(0, (2, 3)), morph_target_id=37)
b_refcount = sys.getrefcount(b)
self.assertEqual(b.name, trade.MeshAttribute.NORMAL)
self.assertEqual(b.format, VertexFormat.VECTOR3)
self.assertEqual(b.array_size, 0)
self.assertEqual(b.morph_target_id, 37)
self.assertIs(b.owner, a)
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
data = b.data
self.assertEqual(data.size, (2, 1))
self.assertEqual(data.stride, (12, 12))
self.assertEqual(data.format, '3f')
self.assertIs(data.owner, a)
# Returns a 2D view always, transpose and take the first element to
# "flatten" it.
self.assertEqual(list(data.transposed(0, 1)[0]), [(1.0, 0.0, 0.0), (0.0, -1.0, 0.0)])
# The data reference the original array, not the MeshAttributeData
# instance
self.assertEqual(sys.getrefcount(b), b_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
del b
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
del data
self.assertEqual(sys.getrefcount(a), a_refcount)
def test_init_1d_array(self):
data = array.array('Q', [0x0000ffff66663333, 0x00009999aaaacccc, 0x0000bbbb22227777, 0x00001111eeee8888])
a = trade.MeshAttributeData(trade.MeshAttribute.JOINT_IDS, VertexFormat.UNSIGNED_SHORT, data, array_size=3)
self.assertEqual(a.name, trade.MeshAttribute.JOINT_IDS)
self.assertEqual(a.format, VertexFormat.UNSIGNED_SHORT)
self.assertEqual(a.array_size, 3)
self.assertEqual(a.morph_target_id, -1)
data = a.data
self.assertEqual(data.size, (4, 3))
self.assertEqual(data.stride, (8, 2))
self.assertEqual(data.format, 'H')
# Getting all first, second and third array elements. Assumes Little
# Endian.
self.assertEqual(list(data.transposed(0, 1)[0]), [0x3333, 0xcccc, 0x7777, 0x8888])
self.assertEqual(list(data.transposed(0, 1)[1]), [0x6666, 0xaaaa, 0x2222, 0xeeee])
self.assertEqual(list(data.transposed(0, 1)[2]), [0xffff, 0x9999, 0xbbbb, 0x1111])
def test_init_2d_array(self):
data = array.array('H', [0x3333, 0x6666, 0xffff, 0xcccc, 0xaaaa, 0x9999, 0x7777, 0x2222, 0xbbbb, 0x8888, 0xeeee, 0x1111])
a = trade.MeshAttributeData(trade.MeshAttribute.JOINT_IDS, VertexFormat.UNSIGNED_SHORT, containers.StridedArrayView1D(data).expanded(0, (4, 3)), array_size=3)
self.assertEqual(a.name, trade.MeshAttribute.JOINT_IDS)
self.assertEqual(a.format, VertexFormat.UNSIGNED_SHORT)
self.assertEqual(a.array_size, 3)
self.assertEqual(a.morph_target_id, -1)
data = a.data
self.assertEqual(data.size, (4, 3))
self.assertEqual(data.stride, (6, 2))
self.assertEqual(data.format, 'H')
# Getting all first, second and third array elements
self.assertEqual(list(data.transposed(0, 1)[0]), [0x3333, 0xcccc, 0x7777, 0x8888])
self.assertEqual(list(data.transposed(0, 1)[1]), [0x6666, 0xaaaa, 0x2222, 0xeeee])
self.assertEqual(list(data.transposed(0, 1)[2]), [0xffff, 0x9999, 0xbbbb, 0x1111])
def test_init_1d_invalid(self):
data = array.array('Q', [0, 0, 0])
data_byte = array.array('B', [0, 0, 0])
# To check that messages properly handle the case of no format string
data_byte_no_format = containers.ArrayView(data_byte)
self.assertEqual(containers.StridedArrayView1D(data_byte_no_format).format, None)
with self.assertRaisesRegex(AssertionError, "VertexFormat.UNSIGNED_INT is not a valid format for MeshAttribute.POSITION"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.UNSIGNED_INT, data)
with self.assertRaisesRegex(AssertionError, "data type Q has 8 bytes but VertexFormat.MATRIX3X3B_NORMALIZED expects at least 9"):
trade.MeshAttributeData(trade.MeshAttribute.CUSTOM(57), VertexFormat.MATRIX3X3B_NORMALIZED, data)
with self.assertRaisesRegex(AssertionError, "data type Q has 8 bytes but array of 3 VertexFormat.VECTOR3UB expects at least 9"):
trade.MeshAttributeData(trade.MeshAttribute.CUSTOM(57), VertexFormat.VECTOR3UB, data, array_size=3)
with self.assertRaisesRegex(AssertionError, "data type B has 1 bytes but VertexFormat.UNSIGNED_SHORT expects at least 2"):
trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_SHORT, data_byte_no_format)
with self.assertRaisesRegex(AssertionError, "expected vertex count to fit into 32 bits but got 4294967296"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, containers.StridedArrayView1D(data)[:1].broadcasted(0, 0x100000000))
with self.assertRaisesRegex(AssertionError, "expected stride to fit into 16 bits but got 32768"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, containers.StridedArrayView1D(data)[::4096])
with self.assertRaisesRegex(AssertionError, "expected stride to fit into 16 bits but got -32769"):
trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_BYTE, containers.StridedArrayView1D(data_byte)[::32769].flipped(0))
with self.assertRaisesRegex(AssertionError, "MeshAttribute.POSITION can't be an array attribute"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data, array_size=2)
with self.assertRaisesRegex(AssertionError, "MeshAttribute.JOINT_IDS has to be an array attribute"):
trade.MeshAttributeData(trade.MeshAttribute.JOINT_IDS, VertexFormat.UNSIGNED_INT, data)
with self.assertRaisesRegex(AssertionError, "expected morph target ID to be either -1 or less than 128 but got -2"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data, morph_target_id=-2)
with self.assertRaisesRegex(AssertionError, "expected morph target ID to be either -1 or less than 128 but got 128"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data, morph_target_id=128)
with self.assertRaisesRegex(AssertionError, "morph target not allowed for MeshAttribute.OBJECT_ID"):
trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_INT, data, morph_target_id=3)
def test_init_2d_invalid(self):
data = containers.StridedArrayView1D(array.array('I', [0, 0, 0, 0, 0, 0])).expanded(0, (3, 2))
data_byte = containers.StridedArrayView1D(array.array('B', [0, 0, 0])).expanded(0, (3, 1))
# To check that messages properly handle the case of no format string
data_byte_no_format = containers.StridedArrayView1D(containers.ArrayView(array.array('B', [0, 0, 0]))).expanded(0, (3, 1))
self.assertEqual(data_byte_no_format.format, None)
with self.assertRaisesRegex(AssertionError, "VertexFormat.UNSIGNED_INT is not a valid format for MeshAttribute.POSITION"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.UNSIGNED_INT, data)
with self.assertRaisesRegex(AssertionError, "2-item second dimension of data type I has 8 bytes but VertexFormat.MATRIX3X3B_NORMALIZED expects at least 9"):
trade.MeshAttributeData(trade.MeshAttribute.CUSTOM(57), VertexFormat.MATRIX3X3B_NORMALIZED, data)
with self.assertRaisesRegex(AssertionError, "2-item second dimension of data type I has 8 bytes but array of 3 VertexFormat.VECTOR3UB expects at least 9"):
trade.MeshAttributeData(trade.MeshAttribute.CUSTOM(57), VertexFormat.VECTOR3UB, data, array_size=3)
with self.assertRaisesRegex(AssertionError, "1-item second dimension of data type B has 1 bytes but VertexFormat.UNSIGNED_SHORT expects at least 2"):
trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_SHORT, data_byte_no_format)
with self.assertRaisesRegex(AssertionError, "second view dimension is not contiguous"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3UB, data[::1,::2])
with self.assertRaisesRegex(AssertionError, "expected vertex count to fit into 32 bits but got 4294967296"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data[:1].broadcasted(0, 0x100000000))
with self.assertRaisesRegex(AssertionError, "expected stride to fit into 16 bits but got 32768"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data[::4096])
with self.assertRaisesRegex(AssertionError, "expected stride to fit into 16 bits but got -32769"):
trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_BYTE, data_byte[::32769].flipped(0))
with self.assertRaisesRegex(AssertionError, "MeshAttribute.POSITION can't be an array attribute"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data, array_size=2)
with self.assertRaisesRegex(AssertionError, "MeshAttribute.JOINT_IDS has to be an array attribute"):
trade.MeshAttributeData(trade.MeshAttribute.JOINT_IDS, VertexFormat.UNSIGNED_INT, data)
with self.assertRaisesRegex(AssertionError, "expected morph target ID to be either -1 or less than 128 but got -2"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data, morph_target_id=-2)
with self.assertRaisesRegex(AssertionError, "expected morph target ID to be either -1 or less than 128 but got 128"):
trade.MeshAttributeData(trade.MeshAttribute.POSITION, VertexFormat.VECTOR3B, data, morph_target_id=128)
with self.assertRaisesRegex(AssertionError, "morph target not allowed for MeshAttribute.OBJECT_ID"):
trade.MeshAttributeData(trade.MeshAttribute.OBJECT_ID, VertexFormat.UNSIGNED_INT, data, morph_target_id=3)
def test_data_access_unsupported_format(self):
data = array.array('Q', [0, 0, 0])
a = trade.MeshAttributeData(trade.MeshAttribute.CUSTOM(57), VertexFormat.MATRIX3X2B_NORMALIZED, data)
with self.assertRaisesRegex(NotImplementedError, "access to VertexFormat.MATRIX3X2B_NORMALIZED is not implemented yet, sorry"):
a.data
python: *very* little from Trade.
7 years ago
class MeshData(unittest.TestCase):
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
def test_custom_attribute(self):
# Creating a custom attribute
a = trade.MeshAttribute.CUSTOM(17)
self.assertTrue(a.is_custom)
python: ... and compatibility with pybind11 < 2.6.2 as well.
3 years ago
if hasattr(a, 'value'): # only since pybind11 2.6.2
self.assertEqual(a.value, 32768 + 17)
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
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)
python: ... and compatibility with pybind11 < 2.6.2 as well.
3 years ago
if hasattr(zero, 'value'): # only since pybind11 2.6.2
self.assertEqual(zero.value, 32768)
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
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)
python: ... and compatibility with pybind11 < 2.6.2 as well.
3 years ago
if hasattr(largest, 'value'): # only since pybind11 2.6.2
self.assertEqual(largest.value, 65535)
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
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)
python: ... and compatibility with pybind11 < 2.6.2 as well.
3 years ago
if hasattr(b, 'value'): # only since pybind11 2.6.2
self.assertEqual(b.value, 3)
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
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>")
python: expose mesh import.
7 years ago
def test(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
# This adds extra attributes for joints and weights, don't want
importer.configuration['compatibilitySkinningAttributes'] = False
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: expose mesh import.
7 years ago
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh = importer.mesh(0)
python: expose mesh import.
7 years ago
self.assertEqual(mesh.primitive, MeshPrimitive.TRIANGLES)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
self.assertEqual(mesh.vertex_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: add an ability for referencing owner of trade.*Data memory. This is important in case the data aren't owned by the instance but instead referencing something else, for example the importer, a memory-mapped file or another instance. Will get increasingly important for zero-copy data import.
3 years ago
self.assertIsNone(mesh.owner)
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
# Index properties
self.assertTrue(mesh.is_indexed)
python: avoid an assertion in trade.MeshData.index_count. Emit a Python exception instead.
4 years ago
self.assertEqual(mesh.index_count, 3)
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
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)
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
self.assertEqual(mesh.attribute_count(), 9)
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
self.assertEqual(mesh.attribute_count(morph_target_id=37), 0)
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
# Attribute properties by ID
self.assertEqual(mesh.attribute_name(2), trade.MeshAttribute.POSITION)
# Custom attribute. On deprecated builds there are extra backwards
# compatibility JOINTS and WEIGHTS attributes.
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
if magnum.BUILD_DEPRECATED:
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
self.assertEqual(mesh.attribute_name(6), trade.MeshAttribute.CUSTOM(10))
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
else:
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
self.assertEqual(mesh.attribute_name(6), trade.MeshAttribute.CUSTOM(8))
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
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))
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
self.assertFalse(mesh.has_attribute(trade.MeshAttribute.POSITION, morph_target_id=37))
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
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)
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
self.assertEqual(mesh.attribute_id(trade.MeshAttribute.TEXTURE_COORDINATES, id=1), 4)
python: resolve a test TODO now that we can change plugin configuration.
3 years ago
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)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
def test_index_data_access(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
mesh = importer.mesh(0)
mesh_refcount = sys.getrefcount(mesh)
python: expose trade.MeshData.index_data and .vertex_data. Useful for rudimentary data size stats queries, not much else as the other APIs are not exposed yet.
4 years ago
index_data = mesh.index_data
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
self.assertEqual(len(index_data), 6)
python: expose trade.MeshData.index_data and .vertex_data. Useful for rudimentary data size stats queries, not much else as the other APIs are not exposed yet.
4 years ago
self.assertIs(index_data.owner, mesh)
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1)
del index_data
self.assertEqual(sys.getrefcount(mesh), mesh_refcount)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
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')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
mesh = importer.mesh(0)
mesh_refcount = sys.getrefcount(mesh)
python: expose trade.MeshData.index_data and .vertex_data. Useful for rudimentary data size stats queries, not much else as the other APIs are not exposed yet.
4 years ago
vertex_data = mesh.vertex_data
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
self.assertEqual(len(vertex_data), 84)
python: expose trade.MeshData.index_data and .vertex_data. Useful for rudimentary data size stats queries, not much else as the other APIs are not exposed yet.
4 years ago
self.assertIs(vertex_data.owner, mesh)
self.assertEqual(sys.getrefcount(mesh), mesh_refcount + 1)
del vertex_data
self.assertEqual(sys.getrefcount(mesh), mesh_refcount)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
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)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
def test_indices_access(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh = importer.mesh(0)
mesh_refcount = sys.getrefcount(mesh)
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
position_id = mesh.attribute_id(trade.MeshAttribute.POSITION)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
positions = mesh.attribute(position_id)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
self.assertEqual(positions.size, (3, ))
self.assertEqual(positions.stride, (28, ))
python: have a common header with Python format string definitions. To not have to duplicate these for each and every case, enlarging the surface for potential bugs. Also changing the signatures to number + identifier, instead of identifier repeated number of times. Means the compiler won't be able to deduplicate / overlap the literals in the binary, but is much more maintainable. For Numpy this causes the slices to be reported as actual typed Numpy arrays instead of typeless tuples, which is good I guess? Not sure why that wasn't the case before, or what is the difference, and how it will behave for sparse types such as aligned matrices.
3 years ago
self.assertEqual(positions.format, '3f')
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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)
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
mutable_positions = mesh.mutable_attribute(position_id)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
self.assertEqual(mutable_positions.size, (3, ))
self.assertEqual(mutable_positions.stride, (28, ))
python: have a common header with Python format string definitions. To not have to duplicate these for each and every case, enlarging the surface for potential bugs. Also changing the signatures to number + identifier, instead of identifier repeated number of times. Means the compiler won't be able to deduplicate / overlap the literals in the binary, but is much more maintainable. For Numpy this causes the slices to be reported as actual typed Numpy arrays instead of typeless tuples, which is good I guess? Not sure why that wasn't the case before, or what is the difference, and how it will behave for sparse types such as aligned matrices.
3 years ago
self.assertEqual(mutable_positions.format, '3f')
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
def test_mutable_index_data_access(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
mesh = importer.mesh(0)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
index_data = mesh.index_data
mutable_index_data = mesh.mutable_index_data
# Second index is 2, it's a 16-bit LE number
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
self.assertEqual(index_data[2], 2)
self.assertEqual(mutable_index_data[2], 2)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
mutable_index_data[2] = 76
self.assertEqual(index_data[2], 76)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
def test_mutable_vertex_data_access(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
mesh = importer.mesh(0)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.vertex_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
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
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
self.assertEqual(vertex_data[21], 51)
self.assertEqual(mutable_vertex_data[21], 51)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
python: make ArrayView element access behavior match bytes/bytearray. In the buffer protocol it used to advertise untyped data with B as the format string, but the __getitem__ and __setitem__ were using the char type (implicitly coming from the fact that the type exposed is ArrayView<char>, StridedArrayViewND<char> or their const variants), resulting in the data being treated as characters by Python. Which was extremely annoying and inconsistent with how the bytes and bytearray behaves. Now ArrayView bindings always operate with std::uint8_t, and for StridedArrayView there's a special case for the <char> type, which makes it treated as std::uint8_t as well. Furthermore, to hint that the <char> is "general data", the format string for it is null / None instead of B.
2 years ago
mutable_vertex_data[21] = 76
self.assertEqual(vertex_data[21], 76)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
def test_mutable_indices_access(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh = importer.mesh(0)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh = importer.mesh(0)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
position_id = mesh.attribute_id(trade.MeshAttribute.POSITION)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
positions = mesh.attribute(position_id)
mutable_positions = mesh.mutable_attribute(position_id)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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)
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
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)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
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))
python: support also normalized VertexFormat values. They're unpacked to full floats on element access and packed back from full floats on mutable access, which makes this all very nice and transparent. Yay Python! That's it for now, I'll postpone half-float and matrix types for later when these are actually needed, as it needs extra testing for the aligned variants too.
3 years ago
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)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: support also normalized VertexFormat values. They're unpacked to full floats on element access and packed back from full floats on mutable access, which makes this all very nice and transparent. Yay Python! That's it for now, I'll postpone half-float and matrix types for later when these are actually needed, as it needs extra testing for the aligned variants too.
3 years ago
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))
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
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?)
python: adapt to Trade::DataFlags changes.
3 years ago
self.assertEqual(mesh.index_data_flags, trade.DataFlags.GLOBAL)
self.assertEqual(mesh.vertex_data_flags, trade.DataFlags.GLOBAL)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
with self.assertRaisesRegex(AttributeError, "mesh index data is not mutable"):
mesh.mutable_index_data
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
with self.assertRaisesRegex(AttributeError, "mesh index data is not mutable"):
mesh.mutable_indices
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
with self.assertRaisesRegex(AttributeError, "mesh vertex data is not mutable"):
mesh.mutable_vertex_data
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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)
python: mutable access to trade.MeshData raw index/vertex data. Not much useful on its own, but it's a prep for what comes next.
3 years ago
python: avoid an assertion in trade.MeshData.index_count. Emit a Python exception instead.
4 years ago
def test_nonindexed(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: avoid an assertion in trade.MeshData.index_count. Emit a Python exception instead.
4 years ago
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh = importer.mesh(1)
python: avoid an assertion in trade.MeshData.index_count. Emit a Python exception instead.
4 years ago
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
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
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
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"):
mesh.indices
with self.assertRaisesRegex(AttributeError, "mesh is not indexed"):
mesh.mutable_indices
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
def test_attribute_oob(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh = importer.mesh(0)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
# Access by OOB ID. Deprecated build contains additional 2 backwards
# compatibility skinning attributes.
if magnum.BUILD_DEPRECATED:
indexOutOfRangeMessage = "index 11 out of range for 11 attributes"
else:
indexOutOfRangeMessage = "index 9 out of range for 9 attributes"
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_name(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_id(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_format(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_offset(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_stride(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_array_size(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh.attribute(mesh.attribute_count())
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, indexOutOfRangeMessage):
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh.mutable_attribute(mesh.attribute_count())
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
# Access by nonexistent name
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_id(trade.MeshAttribute.TANGENT)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_format(trade.MeshAttribute.TANGENT)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_offset(trade.MeshAttribute.TANGENT)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_stride(trade.MeshAttribute.TANGENT)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh.attribute_array_size(trade.MeshAttribute.TANGENT)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh.attribute(trade.MeshAttribute.TANGENT)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TANGENT attributes"):
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh.mutable_attribute(trade.MeshAttribute.TANGENT)
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
# Access by existing name + OOB ID
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_id(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_format(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_offset(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_stride(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_array_size(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 2 out of range for 2 MeshAttribute.TEXTURE_COORDINATES attributes"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.mutable_attribute(trade.MeshAttribute.TEXTURE_COORDINATES, id=2)
# Access by existing name + OOB morph target ID
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_id(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_format(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_offset(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_stride(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute_array_size(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.attribute(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "index 0 out of range for 0 MeshAttribute.TEXTURE_COORDINATES attributes in morph target 37"):
python: adapt to Magnum changes re MeshData morph target support.
3 years ago
mesh.mutable_attribute(trade.MeshAttribute.TEXTURE_COORDINATES, morph_target_id=37)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
def test_attribute_access_array(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh = importer.mesh(0)
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
joint_ids_id = mesh.attribute_id(trade.MeshAttribute.JOINT_IDS)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "array attributes not implemented yet, sorry"):
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
mesh.attribute(joint_ids_id)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "array attributes not implemented yet, sorry"):
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
mesh.mutable_attribute(joint_ids_id)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
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')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
custom_attribute = importer.mesh_attribute_for_name("_CUSTOM_MATRIX_ATTRIBUTE");
self.assertIsNotNone(custom_attribute)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
mesh = importer.mesh(0)
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
custom_attribute_id = mesh.attribute_id(custom_attribute)
python: direct access to trade.MeshData indices and attributes. In concrete types. Yes. Well, some of them for now, I still need to sleep on normalized and matrix types, how it makes the most sense to expose those. Oh, and array attributes as well.
3 years ago
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to VertexFormat.MATRIX2X2 is not implemented yet, sorry"):
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
mesh.attribute(custom_attribute_id)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to VertexFormat.MATRIX2X2 is not implemented yet, sorry"):
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
mesh.mutable_attribute(custom_attribute_id)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to VertexFormat.MATRIX2X2 is not implemented yet, sorry"):
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
mesh.attribute(custom_attribute)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to VertexFormat.MATRIX2X2 is not implemented yet, sorry"):
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
mesh.mutable_attribute(custom_attribute)
python: avoid an assertion in trade.MeshData.index_count. Emit a Python exception instead.
4 years ago
python: expose trade.SceneFieldData. Like with MeshAttributeData, to be eventually used for populating scenes from scratch.
2 years ago
class SceneFieldData(unittest.TestCase):
def test_init_1d(self):
a = array.array('Q', [3, 7, 166, 2872])
b = array.array('h', [2, -1, 37, -1])
a_refcount = sys.getrefcount(a)
b_refcount = sys.getrefcount(b)
c = trade.SceneFieldData(trade.SceneField.MESH_MATERIAL,
trade.SceneMappingType.UNSIGNED_LONG, a,
trade.SceneFieldType.SHORT, b,
flags=trade.SceneFieldFlags.MULTI_ENTRY|trade.SceneFieldFlags.ORDERED_MAPPING)
c_refcount = sys.getrefcount(c)
self.assertEqual(c.flags, trade.SceneFieldFlags.MULTI_ENTRY|trade.SceneFieldFlags.ORDERED_MAPPING)
self.assertEqual(c.name, trade.SceneField.MESH_MATERIAL)
self.assertEqual(c.size, 4)
self.assertEqual(c.mapping_type, trade.SceneMappingType.UNSIGNED_LONG)
self.assertEqual(c.field_type, trade.SceneFieldType.SHORT)
self.assertEqual(c.field_array_size, 0)
self.assertIs(c.mapping_owner, a)
self.assertIs(c.field_owner, b)
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
mapping_data = c.mapping_data
self.assertEqual(mapping_data.size, (4,))
self.assertEqual(mapping_data.stride, (8,))
self.assertEqual(mapping_data.format, 'Q')
self.assertIs(mapping_data.owner, a)
self.assertEqual(list(mapping_data), [3, 7, 166, 2872])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
field_data = c.field_data
self.assertEqual(field_data.size, (4, 1))
self.assertEqual(field_data.stride, (2, 2))
self.assertEqual(field_data.format, 'h')
self.assertIs(field_data.owner, b)
# Returns a 2D view always, transpose and take the first element to
# "flatten" it.
self.assertEqual(list(field_data.transposed(0, 1)[0]), [2, -1, 37, -1])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 2)
del c
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
del mapping_data
del field_data
self.assertEqual(sys.getrefcount(a), a_refcount)
self.assertEqual(sys.getrefcount(b), b_refcount)
def test_init_2d(self):
a = array.array('I', [0, 1])
b = array.array('f', [1.0, 0.0, 0.0,
0.0, -1.0, 0.0])
a_refcount = sys.getrefcount(a)
b_refcount = sys.getrefcount(b)
c = trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_INT, a,
trade.SceneFieldType.VECTOR3, containers.StridedArrayView1D(b).expanded(0, (2, 3)),
flags=trade.SceneFieldFlags.IMPLICIT_MAPPING)
c_refcount = sys.getrefcount(c)
self.assertEqual(c.flags, trade.SceneFieldFlags.IMPLICIT_MAPPING)
self.assertEqual(c.name, trade.SceneField.TRANSLATION)
self.assertEqual(c.size, 2)
self.assertEqual(c.mapping_type, trade.SceneMappingType.UNSIGNED_INT)
self.assertEqual(c.field_type, trade.SceneFieldType.VECTOR3)
self.assertEqual(c.field_array_size, 0)
self.assertIs(c.mapping_owner, a)
self.assertIs(c.field_owner, b)
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
mapping_data = c.mapping_data
self.assertEqual(mapping_data.size, (2,))
self.assertEqual(mapping_data.stride, (4,))
self.assertEqual(mapping_data.format, 'I')
self.assertIs(mapping_data.owner, a)
self.assertEqual(list(mapping_data), [0, 1])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
field_data = c.field_data
self.assertEqual(field_data.size, (2, 1))
self.assertEqual(field_data.stride, (12, 12))
self.assertEqual(field_data.format, '3f')
self.assertIs(field_data.owner, b)
# Returns a 2D view always, transpose and take the first element to
# "flatten" it.
self.assertEqual(list(field_data.transposed(0, 1)[0]), [(1.0, 0.0, 0.0), (0.0, -1.0, 0.0)])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 2)
del c
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
del mapping_data
del field_data
self.assertEqual(sys.getrefcount(a), a_refcount)
self.assertEqual(sys.getrefcount(b), b_refcount)
def test_init_1d_array(self):
a = array.array('B', [3, 7, 166, 72])
b = array.array('Q', [0x0000ffff66663333, 0x00009999aaaacccc, 0x0000bbbb22227777, 0x00001111eeee8888])
c = trade.SceneFieldData(trade.SceneField.CUSTOM(666),
trade.SceneMappingType.UNSIGNED_BYTE, a,
trade.SceneFieldType.UNSIGNED_SHORT, b,
field_array_size=3)
self.assertEqual(c.flags, trade.SceneFieldFlags.NONE)
self.assertEqual(c.name, trade.SceneField.CUSTOM(666))
self.assertEqual(c.size, 4)
self.assertEqual(c.mapping_type, trade.SceneMappingType.UNSIGNED_BYTE)
self.assertEqual(c.field_type, trade.SceneFieldType.UNSIGNED_SHORT)
self.assertEqual(c.field_array_size, 3)
mapping_data = c.mapping_data
self.assertEqual(mapping_data.size, (4,))
self.assertEqual(mapping_data.stride, (1,))
self.assertEqual(mapping_data.format, 'B')
self.assertEqual(list(mapping_data), [3, 7, 166, 72])
field_data = c.field_data
self.assertEqual(field_data.size, (4, 3))
self.assertEqual(field_data.stride, (8, 2))
self.assertEqual(field_data.format, 'H')
# Getting all first, second and third array elements. Assumes Little
# Endian.
self.assertEqual(list(field_data.transposed(0, 1)[0]), [0x3333, 0xcccc, 0x7777, 0x8888])
self.assertEqual(list(field_data.transposed(0, 1)[1]), [0x6666, 0xaaaa, 0x2222, 0xeeee])
self.assertEqual(list(field_data.transposed(0, 1)[2]), [0xffff, 0x9999, 0xbbbb, 0x1111])
def test_init_2d_array(self):
a = array.array('B', [3, 7, 166, 72])
b = array.array('H', [0x3333, 0x6666, 0xffff, 0xcccc, 0xaaaa, 0x9999, 0x7777, 0x2222, 0xbbbb, 0x8888, 0xeeee, 0x1111])
c = trade.SceneFieldData(trade.SceneField.CUSTOM(666),
trade.SceneMappingType.UNSIGNED_BYTE, a,
trade.SceneFieldType.UNSIGNED_SHORT, containers.StridedArrayView1D(b).expanded(0, (4, 3)),
field_array_size=3)
self.assertEqual(c.flags, trade.SceneFieldFlags.NONE)
self.assertEqual(c.name, trade.SceneField.CUSTOM(666))
self.assertEqual(c.size, 4)
self.assertEqual(c.mapping_type, trade.SceneMappingType.UNSIGNED_BYTE)
self.assertEqual(c.field_type, trade.SceneFieldType.UNSIGNED_SHORT)
self.assertEqual(c.field_array_size, 3)
mapping_data = c.mapping_data
self.assertEqual(mapping_data.size, (4,))
self.assertEqual(mapping_data.stride, (1,))
self.assertEqual(mapping_data.format, 'B')
self.assertEqual(list(mapping_data), [3, 7, 166, 72])
field_data = c.field_data
self.assertEqual(field_data.size, (4, 3))
self.assertEqual(field_data.stride, (6, 2))
self.assertEqual(field_data.format, 'H')
# Getting all first, second and third array elements. Assumes Little
# Endian.
self.assertEqual(list(field_data.transposed(0, 1)[0]), [0x3333, 0xcccc, 0x7777, 0x8888])
self.assertEqual(list(field_data.transposed(0, 1)[1]), [0x6666, 0xaaaa, 0x2222, 0xeeee])
self.assertEqual(list(field_data.transposed(0, 1)[2]), [0xffff, 0x9999, 0xbbbb, 0x1111])
def test_init_bit_1d(self):
a = array.array('H', [3, 7, 166, 2872])
b = array.array('b', [1, 0, 1, 0])
a_refcount = sys.getrefcount(a)
b_refcount = sys.getrefcount(b)
c = trade.SceneFieldData(trade.SceneField.CUSTOM(1337),
trade.SceneMappingType.UNSIGNED_SHORT, a,
containers.StridedArrayView1D(b).slice_bit(0),
flags=trade.SceneFieldFlags.MULTI_ENTRY|trade.SceneFieldFlags.ORDERED_MAPPING)
c_refcount = sys.getrefcount(c)
self.assertEqual(c.flags, trade.SceneFieldFlags.MULTI_ENTRY|trade.SceneFieldFlags.ORDERED_MAPPING)
self.assertEqual(c.name, trade.SceneField.CUSTOM(1337))
self.assertEqual(c.size, 4)
self.assertEqual(c.mapping_type, trade.SceneMappingType.UNSIGNED_SHORT)
self.assertEqual(c.field_type, trade.SceneFieldType.BIT)
self.assertEqual(c.field_array_size, 0)
self.assertIs(c.mapping_owner, a)
self.assertIs(c.field_owner, b)
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
mapping_data = c.mapping_data
self.assertEqual(mapping_data.size, (4,))
self.assertEqual(mapping_data.stride, (2,))
self.assertEqual(mapping_data.format, 'H')
self.assertIs(mapping_data.owner, a)
self.assertEqual(list(mapping_data), [3, 7, 166, 2872])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
field_data = c.field_data
self.assertEqual(field_data.size, (4, 1))
self.assertEqual(field_data.offset, 0)
self.assertEqual(field_data.stride, (8, 1))
self.assertIs(field_data.owner, b)
# Returns a 2D view always, transpose and take the first element to
# "flatten" it.
self.assertEqual(list(field_data.transposed(0, 1)[0]), [True, False, True, False])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 2)
del c
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
del mapping_data
del field_data
self.assertEqual(sys.getrefcount(a), a_refcount)
self.assertEqual(sys.getrefcount(b), b_refcount)
def test_init_bit_2d(self):
a = array.array('H', [3, 7, 166, 2872])
b = containers.BitArray.value_init(4*2)
b[0] = True
b[1] = True
b[4] = True
b[7] = True
a_refcount = sys.getrefcount(a)
b_refcount = sys.getrefcount(b)
c = trade.SceneFieldData(trade.SceneField.CUSTOM(1337),
trade.SceneMappingType.UNSIGNED_SHORT, a,
containers.StridedBitArrayView1D(b).expanded(0, (4, 2)),
flags=trade.SceneFieldFlags.MULTI_ENTRY|trade.SceneFieldFlags.ORDERED_MAPPING)
c_refcount = sys.getrefcount(c)
self.assertEqual(c.flags, trade.SceneFieldFlags.MULTI_ENTRY|trade.SceneFieldFlags.ORDERED_MAPPING)
self.assertEqual(c.name, trade.SceneField.CUSTOM(1337))
self.assertEqual(c.size, 4)
self.assertEqual(c.mapping_type, trade.SceneMappingType.UNSIGNED_SHORT)
self.assertEqual(c.field_type, trade.SceneFieldType.BIT)
self.assertEqual(c.field_array_size, 2)
self.assertIs(c.mapping_owner, a)
self.assertIs(c.field_owner, b)
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
mapping_data = c.mapping_data
self.assertEqual(mapping_data.size, (4,))
self.assertEqual(mapping_data.stride, (2,))
self.assertEqual(mapping_data.format, 'H')
self.assertIs(mapping_data.owner, a)
self.assertEqual(list(mapping_data), [3, 7, 166, 2872])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
field_data = c.field_data
self.assertEqual(field_data.size, (4, 2))
self.assertEqual(field_data.offset, 0)
self.assertEqual(field_data.stride, (2, 1))
self.assertIs(field_data.owner, b)
# Getting all first and second array elements
self.assertEqual(list(field_data.transposed(0, 1)[0]), [True, False, True, False])
self.assertEqual(list(field_data.transposed(0, 1)[1]), [True, False, False, True])
# The data reference the original array, not the SceneFieldData
# instance
self.assertEqual(sys.getrefcount(c), c_refcount)
self.assertEqual(sys.getrefcount(a), a_refcount + 2)
self.assertEqual(sys.getrefcount(b), b_refcount + 2)
del c
self.assertEqual(sys.getrefcount(a), a_refcount + 1)
self.assertEqual(sys.getrefcount(b), b_refcount + 1)
del mapping_data
del field_data
self.assertEqual(sys.getrefcount(a), a_refcount)
self.assertEqual(sys.getrefcount(b), b_refcount)
def test_init_1d_invalid(self):
data = array.array('Q', [0, 0, 0])
data_byte = array.array('B', [0, 0, 0])
# To check that messages properly handle the case of no format string
data_byte_no_format = containers.ArrayView(data_byte)
self.assertEqual(containers.StridedArrayView1D(data_byte_no_format).format, None)
with self.assertRaisesRegex(AssertionError, "expected SceneField.TRANSLATION mapping and field view to have the same size but got 2 and 3"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data[:2],
trade.SceneFieldType.VECTOR2, data)
with self.assertRaisesRegex(AssertionError, "SceneFieldType.UNSIGNED_SHORT is not a valid type for SceneField.TRANSLATION"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_LONG, data,
trade.SceneFieldType.UNSIGNED_SHORT, data)
with self.assertRaisesRegex(AssertionError, "data type B has 1 bytes but SceneMappingType.UNSIGNED_SHORT expects at least 2"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data_byte,
trade.SceneFieldType.VECTOR2, data)
with self.assertRaisesRegex(AssertionError, "data type B has 1 bytes but SceneMappingType.UNSIGNED_SHORT expects at least 2"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data_byte_no_format,
trade.SceneFieldType.VECTOR2, data)
with self.assertRaisesRegex(AssertionError, "data type Q has 8 bytes but SceneFieldType.VECTOR3 expects at least 12"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data,
trade.SceneFieldType.VECTOR3, data)
with self.assertRaisesRegex(AssertionError, "data type Q has 8 bytes but array of 3 SceneFieldType.FLOAT expects at least 12"):
trade.SceneFieldData(trade.SceneField.CUSTOM(76),
trade.SceneMappingType.UNSIGNED_SHORT, data,
trade.SceneFieldType.FLOAT, data, field_array_size=3)
with self.assertRaisesRegex(AssertionError, "data type B has 1 bytes but SceneFieldType.SHORT expects at least 2"):
trade.SceneFieldData(trade.SceneField.MESH_MATERIAL,
trade.SceneMappingType.UNSIGNED_INT, data,
trade.SceneFieldType.SHORT, data_byte_no_format)
with self.assertRaisesRegex(AssertionError, "expected mapping view stride to fit into 16 bits but got 32768"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, containers.StridedArrayView1D(data)[::4096],
trade.SceneFieldType.VECTOR2, data[:1])
with self.assertRaisesRegex(AssertionError, "expected mapping view stride to fit into 16 bits but got -32769"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_BYTE, containers.StridedArrayView1D(data_byte)[::32769].flipped(0),
trade.SceneFieldType.VECTOR2, data[:1])
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got 32768"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data[:1],
trade.SceneFieldType.VECTOR2, containers.StridedArrayView1D(data)[::4096])
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got -32769"):
trade.SceneFieldData(trade.SceneField.CAMERA,
trade.SceneMappingType.UNSIGNED_SHORT, data[:1],
trade.SceneFieldType.UNSIGNED_BYTE, containers.StridedArrayView1D(data_byte)[::32769].flipped(0))
with self.assertRaisesRegex(AssertionError, "SceneField.MESH can't be an array field"):
trade.SceneFieldData(trade.SceneField.MESH,
trade.SceneMappingType.UNSIGNED_SHORT, data,
trade.SceneFieldType.UNSIGNED_SHORT, data, field_array_size=3)
with self.assertRaisesRegex(AssertionError, "can't pass SceneFieldFlags.MULTI_ENTRY for a SceneField.TRANSLATION view of SceneFieldType.VECTOR2"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_LONG, data,
trade.SceneFieldType.VECTOR2, data, flags=trade.SceneFieldFlags.MULTI_ENTRY)
with self.assertRaisesRegex(AssertionError, "use a string constructor for SceneFieldType.STRING_OFFSET16"):
trade.SceneFieldData(trade.SceneField.CUSTOM(333),
trade.SceneMappingType.UNSIGNED_LONG, data,
trade.SceneFieldType.STRING_OFFSET16, data)
with self.assertRaisesRegex(AssertionError, "use a bit constructor for SceneFieldType.BIT"):
trade.SceneFieldData(trade.SceneField.CUSTOM(333),
trade.SceneMappingType.UNSIGNED_LONG, data,
trade.SceneFieldType.BIT, data)
def test_init_2d_invalid(self):
data_1d = array.array('Q', [0, 0, 0])
data = containers.StridedArrayView1D(array.array('I', [0, 0, 0, 0, 0, 0])).expanded(0, (3, 2))
data_byte = containers.StridedArrayView1D(array.array('B', [0, 0, 0])).expanded(0, (3, 1))
# To check that messages properly handle the case of no format string
data_byte_no_format = containers.StridedArrayView1D(containers.ArrayView(array.array('B', [0, 0, 0]))).expanded(0, (3, 1))
self.assertEqual(data_byte_no_format.format, None)
with self.assertRaisesRegex(AssertionError, "expected SceneField.TRANSLATION mapping and field view to have the same size but got 2 and 3"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data_1d[:2],
trade.SceneFieldType.VECTOR2, data)
with self.assertRaisesRegex(AssertionError, "SceneFieldType.UNSIGNED_SHORT is not a valid type for SceneField.TRANSLATION"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_LONG, data_1d,
trade.SceneFieldType.UNSIGNED_SHORT, data)
# SceneMappingType size checks are shared with the 1D variant, not
# testing here again
with self.assertRaisesRegex(AssertionError, "2-item second dimension of data type I has 8 bytes but SceneFieldType.VECTOR3 expects at least 12"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data_1d,
trade.SceneFieldType.VECTOR3, data)
with self.assertRaisesRegex(AssertionError, "2-item second dimension of data type I has 8 bytes but array of 3 SceneFieldType.FLOAT expects at least 12"):
trade.SceneFieldData(trade.SceneField.CUSTOM(76),
trade.SceneMappingType.UNSIGNED_SHORT, data_1d,
trade.SceneFieldType.FLOAT, data, field_array_size=3)
with self.assertRaisesRegex(AssertionError, "1-item second dimension of data type B has 1 bytes but SceneFieldType.SHORT expects at least 2"):
trade.SceneFieldData(trade.SceneField.MESH_MATERIAL,
trade.SceneMappingType.UNSIGNED_INT, data_1d,
trade.SceneFieldType.SHORT, data_byte_no_format)
with self.assertRaisesRegex(AssertionError, "second field view dimension is not contiguous"):
trade.SceneFieldData(trade.SceneField.MESH,
trade.SceneMappingType.UNSIGNED_SHORT, data_1d,
trade.SceneFieldType.UNSIGNED_SHORT, data[::1,::2])
# SceneMappingType stride checks are shared with the 1D variant, not
# testing here again
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got 32768"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_SHORT, data_1d[:1],
trade.SceneFieldType.VECTOR2, data[::4096])
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got -32769"):
trade.SceneFieldData(trade.SceneField.CAMERA,
trade.SceneMappingType.UNSIGNED_SHORT, data_1d[:1],
trade.SceneFieldType.UNSIGNED_BYTE, data_byte[::32769].flipped(0))
with self.assertRaisesRegex(AssertionError, "SceneField.MESH can't be an array field"):
trade.SceneFieldData(trade.SceneField.MESH,
trade.SceneMappingType.UNSIGNED_SHORT, data_1d,
trade.SceneFieldType.UNSIGNED_SHORT, data, field_array_size=3)
with self.assertRaisesRegex(AssertionError, "can't pass SceneFieldFlags.MULTI_ENTRY for a SceneField.TRANSLATION view of SceneFieldType.VECTOR2"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_LONG, data_1d,
trade.SceneFieldType.VECTOR2, data, flags=trade.SceneFieldFlags.MULTI_ENTRY)
with self.assertRaisesRegex(AssertionError, "use a string constructor for SceneFieldType.STRING_OFFSET16"):
trade.SceneFieldData(trade.SceneField.CUSTOM(333),
trade.SceneMappingType.UNSIGNED_LONG, data_1d,
trade.SceneFieldType.STRING_OFFSET16, data)
with self.assertRaisesRegex(AssertionError, "use a bit constructor for SceneFieldType.BIT"):
trade.SceneFieldData(trade.SceneField.CUSTOM(333),
trade.SceneMappingType.UNSIGNED_LONG, data_1d,
trade.SceneFieldType.BIT, data)
def test_init_bit_1d_invalid(self):
data = array.array('Q', [0, 0, 0])
data_bits = containers.BitArray.value_init(3)
with self.assertRaisesRegex(AssertionError, "expected SceneField.CUSTOM\\(33\\) mapping and field view to have the same size but got 2 and 3"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_SHORT, data[:2],
data_bits)
with self.assertRaisesRegex(AssertionError, "SceneFieldType.BIT is not a valid type for SceneField.TRANSLATION"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_LONG, data,
data_bits)
# SceneMappingType size and stride checks are shared with the non-bit
# variant, not testing here again
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got 32768"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_SHORT, data[:1],
containers.StridedBitArrayView1D(data_bits)[::32768])
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got -32769"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_SHORT, data[:1],
containers.StridedBitArrayView1D(data_bits)[::32769].flipped(0))
with self.assertRaisesRegex(AssertionError, "can't pass SceneFieldFlags.OFFSET_ONLY for a SceneField.CUSTOM\\(33\\) view of SceneFieldType.BIT"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_LONG, data,
data_bits, flags=trade.SceneFieldFlags.OFFSET_ONLY)
def test_init_bit_2d_invalid(self):
data = array.array('Q', [0, 0, 0])
data_bits = containers.StridedBitArrayView1D(containers.BitArray.value_init(3*2)).expanded(0, (3, 2))
data_bits_one_element = containers.StridedBitArrayView1D(containers.BitArray.value_init(3)).expanded(0, (3, 1))
with self.assertRaisesRegex(AssertionError, "expected SceneField.CUSTOM\\(33\\) mapping and field view to have the same size but got 2 and 3"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_SHORT, data[:2],
data_bits)
with self.assertRaisesRegex(AssertionError, "SceneFieldType.BIT is not a valid type for SceneField.TRANSLATION"):
trade.SceneFieldData(trade.SceneField.TRANSLATION,
trade.SceneMappingType.UNSIGNED_LONG, data,
data_bits)
# SceneMappingType size and stride checks are shared with the non-bit
# variant, not testing here again
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got 32768"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_SHORT, data[:1],
data_bits[::16384])
with self.assertRaisesRegex(AssertionError, "expected field view stride to fit into 16 bits but got -32769"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_SHORT, data[:1],
data_bits_one_element[::32769].flipped(0))
with self.assertRaisesRegex(AssertionError, "can't pass SceneFieldFlags.OFFSET_ONLY for a SceneField.CUSTOM\\(33\\) view of SceneFieldType.BIT"):
trade.SceneFieldData(trade.SceneField.CUSTOM(33),
trade.SceneMappingType.UNSIGNED_LONG, data,
data_bits,
flags=trade.SceneFieldFlags.OFFSET_ONLY)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
self.assertEqual(scene.field_count, 8)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
# 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)
python: add an ability for referencing owner of trade.*Data memory. This is important in case the data aren't owned by the instance but instead referencing something else, for example the importer, a memory-mapped file or another instance. Will get increasingly important for zero-copy data import.
3 years ago
self.assertIsNone(scene.owner)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
# 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?
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(scene.field_flags(2), trade.SceneFieldFlags.NONE)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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?
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(scene.field_flags(trade.SceneField.PARENT), trade.SceneFieldFlags.NONE)
python: accidentally didn't test trade.SceneData.field_type() w/ an enum.
3 years ago
self.assertEqual(scene.field_type(trade.SceneField.CUSTOM(1)), trade.SceneFieldType.STRING_OFFSET32)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
scene_field_yes = importer.scene_field_for_name('yes')
self.assertIsNotNone(scene_field_yes)
yes_id = scene.field_id(scene_field_yes)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
translations = scene.field(translation_id)
python: support bit field access in SceneData.
3 years ago
self.assertIsInstance(translations, containers.StridedArrayView1D)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
self.assertIsInstance(cameras, containers.StridedArrayView1D)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
yeses1 = scene.field(scene_field_yes)
yeses2 = scene.field(yes_id)
self.assertIsInstance(yeses1, containers.StridedBitArrayView1D)
self.assertIsInstance(yeses2, containers.StridedBitArrayView1D)
self.assertEqual(yeses1.size, (2, ))
self.assertEqual(yeses2.size, (2, ))
self.assertEqual(yeses1.stride, (1, ))
self.assertEqual(yeses2.stride, (1, ))
self.assertEqual(list(yeses1), [True, False])
self.assertEqual(list(yeses2), [True, False])
self.assertIs(yeses1.owner, scene)
self.assertIs(yeses2.owner, scene)
self.assertEqual(sys.getrefcount(scene), scene_refcount + 2)
del yeses1
del yeses2
self.assertEqual(sys.getrefcount(scene), scene_refcount)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
mutable_translations = scene.mutable_field(translation_id)
python: support bit field access in SceneData.
3 years ago
self.assertIsInstance(mutable_translations, containers.MutableStridedArrayView1D)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
self.assertIsInstance(mutable_cameras, containers.MutableStridedArrayView1D)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
mutable_yeses1 = scene.mutable_field(scene_field_yes)
mutable_yeses2 = scene.mutable_field(yes_id)
self.assertIsInstance(mutable_yeses1, containers.MutableStridedBitArrayView1D)
self.assertIsInstance(mutable_yeses2, containers.MutableStridedBitArrayView1D)
self.assertEqual(mutable_yeses1.size, (2, ))
self.assertEqual(mutable_yeses2.size, (2, ))
self.assertEqual(mutable_yeses1.stride, (1, ))
self.assertEqual(mutable_yeses2.stride, (1, ))
self.assertEqual(list(mutable_yeses1), [True, False])
self.assertEqual(list(mutable_yeses2), [True, False])
self.assertIs(mutable_yeses1.owner, scene)
self.assertIs(mutable_yeses2.owner, scene)
self.assertEqual(sys.getrefcount(scene), scene_refcount + 2)
del mutable_yeses1
del mutable_yeses2
self.assertEqual(sys.getrefcount(scene), scene_refcount)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(scene.data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(scene.data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
scene_field_yes = importer.scene_field_for_name('yes')
self.assertIsNotNone(scene_field_yes)
yes_id = scene.field_id(scene_field_yes)
yeses1 = scene.field(scene_field_yes)
yeses2 = scene.field(yes_id)
mutable_yeses1 = scene.mutable_field(scene_field_yes)
mutable_yeses2 = scene.mutable_field(yes_id)
self.assertEqual(yeses1[0], True)
self.assertEqual(yeses2[1], False)
self.assertEqual(mutable_yeses1[0], True)
self.assertEqual(mutable_yeses2[1], False)
mutable_yeses1[0] = False
mutable_yeses2[1] = True
self.assertEqual(yeses1[0], False)
self.assertEqual(yeses2[1], True)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: fix inconsistent naming of Trade enum sets. They should be named after the plural EnumSet, not the C++ enum. That was already done for the enums in the primitives library as well as all shader flags, but not here. They should all also contain a NONE value for an empty set. Breaking change, sorry. To avoid similar mistakes in the future, this is now documented in the API Conventions page.
3 years ago
self.assertEqual(scene.data_flags, trade.DataFlags.OWNED|trade.DataFlags.MUTABLE)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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):
python: test SceneData mutable access failures now that it's possible.
3 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
scene = scenetools.filter_except_fields(importer.scene(0), [trade.SceneField.SKIN])
self.assertEqual(scene.data_flags, trade.DataFlags.NONE)
with self.assertRaisesRegex(AttributeError, "scene data is not mutable"):
scene.mutable_mapping(0)
with self.assertRaisesRegex(AttributeError, "scene data is not mutable"):
scene.mutable_mapping(trade.SceneField.PARENT)
with self.assertRaisesRegex(AttributeError, "scene data is not mutable"):
scene.mutable_field(0)
with self.assertRaisesRegex(AttributeError, "scene data is not mutable"):
scene.mutable_field(trade.SceneField.PARENT)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_name(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_flags(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_type(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_size(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_array_size(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.has_field_object(scene.field_count, 0)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(scene.field_count, 0)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mapping(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mutable_mapping(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.field(scene.field_count)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 8 out of range for 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mutable_field(scene.field_count)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
# Access by nonexistent field name
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_id(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_flags(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_type(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_size(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_array_size(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.has_field_object(trade.SceneField.SCALING, 0)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(trade.SceneField.SCALING, 0)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mapping(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mutable_mapping(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.field(trade.SceneField.SCALING)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "SceneField.SCALING not found among 8 fields"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mutable_field(trade.SceneField.SCALING)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
# OOB object ID
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 4 out of range for 4 objects"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.has_field_object(0, 4) # PARENT
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 4 out of range for 4 objects"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.has_field_object(trade.SceneField.PARENT, 4)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 4 out of range for 4 objects"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(0, 4) # PARENT
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 4 out of range for 4 objects"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(trade.SceneField.PARENT, 4)
# Lookup error
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(LookupError, "object 1 not found in field SceneField.CAMERA starting at offset 0"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(4, 1) # CAMERA
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(LookupError, "object 1 not found in field SceneField.CAMERA starting at offset 0"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(trade.SceneField.CAMERA, 1)
# Lookup error due to field offset being at the end
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(LookupError, "object 1 not found in field SceneField.PARENT starting at offset 4"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(0, 1, scene.field_size(0)) # PARENT
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(LookupError, "object 1 not found in field SceneField.PARENT starting at offset 4"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(trade.SceneField.PARENT, 1, scene.field_size(trade.SceneField.PARENT))
# OOB field offset (offset == size is allowed, tested above)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "offset 5 out of range for a field of size 4"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(0, 1, scene.field_size(0) + 1) # PARENT
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "offset 5 out of range for a field of size 4"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
scene.field_object_offset(trade.SceneField.PARENT, 1, scene.field_size(trade.SceneField.PARENT) + 1)
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
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)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to SceneFieldType.STRING_OFFSET32 is not implemented yet, sorry"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.field(string_field_id)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to SceneFieldType.STRING_OFFSET32 is not implemented yet, sorry"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mutable_field(string_field_id)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to SceneFieldType.STRING_OFFSET32 is not implemented yet, sorry"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.field(string_field)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(NotImplementedError, "access to SceneFieldType.STRING_OFFSET32 is not implemented yet, sorry"):
python: data access in trade.SceneData. Just regular boring code, all the cool stuff was invented for MeshData already.
3 years ago
scene.mutable_field(string_field)
python: haha whoops?
3 years ago
class TextureData(unittest.TestCase):
python: expose trade.TextureData and related importer APIs.
3 years ago
def test(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
texture = importer.texture("A texture")
self.assertEqual(texture.type, trade.TextureType.TEXTURE2D)
self.assertEqual(texture.minification_filter, SamplerFilter.NEAREST)
self.assertEqual(texture.magnification_filter, SamplerFilter.LINEAR)
self.assertEqual(texture.mipmap_filter, SamplerMipmap.NEAREST)
self.assertEqual(texture.wrapping, (SamplerWrapping.MIRRORED_REPEAT, SamplerWrapping.CLAMP_TO_EDGE, SamplerWrapping.REPEAT))
self.assertEqual(texture.image, 1)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
class Importer(unittest.TestCase):
python: expose pluginmanager.AbstractPlugin. Will contain functions that are not related to the actual subclass.
3 years ago
def test_manager(self):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
manager = trade.ImporterManager()
python: explicitly test all pluginmanager.AbstractManager interfaces.
3 years ago
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)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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')
python: expose pluginmanager.AbstractPlugin. Will contain functions that are not related to the actual subclass.
3 years ago
def test(self):
python: expose static AbstractPlugin properties as well.
3 years ago
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')
python: expose pluginmanager.AbstractPlugin. Will contain functions that are not related to the actual subclass.
3 years ago
self.assertEqual(importer.plugin, 'StbImageImporter')
python: expose trade.Abstract{Importer,Converter}.features and .flags. Right now the importer/converter APIs are not checked against the features so using them wrong will assert and make Python die. But there are at least the enums exposed now so it's possible to prevent the assert.
3 years ago
self.assertEqual(importer.features, trade.ImporterFeatures.OPEN_DATA)
self.assertEqual(importer.flags, trade.ImporterFlags.NONE)
importer.flags = trade.ImporterFlags.VERBOSE
self.assertEqual(importer.flags, trade.ImporterFlags.VERBOSE)
python: expose pluginmanager.AbstractPlugin. Will contain functions that are not related to the actual subclass.
3 years ago
python: explicitly test all pluginmanager.AbstractManager interfaces.
3 years ago
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)
python: expose pluginmanager.AbstractManager.set_preferred_plugins(). It used to take an initializer list, not anymore. Will test this better once I have to build e.g. AssimpImporter for some other reason -- then I can use this function to prefer it for loading glTFs and see how that manages.
3 years ago
def test_set_preferred_plugins(self):
manager = trade.ImporterManager()
python: resolve a test TODO now that we have plugin metadata access.
3 years ago
# TGA importer is loaded directly
importer = manager.load_and_instantiate('TgaImporter')
self.assertEqual(importer.metadata.name, 'TgaImporter')
python: expose pluginmanager.AbstractManager.set_preferred_plugins(). It used to take an initializer list, not anymore. Will test this better once I have to build e.g. AssimpImporter for some other reason -- then I can use this function to prefer it for loading glTFs and see how that manages.
3 years ago
manager.set_preferred_plugins('TgaImporter', ['StbImageImporter', 'DevIlImageImporter'])
python: resolve a test TODO now that we have plugin metadata access.
3 years ago
# TGA importer is loaded from the preferred implementation
importer = manager.load_and_instantiate('TgaImporter')
self.assertEqual(importer.metadata.name, 'StbImageImporter')
python: expose pluginmanager.AbstractManager.set_preferred_plugins(). It used to take an initializer list, not anymore. Will test this better once I have to build e.g. AssimpImporter for some other reason -- then I can use this function to prefer it for loading glTFs and see how that manages.
3 years ago
def test_set_preferred_plugins_alias_not_found(self):
manager = trade.ImporterManager()
with self.assertRaises(KeyError):
manager.set_preferred_plugins('ApngImporter', [])
python: expose pluginmanager.AbstractManager.register_external_manager(). And *now* it's possible to use scene converter plugins.
3 years ago
def test_register_external_manager(self):
# This scenario is stupid in practice, but want to test it on the
# Importer API for consistency
converter_manager = trade.ImageConverterManager()
converter_manager_refcount = sys.getrefcount(converter_manager)
manager = trade.ImporterManager()
manager.register_external_manager(converter_manager)
self.assertEqual(sys.getrefcount(converter_manager), converter_manager_refcount + 1)
del manager
self.assertEqual(sys.getrefcount(converter_manager), converter_manager_refcount)
python: expose pluginmanager.PluginMetadata.
3 years ago
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)
python: expose plugin configuration as well. In both PluginMetadata and AbstractPlugin itself. This makes the pluginmanager module depend on the utility module (which currently contains just the Configuration bindings).
3 years ago
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
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
def test_no_file_opened(self):
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
self.assertFalse(importer.is_opened)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
importer.mesh_count
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
importer.mesh_level_count(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
importer.mesh_for_name('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
importer.mesh_name(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
importer.mesh(0)
python: test also named AbstractImporter APIs with no file opened. Code coverage says red!
3 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.mesh('')
python: expose mesh import.
7 years ago
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.material_count
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.material_for_name('')
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.material_name(0)
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.material(0)
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.material('')
python: expose trade.TextureData and related importer APIs.
3 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.texture_count
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.texture_for_name('')
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.texture_name(0)
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.texture(0)
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.texture('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image1d_count
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image2d_count
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image3d_count
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose trade.abstractImporter.imageXd_level_count().
6 years ago
importer.image1d_level_count(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose trade.abstractImporter.imageXd_level_count().
6 years ago
importer.image2d_level_count(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose trade.abstractImporter.imageXd_level_count().
6 years ago
importer.image3d_level_count(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image1d_for_name('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image2d_for_name('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image3d_for_name('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image1d_name(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image2d_name(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image3d_name(0)
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image1d(0)
python: test also named AbstractImporter APIs with no file opened. Code coverage says red!
3 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.image1d('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image2d(0)
python: test also named AbstractImporter APIs with no file opened. Code coverage says red!
3 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.image2d('')
python: use AssertionError for trade.AbstractImporter usage errors. Because using RuntimeError conflates with import failures. Also update and fix docs to not show ValueError for where IndexError should be.
4 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
importer.image3d(0)
python: test also named AbstractImporter APIs with no file opened. Code coverage says red!
3 years ago
with self.assertRaisesRegex(AssertionError, "no file opened"):
importer.image3d('')
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
def test_index_oob(self):
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
texture_importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
texture_importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
mesh_importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
mesh_importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
material_importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
material_importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
scene_importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
scene_importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 entries"):
scene_importer.scene_name(3)
with self.assertRaisesRegex(IndexError, "index 5 out of range for 5 entries"):
scene_importer.object_name(5)
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 entries"):
scene_importer.scene(3)
with self.assertRaisesRegex(IndexError, "index 5 out of range for 5 entries"):
mesh_importer.mesh_level_count(5)
with self.assertRaisesRegex(IndexError, "index 5 out of range for 5 entries"):
mesh_importer.mesh_name(5)
with self.assertRaisesRegex(IndexError, "index 5 out of range for 5 entries"):
mesh_importer.mesh(5)
python: expose the whole MaterialTools library.
2 years ago
with self.assertRaisesRegex(IndexError, "index 5 out of range for 5 entries"):
material_importer.material_name(5)
with self.assertRaisesRegex(IndexError, "index 5 out of range for 5 entries"):
material_importer.material(5)
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 entries"):
texture_importer.texture_name(3)
with self.assertRaisesRegex(IndexError, "index 3 out of range for 3 entries"):
texture_importer.texture(3)
with self.assertRaisesRegex(IndexError, "index 0 out of range for 0 entries"):
texture_importer.image1d_level_count(0)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 entries"):
texture_importer.image2d_level_count(2)
with self.assertRaisesRegex(IndexError, "index 0 out of range for 0 entries"):
texture_importer.image3d_level_count(0)
with self.assertRaisesRegex(IndexError, "index 0 out of range for 0 entries"):
texture_importer.image1d_name(0)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 entries"):
texture_importer.image2d_name(2)
with self.assertRaisesRegex(IndexError, "index 0 out of range for 0 entries"):
texture_importer.image3d_name(0)
with self.assertRaisesRegex(IndexError, "index 0 out of range for 0 entries"):
texture_importer.image1d(0)
with self.assertRaisesRegex(IndexError, "index 2 out of range for 2 entries"):
texture_importer.image2d(2)
with self.assertRaisesRegex(IndexError, "index 0 out of range for 0 entries"):
texture_importer.image3d(0)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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'')
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_open_data_not_supported(self):
importer = trade.ImporterManager().load_and_instantiate('AnySceneImporter')
with self.assertRaisesRegex(AssertionError, "feature not supported"):
importer.open_data(b'')
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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)
python: support bit field access in SceneData.
3 years ago
self.assertEqual(scene.field_count, 8)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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")
python: support bit field access in SceneData.
3 years ago
self.assertEqual(scene.field_count, 8)
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
python: stupid typo in a test name.
3 years ago
def test_scene_by_name_not_found(self):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "name Nonexistent not found among 3 entries"):
python: expose trade.SceneData basics together with importer APIs. No data access yet, that'll come later.
3 years ago
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")
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
def test_mesh(self):
python: expose mesh import.
7 years ago
# importer refcounting tested in image2d
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
# Asking for custom mesh attribute names should work even if not
# opened, returns None
python: update some test TODOs.
3 years ago
# TODO clean up once the compatibilitySkinningAttributes option is
# gone (until then it'll still return different IDs, regardless of it
# being enabled)
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
if magnum.BUILD_DEPRECATED:
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
self.assertIsNone(importer.mesh_attribute_name(trade.MeshAttribute.CUSTOM(9)))
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
else:
python: implement handling for custom trade.MeshAttribute values. So it's possible to create them, print them and get the custom ID back. Will be also used for SceneField and other yet-to-be-exposed enums.
3 years ago
self.assertIsNone(importer.mesh_attribute_name(trade.MeshAttribute.CUSTOM(7)))
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
self.assertIsNone(importer.mesh_attribute_for_name("_CUSTOM_ATTRIBUTE"))
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
self.assertEqual(importer.mesh_count, 5)
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
self.assertEqual(importer.mesh_level_count(0), 1)
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
self.assertEqual(importer.mesh_name(0), 'Indexed mesh')
self.assertEqual(importer.mesh_for_name('Indexed mesh'), 0)
# It should work after opening
python: update some test TODOs.
3 years ago
# TODO clean up once the compatibilitySkinningAttributes option is
# gone (until then it'll still return different IDs, regardless of it
# being enabled)
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
if magnum.BUILD_DEPRECATED:
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
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))
python: adapt the MeshData test to behavior on non-deprecated builds. Sigh.
3 years ago
else:
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
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))
python: expose mesh import.
7 years ago
python: adapt to Trade::MeshDataXD deprecation. Right now there's no deprecation logic in place for the Python bindings, so this is a breaking change. Sorry about that.
6 years ago
mesh = importer.mesh(0)
python: expose mesh import.
7 years ago
self.assertEqual(mesh.primitive, MeshPrimitive.TRIANGLES)
python: fix & test handling of cast/packed VertexFormats. It was casting in the wrong direction, causing an unbound type to be returned and also accessing the data totally wrong. Should have tested this properly in the first place.
3 years ago
self.assertTrue(mesh.has_attribute(importer.mesh_attribute_for_name("_CUSTOM_MATRIX_ATTRIBUTE")))
python: expose mesh import.
7 years ago
python: properly test also image import level OOB checks.
4 years ago
def test_mesh_level_oob(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: properly check also level bounds in importers.
6 years ago
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "level 1 out of range for 1 entries"):
python: properly check also level bounds in importers.
6 years ago
importer.mesh(0, 1)
python: ability to import images and meshes by name.
4 years ago
def test_mesh_by_name(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: ability to import images and meshes by name.
4 years ago
mesh = importer.mesh('Non-indexed mesh')
self.assertEqual(mesh.primitive, MeshPrimitive.TRIANGLES)
def test_mesh_by_name_not_found(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: ability to import images and meshes by name.
4 years ago
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "name Nonexistent not found among 5 entries"):
python: ability to import images and meshes by name.
4 years ago
importer.mesh('Nonexistent')
def test_mesh_by_name_level_oob(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: ability to import images and meshes by name.
4 years ago
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "level 1 out of range for 1 entries"):
python: ability to import images and meshes by name.
4 years ago
importer.mesh('Non-indexed mesh', 1)
python: test trade.AbstractImporter.mesh() failure.
3 years ago
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')
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
def test_material(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
python: expose the whole MaterialTools library.
2 years ago
self.assertEqual(importer.material_count, 5)
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
self.assertEqual(importer.material_name(2), 'Material with an empty layer')
self.assertEqual(importer.material_for_name('Material with an empty layer'), 2)
material = importer.material(2)
self.assertEqual(material.layer_count, 2)
def test_material_by_name(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material("Material with an empty layer")
self.assertEqual(material.layer_count, 2)
def test_material_by_name_not_found(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
python: expose the whole MaterialTools library.
2 years ago
with self.assertRaisesRegex(KeyError, "name Nonexistent not found among 5 entries"):
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
importer.material('Nonexistent')
def test_material_failed(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
with self.assertRaisesRegex(RuntimeError, "import failed"):
importer.material(3)
with self.assertRaisesRegex(RuntimeError, "import failed"):
importer.material("A broken material")
python: properly test all trade.AbstractImporter texture APIs. Meshes, scenes, images all have this, textures not for some reason.
2 years ago
def test_texture(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
self.assertEqual(importer.texture_count, 3)
self.assertEqual(importer.texture_name(1), 'A broken texture')
self.assertEqual(importer.texture_for_name('A broken texture'), 1)
texture = importer.texture(2)
self.assertEqual(texture.image, 1)
python: expose trade.TextureData and related importer APIs.
3 years ago
def test_texture_by_name(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
texture = importer.texture("A texture")
self.assertEqual(texture.image, 1)
def test_texture_by_name_not_found(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "name Nonexistent not found among 3 entries"):
python: expose trade.TextureData and related importer APIs.
3 years ago
importer.texture('Nonexistent')
def test_texture_failed(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
with self.assertRaisesRegex(RuntimeError, "import failed"):
importer.texture(1)
with self.assertRaisesRegex(RuntimeError, "import failed"):
importer.texture("A broken texture")
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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)
python: expose trade.abstractImporter.imageXd_level_count().
6 years ago
self.assertEqual(importer.image2d_level_count(0), 1)
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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)
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
def test_image2d_level_oob(self):
python: properly test also image import level OOB checks.
4 years ago
# importer refcounting tested in image2d
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png'))
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(IndexError, "level 1 out of range for 1 entries"):
python: properly test also image import level OOB checks.
4 years ago
importer.image2d(0, 1)
python: test trade.AbstractImporter.image2d() by name. And a failure of the by-name API.
3 years ago
def test_image2d_by_name(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: expose trade.TextureData and related importer APIs.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
python: test trade.AbstractImporter.image2d() by name. And a failure of the by-name API.
3 years ago
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')
python: expose trade.TextureData and related importer APIs.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
python: test trade.AbstractImporter.image2d() by name. And a failure of the by-name API.
3 years ago
python: add actual exception messages to all Trade and *Tools APIs. The time saved on not writing those messages back then was really not worth the time wasted on figuring out what the hell every time one of these fires. And yet, somehow Python itself and a ton of libraries raises just an IndexError alone, with nothing saying *how* wrong it was. Those details, present in Magnum's own C++ asserts, proved to be extremely valuable for being able to quickly figure out what's wrong, often even without even having to look at the code or step through in the debugger. Also fixes an issue where SceneData.field_object_offset() was rejecting offsets right at the end of the field. Wasn't caught by tests because apparently LookupError is a base of IndexError and as there was no message it just failed elsewhere without being noticed.
3 years ago
with self.assertRaisesRegex(KeyError, "name Nonexistent not found among 2 entries"):
python: test trade.AbstractImporter.image2d() by name. And a failure of the by-name API.
3 years ago
importer.image2d('Nonexistent')
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
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):
python: test trade.AbstractImporter.image2d() by name. And a failure of the by-name API.
3 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: expose trade.TextureData and related importer APIs.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'texture.gltf'))
python: expose basic image import in trade. Quite a huge commit because it all needs to be tested together.
7 years ago
with self.assertRaisesRegex(RuntimeError, "import failed"):
python: minor, doc++, add TODOs.
4 years ago
importer.image2d(0)
python: test trade.AbstractImporter.image2d() by name. And a failure of the by-name API.
3 years ago
with self.assertRaisesRegex(RuntimeError, "import failed"):
importer.image2d('A broken image')
python: exposed basics of trade.AbstractImageConverter.
4 years ago
class ImageConverter(unittest.TestCase):
python: expose trade.Abstract{Importer,Converter}.features and .flags. Right now the importer/converter APIs are not checked against the features so using them wrong will assert and make Python die. But there are at least the enums exposed now so it's possible to prevent the assert.
3 years ago
def test(self):
converter = trade.ImageConverterManager().load_and_instantiate('StbImageConverter')
self.assertEqual(converter.features, trade.ImageConverterFeatures.CONVERT2D_TO_FILE|trade.ImageConverterFeatures.CONVERT2D_TO_DATA)
self.assertEqual(converter.flags, trade.ImageConverterFlags.NONE)
converter.flags = trade.ImageConverterFlags.VERBOSE
self.assertEqual(converter.flags, trade.ImageConverterFlags.VERBOSE)
python: expose image-to-image ImageConverter APIs as well.
3 years ago
# TODO test also 1D and 3D variants for more robustness
python: exposed basics of trade.AbstractImageConverter.
4 years ago
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)
python: expose image-to-image ImageConverter APIs as well.
3 years ago
self.assertEqual(image.size, Vector2i(3, 2))
converter = trade.ImageConverterManager().load_and_instantiate('StbResizeImageConverter')
converter.configuration['size'] = "1 1"
python: expose compressed image APIs in AbstractImageConverter.
3 years ago
# Both ImageView and ImageData should work
converted1 = converter.convert(image)
converted2 = converter.convert(ImageView2D(image))
self.assertEqual(converted1.size, Vector2i(1, 1))
self.assertEqual(converted2.size, Vector2i(1, 1))
python: expose image-to-image ImageConverter APIs as well.
3 years ago
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)
self.assertEqual(image.size, Vector2i(3, 2))
converter = trade.ImageConverterManager().load_and_instantiate('StbResizeImageConverter')
# not setting any size
with self.assertRaisesRegex(RuntimeError, "conversion failed"):
converter.convert(image)
python: expose compressed image APIs in AbstractImageConverter.
3 years ago
def test_compressed_image2d(self):
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.assertTrue(image.is_compressed)
converter = trade.ImageConverterManager().load_and_instantiate('BcDecImageConverter')
# Both ImageData and CompressedImageView should work
converted1 = converter.convert(image)
converted2 = converter.convert(CompressedImageView2D(image))
self.assertFalse(converted1.is_compressed)
self.assertFalse(converted2.is_compressed)
def test_compressed_image2d_failed(self):
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.assertTrue(image.is_compressed)
converter = trade.ImageConverterManager().load_and_instantiate('EtcDecImageConverter')
with self.assertRaisesRegex(RuntimeError, "conversion failed"):
converter.convert(image)
python: expose image-to-image ImageConverter APIs as well.
3 years ago
def test_image2d_to_file(self):
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png'))
image = importer.image2d(0)
python: exposed basics of trade.AbstractImageConverter.
4 years ago
converter = trade.ImageConverterManager().load_and_instantiate('StbImageConverter')
with tempfile.TemporaryDirectory() as tmp:
python: expose compressed image APIs in AbstractImageConverter.
3 years ago
# Both ImageData and ImageView should work
converter.convert_to_file(image, os.path.join(tmp, "image1.png"))
converter.convert_to_file(ImageView2D(image), os.path.join(tmp, "image2.png"))
self.assertTrue(os.path.exists(os.path.join(tmp, "image1.png")))
self.assertTrue(os.path.exists(os.path.join(tmp, "image2.png")))
python: exposed basics of trade.AbstractImageConverter.
4 years ago
python: expose image-to-image ImageConverter APIs as well.
3 years ago
def test_image2d_to_file_failed(self):
python: exposed basics of trade.AbstractImageConverter.
4 years ago
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"))
python: expose basics of trade.AbstractSceneConverter.
4 years ago
python: expose compressed image APIs in AbstractImageConverter.
3 years ago
def test_compressed_image2d_to_file(self):
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.assertTrue(image.is_compressed)
converter = trade.ImageConverterManager().load_and_instantiate('KtxImageConverter')
with tempfile.TemporaryDirectory() as tmp:
# Both ImageData and CompressedImageView should work
converter.convert_to_file(image, os.path.join(tmp, "image1.ktx2"))
converter.convert_to_file(CompressedImageView2D(image), os.path.join(tmp, "image2.ktx2"))
self.assertTrue(os.path.exists(os.path.join(tmp, "image1.ktx2")))
self.assertTrue(os.path.exists(os.path.join(tmp, "image2.ktx2")))
def test_compressed_image2d_to_file_failed(self):
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.assertTrue(image.is_compressed)
converter = trade.ImageConverterManager().load_and_instantiate('KtxImageConverter')
# Set something stupid in the config to make it fail
converter.configuration['swizzle'] = "haha"
with tempfile.TemporaryDirectory() as tmp:
with self.assertRaisesRegex(RuntimeError, "conversion failed"):
converter.convert_to_file(image, os.path.join(tmp, "image.ktx2"))
python: expose basics of trade.AbstractSceneConverter.
4 years ago
class SceneConverter(unittest.TestCase):
python: expose trade.AbstractConverter.add*_importer_contents().
3 years ago
def test_scenecontents_for_importer(self):
# Silly, yes, but don't want to enable StanfordImporter just for this
# test case
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png'))
self.assertEqual(trade.SceneContents.FOR(importer), trade.SceneContents.IMAGES2D|trade.SceneContents.NAMES)
def test_scenecontents_for_importer_not_opened(self):
# Silly, yes, but don't want to enable StanfordImporter just for this
# test case
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
with self.assertRaisesRegex(AssertionError, "no file opened"):
trade.SceneContents.FOR(importer)
def test_scenecontents_for_converter(self):
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
self.assertEqual(trade.SceneContents.FOR(converter), trade.SceneContents.MESHES|trade.SceneContents.NAMES)
python: expose trade.Abstract{Importer,Converter}.features and .flags. Right now the importer/converter APIs are not checked against the features so using them wrong will assert and make Python die. But there are at least the enums exposed now so it's possible to prevent the assert.
3 years ago
def test(self):
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
self.assertEqual(converter.features, trade.SceneConverterFeatures.CONVERT_MESH_TO_FILE|trade.SceneConverterFeatures.CONVERT_MESH_TO_DATA)
self.assertEqual(converter.flags, trade.SceneConverterFlags.NONE)
converter.flags = trade.SceneConverterFlags.VERBOSE
self.assertEqual(converter.flags, trade.SceneConverterFlags.VERBOSE)
python: expose basics of trade.AbstractSceneConverter.
4 years ago
def test_mesh(self):
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
mesh = importer.mesh('Indexed mesh')
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter_manager = trade.SceneConverterManager()
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
if 'MeshOptimizerSceneConverter' not in converter_manager.plugin_list:
self.skipTest("MeshOptimizerSceneConverter plugin not available")
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter = converter_manager.load_and_instantiate('MeshOptimizerSceneConverter')
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
converted_mesh = converter.convert(mesh)
self.assertEqual(converted_mesh.index_count, mesh.index_count)
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('Non-indexed mesh')
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter_manager = trade.SceneConverterManager()
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
if 'MeshOptimizerSceneConverter' not in converter_manager.plugin_list:
self.skipTest("MeshOptimizerSceneConverter plugin not available")
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter = converter_manager.load_and_instantiate('MeshOptimizerSceneConverter')
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
with self.assertRaisesRegex(RuntimeError, "conversion failed"):
converted_mesh = converter.convert(mesh)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_mesh_not_supported(self):
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with self.assertRaisesRegex(AssertionError, "mesh conversion not supported"):
converter.convert(primitives.cube_solid())
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
def test_mesh_in_place(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
mesh = importer.mesh('Indexed mesh')
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter_manager = trade.SceneConverterManager()
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
if 'MeshOptimizerSceneConverter' not in converter_manager.plugin_list:
self.skipTest("MeshOptimizerSceneConverter plugin not available")
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter = converter_manager.load_and_instantiate('MeshOptimizerSceneConverter')
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
converter.convert_in_place(mesh)
self.assertEqual(mesh.index_count, 3)
def test_mesh_in_place_failed(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')
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter_manager = trade.SceneConverterManager()
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
if 'MeshOptimizerSceneConverter' not in converter_manager.plugin_list:
self.skipTest("MeshOptimizerSceneConverter plugin not available")
python: the WHAT was done in the test here and then copied 100 times?
3 years ago
converter = converter_manager.load_and_instantiate('MeshOptimizerSceneConverter')
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
with self.assertRaisesRegex(RuntimeError, "conversion failed"):
converter.convert_in_place(mesh)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_mesh_in_place_not_supported(self):
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with self.assertRaisesRegex(AssertionError, "mesh conversion not supported"):
converter.convert_in_place(primitives.cube_solid())
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
def test_mesh_to_file(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh = importer.mesh(1)
python: expose basics of trade.AbstractSceneConverter.
4 years ago
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")))
python: expose mesh-to-mesh and in-place mesh conversion. Needs to fetch MeshOptimizer on the CIs for testing this as there's no other plugin with these features right now.
3 years ago
def test_mesh_to_file_failed(self):
python: CgltfImporter is deprecated, test with GltfImporter instead.
4 years ago
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
python: handle Windows path insanities in the bindings directly. Otherwise people wouldn't be able to conveniently use os.path, which is an undesirable pain point. And do this for all currently exposed APIs, not just the AbstractImporter that caused a problem. This reverts commit 28497ec2ca4990ad37d0b9d6263cf83855ab87b8.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
python: expose all index/attribute property queries in trade.MeshData. Except for the actual data access, that'll be done next. Also updated the mesh test file with more useful contents.
3 years ago
mesh = importer.mesh(1)
python: expose basics of trade.AbstractSceneConverter.
4 years ago
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"))
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_mesh_to_file_not_supported(self):
converter_manager = trade.SceneConverterManager()
if 'MeshOptimizerSceneConverter' not in converter_manager.plugin_list:
self.skipTest("MeshOptimizerSceneConverter plugin not available")
converter = converter_manager.load_and_instantiate('MeshOptimizerSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
with self.assertRaisesRegex(AssertionError, "mesh conversion not supported"):
converter.convert_to_file(primitives.cube_solid(), os.path.join(tmp, "mesh.foo"))
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
def test_batch_file(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.begin_file(os.path.join(tmp, "mesh.ply"))
self.assertTrue(converter.is_converting)
self.assertEqual(converter.mesh_count, 0)
self.assertEqual(converter.add(mesh), 0)
self.assertEqual(converter.mesh_count, 1)
converter.end_file()
self.assertFalse(converter.is_converting)
self.assertTrue(os.path.exists(os.path.join(tmp, "mesh.ply")))
def test_batch_file_begin_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, "beginning the conversion failed"):
converter.begin_file(os.path.join(tmp, "mesh.obj"))
def test_batch_file_end_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('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "mesh.ply"))
with self.assertRaisesRegex(RuntimeError, "ending the conversion failed"):
converter.end_file()
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_file_not_supported(self):
converter_manager = trade.SceneConverterManager()
if 'MeshOptimizerSceneConverter' not in converter_manager.plugin_list:
self.skipTest("MeshOptimizerSceneConverter plugin not available")
converter = converter_manager.load_and_instantiate('MeshOptimizerSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
with self.assertRaisesRegex(AssertionError, "feature not supported"):
converter.begin_file(os.path.join(tmp, "mesh.foo"))
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
def test_batch_add_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('Point mesh')
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "mesh.ply"))
with self.assertRaisesRegex(RuntimeError, "adding the mesh failed"):
converter.add(mesh)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_add_mesh_not_supported(self):
# TODO implement once there's a converter that doesn't support meshes
python: update some test TODOs.
3 years ago
# or has only in-place conversion (MeshOptimizerSceneConverter
# support this with begin())
python: convert more Trade assertions to Python exceptions.
3 years ago
pass
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
def test_batch_set_mesh_attribute_name(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
mesh = importer.mesh('Custom mesh attribute')
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "mesh.gltf")
converter.begin_file(filename)
converter.set_mesh_attribute_name(importer.mesh_attribute_for_name('_FOOBARTHINGY'), '_FOOBARTHINGY')
converter.add(mesh)
converter.end_file()
with open(filename, 'r') as f:
self.assertIn('_FOOBARTHINGY', f.read())
def test_batch_set_mesh_attribute_name_not_custom(self):
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "mesh.gltf")
converter.begin_file(filename)
with self.assertRaisesRegex(AssertionError, "not a custom attribute"):
converter.set_mesh_attribute_name(trade.MeshAttribute.POSITION, 'foo')
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_set_mesh_attribute_name_not_supported(self):
# TODO implement once there's a converter that doesn't support meshes
pass
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
def test_batch_add_material(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material("Material with an empty layer")
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "file.gltf")
converter.begin_file(filename)
self.assertEqual(converter.material_count, 0)
converter.add(material, "Material with an empty layer")
self.assertEqual(converter.material_count, 1)
converter.end_file()
with open(filename, 'r') as f:
self.assertIn("Material with an empty layer", f.read())
def test_batch_add_material_failed(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
# References a texture, which means conversion will fail due to the
# texture not being added before
material = importer.material(0)
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "file.gltf"))
with self.assertRaisesRegex(RuntimeError, "adding the material failed"):
converter.add(material)
def test_batch_add_material_not_supported(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material("Material with an empty layer")
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "file.ply"))
with self.assertRaisesRegex(AssertionError, "material conversion not supported"):
converter.add(material)
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
def test_batch_add_scene(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
scene = importer.scene("A default scene that's empty")
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "scene.gltf")
converter.begin_file(filename)
python: improve test coverage for new SceneConverter APIs.
3 years ago
self.assertEqual(converter.scene_count, 0)
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
converter.add(scene, "A default scene that's empty")
python: improve test coverage for new SceneConverter APIs.
3 years ago
self.assertEqual(converter.scene_count, 1)
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
converter.end_file()
with open(filename, 'r') as f:
self.assertIn("A default scene that's empty", f.read())
python: improve test coverage for new SceneConverter APIs.
3 years ago
def test_batch_add_scene_failed(self):
# Static builds with non-static plugins cause assertions with non-owned
# array deleters used by PrimitiveImporter, skip in that case
if magnum.BUILD_STATIC:
self.skipTest("dynamic PrimitiveImporter doesn't work with a static build")
importer = trade.ImporterManager().load_and_instantiate('PrimitiveImporter')
importer.open_data(containers.ArrayView())
scene = importer.scene(0)
self.assertFalse(scene.is_3d)
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
python: minor, doc++
3 years ago
converter.begin_file(os.path.join(tmp, "scene.gltf"))
python: improve test coverage for new SceneConverter APIs.
3 years ago
with self.assertRaisesRegex(RuntimeError, "adding the scene failed"):
converter.add(scene)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_add_scene_not_supported(self):
# Static builds with non-static plugins cause assertions with non-owned
# array deleters used by PrimitiveImporter, skip in that case
if magnum.BUILD_STATIC:
self.skipTest("dynamic PrimitiveImporter doesn't work with a static build")
importer = trade.ImporterManager().load_and_instantiate('PrimitiveImporter')
importer.open_data(containers.ArrayView())
scene = importer.scene(0)
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "scene.ply"))
with self.assertRaisesRegex(AssertionError, "scene conversion not supported"):
converter.add(scene)
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
def test_batch_set_default_scene(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
scene = importer.scene("A default scene that's empty")
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "scene.gltf")
converter.begin_file(filename)
converter.add(scene, "A default scene that's empty")
converter.set_default_scene(0)
converter.end_file()
with open(filename, 'r') as f:
self.assertIn('"scene": 0', f.read())
def test_batch_set_default_scene_out_of_range(self):
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
python: minor, doc++
3 years ago
converter.begin_file(os.path.join(tmp, "scene.gltf"))
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
with self.assertRaisesRegex(AssertionError, "index 1 out of range for 0 scenes"):
converter.set_default_scene(1)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_set_default_scene_not_supported(self):
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "scene.ply"))
with self.assertRaisesRegex(AssertionError, "feature not supported"):
converter.set_default_scene(0)
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
def test_batch_set_scene_field_name(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
# Keep only the single custom numeric attribute in the scene (plus
# hierarchy and transformation that's required by glTF)
# TODO clean up once there's a possibility to create scenes from
# scratch
scene = scenetools.filter_only_fields(importer.scene("A scene"), [
trade.SceneField.PARENT,
trade.SceneField.TRANSLATION,
importer.scene_field_for_name('aNumber'),
])
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "scene.gltf")
converter.begin_file(filename)
converter.set_scene_field_name(importer.scene_field_for_name('aNumber'), 'aNumber')
converter.add(scene)
converter.end_file()
with open(filename, 'r') as f:
self.assertIn('"aNumber":', f.read())
def test_batch_set_scene_field_name_not_custom(self):
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
python: minor, doc++
3 years ago
converter.begin_file(os.path.join(tmp, "scene.gltf"))
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
with self.assertRaisesRegex(AssertionError, "not a custom field"):
converter.set_scene_field_name(trade.SceneField.SCALING, 'foo')
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_set_scene_field_name_not_supported(self):
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "scene.ply"))
with self.assertRaisesRegex(AssertionError, "feature not supported"):
converter.set_scene_field_name(trade.SceneField.CUSTOM(1), 'foo')
python: expose 2D image APIs in AbstractSceneConverter.
3 years ago
def test_batch_add_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)
image_converter_manager = trade.ImageConverterManager()
scene_converter_manager = trade.SceneConverterManager()
scene_converter_manager.register_external_manager(image_converter_manager)
converter = scene_converter_manager.load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "file.gltf")
converter.begin_file(filename)
self.assertEqual(converter.image2d_count, 0)
converter.add(image, "A PNG image")
self.assertEqual(converter.image2d_count, 1)
converter.end_file()
with open(filename, 'r') as f:
self.assertIn("A PNG image", f.read())
def test_batch_add_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.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
# Nonsense image converter
converter.configuration['imageConverter'] = 'ThisIsNoImageConverter'
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "file.gltf"))
with self.assertRaisesRegex(RuntimeError, "adding the image failed"):
converter.add(image)
def test_batch_add_image2d_not_supported(self):
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png'))
image = importer.image2d(0)
importer = trade.ImporterManager().load_and_instantiate('DdsImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), "rgba_dxt1.dds"))
compressed_image = importer.image2d(0)
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "file.ply"))
with self.assertRaisesRegex(AssertionError, "2D image conversion not supported"):
converter.add(image)
with self.assertRaisesRegex(AssertionError, "compressed 2D image conversion not supported"):
converter.add(compressed_image)
python: expose trade.AbstractConverter.add*_importer_contents().
3 years ago
def test_batch_add_importer_contents(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'two-meshes.gltf'))
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
python: minor, doc++
3 years ago
converter.begin_file(os.path.join(tmp, "two-meshes.gltf"))
python: expose trade.AbstractConverter.add*_importer_contents().
3 years ago
self.assertEqual(converter.mesh_count, 0)
# Nothing like that in the file
converter.add_importer_contents(importer, trade.SceneContents.SCENES|trade.SceneContents.CAMERAS)
self.assertEqual(converter.mesh_count, 0)
converter.add_importer_contents(importer)
self.assertEqual(converter.mesh_count, 2)
def test_batch_add_importer_contents_failed(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'two-meshes.gltf'))
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
python: minor, doc++
3 years ago
converter.begin_file(os.path.join(tmp, "file.ply"))
python: expose trade.AbstractConverter.add*_importer_contents().
3 years ago
with self.assertRaisesRegex(RuntimeError, "adding importer contents failed"):
converter.add_importer_contents(importer)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_add_importer_contents_not_opened(self):
importer = trade.ImporterManager().load_and_instantiate('AnySceneImporter')
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "file.gltf"))
with self.assertRaisesRegex(AssertionError, "the importer is not opened"):
converter.add_importer_contents(importer)
python: expose trade.AbstractConverter.add*_importer_contents().
3 years ago
def test_batch_add_supported_importer_contents(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "two-meshes.gltf")
converter.begin_file(filename)
self.assertEqual(converter.mesh_count, 0)
# Nothing like that in the file
converter.add_supported_importer_contents(importer, trade.SceneContents.MESHES)
self.assertEqual(converter.mesh_count, 0)
# It contains cameras, nodes and scenes, none of which is supported
# by the converter
converter.add_supported_importer_contents(importer)
self.assertEqual(converter.mesh_count, 0)
def test_batch_add_supported_importer_contents_failed(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'two-meshes.gltf'))
converter = trade.SceneConverterManager().load_and_instantiate('StanfordSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, "two-meshes.gltf")
converter.begin_file(filename)
with self.assertRaisesRegex(RuntimeError, "adding importer contents failed"):
converter.add_supported_importer_contents(importer)
python: convert more Trade assertions to Python exceptions.
3 years ago
def test_batch_add_supported_importer_contents_not_opened(self):
importer = trade.ImporterManager().load_and_instantiate('AnySceneImporter')
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
with tempfile.TemporaryDirectory() as tmp:
converter.begin_file(os.path.join(tmp, "file.gltf"))
with self.assertRaisesRegex(AssertionError, "the importer is not opened"):
converter.add_supported_importer_contents(importer)
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
def test_batch_no_conversion_in_progress(self):
importer = trade.ImporterManager().load_and_instantiate('GltfImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'mesh.gltf'))
mesh = importer.mesh('Custom mesh attribute')
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'scene.gltf'))
scene = importer.scene("A default scene that's empty")
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
importer.open_file(os.path.join(os.path.dirname(__file__), 'material.gltf'))
material = importer.material("Material with an empty layer")
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
python: expose 2D image APIs in AbstractSceneConverter.
3 years ago
importer = trade.ImporterManager().load_and_instantiate('StbImageImporter')
importer.open_file(os.path.join(os.path.dirname(__file__), 'rgb.png'))
image = importer.image2d(0)
python: expose trade.AbstractSceneConverter batch mode for files. Just meshes for now.
3 years ago
converter = trade.SceneConverterManager().load_and_instantiate('GltfSceneConverter')
self.assertFalse(converter.is_converting)
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.end_file()
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.mesh_count
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.add(mesh)
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.set_mesh_attribute_name(trade.MeshAttribute.CUSTOM(1), 'foobar')
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
python: expose trade.MaterialData and related importer & converter APIs. Rather massive, heh. So far no attribute mutability or creating new attributes, just queries.
2 years ago
converter.material_count
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.add(material)
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
python: expose scene-related APIs in AbstractSceneConverter.
3 years ago
converter.scene_count
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.add(scene)
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.set_default_scene(0)
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.set_scene_field_name(trade.SceneField.CUSTOM(1), 'foobar')
python: expose 2D image APIs in AbstractSceneConverter.
3 years ago
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.image2d_count
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.add(image)
python: expose trade.AbstractConverter.add*_importer_contents().
3 years ago
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.add_importer_contents(importer)
with self.assertRaisesRegex(AssertionError, "no conversion in progress"):
converter.add_supported_importer_contents(importer)