Trade: resource names are handled by importer, not *Data classes.

In most cases the names aren't even supported/used and thus it is
wasteful to have them in all *Data classes. If the importer wants to
support them, it would reimplement *name() functions instead.

src/Primitives/Capsule.cpp

@@ -20,7 +20,7 @@
 
 namespace Magnum { namespace Primitives {
 
-Capsule::Capsule(std::uint32_t hemisphereRings, std::uint32_t cylinderRings, std::uint32_t segments, GLfloat length, TextureCoords textureCoords): MeshData3D("", Mesh::Primitive::Triangles, new std::vector<std::uint32_t>, {new std::vector<Point3D>()}, {new std::vector<Vector3>()}, textureCoords == TextureCoords::Generate ? std::vector<std::vector<Vector2>*>{new std::vector<Vector2>()} : std::vector<std::vector<Vector2>*>()), segments(segments), textureCoords(textureCoords) {
+Capsule::Capsule(std::uint32_t hemisphereRings, std::uint32_t cylinderRings, std::uint32_t segments, GLfloat length, TextureCoords textureCoords): MeshData3D(Mesh::Primitive::Triangles, new std::vector<std::uint32_t>, {new std::vector<Point3D>()}, {new std::vector<Vector3>()}, textureCoords == TextureCoords::Generate ? std::vector<std::vector<Vector2>*>{new std::vector<Vector2>()} : std::vector<std::vector<Vector2>*>()), segments(segments), textureCoords(textureCoords) {
     CORRADE_ASSERT(hemisphereRings >= 1 && cylinderRings >= 1 && segments >= 3, "Capsule must have at least one hemisphere ring, one cylinder ring and three segments", );
 
     GLfloat height = 2.0f+length;
@@ -48,7 +48,7 @@ Capsule::Capsule(std::uint32_t hemisphereRings, std::uint32_t cylinderRings, std
     topFaceRing();
 }
 
-Capsule::Capsule(std::uint32_t segments, TextureCoords textureCoords): MeshData3D("", Mesh::Primitive::Triangles, new std::vector<std::uint32_t>, {new std::vector<Point3D>()}, {new std::vector<Vector3>()}, textureCoords == TextureCoords::Generate ? std::vector<std::vector<Vector2>*>{new std::vector<Vector2>()} : std::vector<std::vector<Vector2>*>()), segments(segments), textureCoords(textureCoords) {}
+Capsule::Capsule(std::uint32_t segments, TextureCoords textureCoords): MeshData3D(Mesh::Primitive::Triangles, new std::vector<std::uint32_t>, {new std::vector<Point3D>()}, {new std::vector<Vector3>()}, textureCoords == TextureCoords::Generate ? std::vector<std::vector<Vector2>*>{new std::vector<Vector2>()} : std::vector<std::vector<Vector2>*>()), segments(segments), textureCoords(textureCoords) {}
 
 void Capsule::capVertex(GLfloat y, GLfloat normalY, GLfloat textureCoordsV) {
     positions(0)->push_back({0.0f, y, 0.0f});

src/Primitives/Cube.cpp

@@ -19,7 +19,7 @@
 
 namespace Magnum { namespace Primitives {
 
-Cube::Cube(): MeshData3D("", Mesh::Primitive::Triangles, new std::vector<std::uint32_t>{
+Cube::Cube(): MeshData3D(Mesh::Primitive::Triangles, new std::vector<std::uint32_t>{
      0,  1,  2,  0,  2,  3, /* +Z */
      4,  5,  6,  4,  6,  7, /* +X */
      8,  9, 10,  8, 10, 11, /* +Y */

src/Primitives/Icosphere.cpp

@@ -19,7 +19,7 @@
 
 namespace Magnum { namespace Primitives {
 
-Icosphere<0>::Icosphere(): MeshData3D("", Mesh::Primitive::Triangles, new std::vector<std::uint32_t>{
+Icosphere<0>::Icosphere(): MeshData3D(Mesh::Primitive::Triangles, new std::vector<std::uint32_t>{
     1, 2, 6,
     1, 7, 2,
     3, 4, 5,

src/Primitives/Plane.cpp

@@ -19,7 +19,7 @@
 
 namespace Magnum { namespace Primitives {
 
-Plane::Plane(): MeshData3D("", Mesh::Primitive::TriangleStrip, nullptr, {new std::vector<Point3D>{
+Plane::Plane(): MeshData3D(Mesh::Primitive::TriangleStrip, nullptr, {new std::vector<Point3D>{
     {1.0f, -1.0f, 0.0f},
     {1.0f, 1.0f, 0.0f},
     {-1.0f, -1.0f, 0.0f},

src/Primitives/Square.cpp

@@ -19,7 +19,7 @@
 
 namespace Magnum { namespace Primitives {
 
-Square::Square(): MeshData2D("", Mesh::Primitive::TriangleStrip, nullptr, {new std::vector<Point2D>{
+Square::Square(): MeshData2D(Mesh::Primitive::TriangleStrip, nullptr, {new std::vector<Point2D>{
     {1.0f, -1.0f},
     {1.0f, 1.0f},
     {-1.0f, -1.0f},

src/Trade/AbstractImporter.h

@@ -130,10 +130,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief %Scene ID for given name
          *
          * If no scene for given name exists, returns -1.
-         * @see SceneData::name()
+         * @see sceneName()
          */
         virtual std::int32_t sceneForName(const std::string& name);
 
+        /**
+         * @brief %Scene name
+         * @param id        %Scene ID, from range [0, sceneCount()).
+         *
+         * @see sceneForName()
+         */
+        virtual std::string sceneName(std::uint32_t id);
+
         /**
          * @brief %Scene
          * @param id        %Scene ID, from range [0, sceneCount()).
@@ -149,10 +157,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief %Light ID for given name
          *
          * If no light for given name exists, returns -1.
-         * @see LightData::name()
+         * @see lightName()
          */
         virtual std::int32_t lightForName(const std::string& name);
 
+        /**
+         * @brief %Light name
+         * @param id        %Light ID, from range [0, lightCount()).
+         *
+         * @see lightForName()
+         */
+        virtual std::string lightName(std::uint32_t id);
+
         /**
          * @brief %Light
          * @param id        %Light ID, from range [0, lightCount()).
@@ -161,20 +177,28 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          */
         virtual LightData* light(std::uint32_t id);
 
-        /** @brief %Camera count */
+        /** @brief Camera count */
         virtual inline std::uint32_t cameraCount() const { return 0; }
 
         /**
-         * @brief %Camera ID for given name
+         * @brief Camera ID for given name
          *
          * If no camera for given name exists, returns -1.
-         * @see CameraData::name()
+         * @see cameraName()
          */
         virtual std::int32_t cameraForName(const std::string& name);
 
         /**
-         * @brief %Camera
+         * @brief Camera name
-         * @param id        %Camera ID, from range [0, cameraCount()).
+         * @param id        Camera ID, from range [0, cameraCount()).
+         *
+         * @see cameraForName()
+         */
+        virtual std::string cameraName(std::uint32_t id);
+
+        /**
+         * @brief Camera
+         * @param id        Camera ID, from range [0, cameraCount()).
          *
          * Returns pointer to given camera or nullptr, if no such camera
          * exists.
@@ -188,13 +212,21 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Two-dimensional object ID for given name
          *
          * If no scene for given name exists, returns -1.
-         * @see ObjectData2D::name()
+         * @see object2DName()
          */
         virtual std::int32_t object2DForName(const std::string& name);
 
+        /**
+         * @brief Two-dimensional object name
+         * @param id        Object ID, from range [0, object2DCount()).
+         *
+         * @see object2DForName()
+         */
+        virtual std::string object2DName(std::uint32_t id);
+
         /**
          * @brief Two-dimensional object
-         * @param id        %Object ID, from range [0, object2DCount()).
+         * @param id        Object ID, from range [0, object2DCount()).
          *
          * Returns pointer to given object or nullptr, if no such object
          * exists.
@@ -208,13 +240,21 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Three-dimensional object ID for given name
          *
          * If no scene for given name exists, returns -1.
-         * @see ObjectData3D::name()
+         * @see object3DName()
          */
         virtual std::int32_t object3DForName(const std::string& name);
 
+        /**
+         * @brief Three-dimensional object name
+         * @param id        Object ID, from range [0, object3DCount()).
+         *
+         * @see object3DForName()
+         */
+        virtual std::string object3DName(std::uint32_t id);
+
         /**
          * @brief Three-dimensional object
-         * @param id        %Object ID, from range [0, object3DCount()).
+         * @param id        Object ID, from range [0, object3DCount()).
          *
          * Returns pointer to given object or nullptr, if no such object
          * exists.
@@ -228,13 +268,21 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Two-dimensional mesh ID for given name
          *
          * If no mesh for given name exists, returns -1.
-         * @see MeshData2D::name()
+         * @see mesh2DName()
          */
         virtual std::int32_t mesh2DForName(const std::string& name);
 
+        /**
+         * @brief Two-dimensional mesh name
+         * @param id        %Mesh ID, from range [0, mesh2DCount()).
+         *
+         * @see mesh2DForName()
+         */
+        virtual std::string mesh2DName(std::uint32_t id);
+
         /**
          * @brief Two-dimensional mesh
-         * @param id        %Mesh ID, from range [0, meshCount()).
+         * @param id        %Mesh ID, from range [0, mesh2DCount()).
          *
          * Returns pointer to given mesh or nullptr, if no such mesh exists.
          */
@@ -247,13 +295,21 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Three-dimensional mesh ID for given name
          *
          * If no mesh for given name exists, returns -1.
-         * @see MeshData3D::name()
+         * @see mesh3DName()
          */
         virtual std::int32_t mesh3DForName(const std::string& name);
 
+        /**
+         * @brief Three-dimensional mesh name
+         * @param id        %Mesh ID, from range [0, mesh3DCount()).
+         *
+         * @see mesh3DForName()
+         */
+        virtual std::string mesh3DName(std::uint32_t id);
+
         /**
          * @brief Three-dimensional mesh
-         * @param id        %Mesh ID, from range [0, meshCount()).
+         * @param id        %Mesh ID, from range [0, mesh3DCount()).
          *
          * Returns pointer to given mesh or nullptr, if no such mesh exists.
          */
@@ -266,10 +322,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Material ID for given name
          *
          * If no material for given name exists, returns -1.
-         * @see AbstractMaterialData::name()
+         * @see materialName()
          */
         virtual std::int32_t materialForName(const std::string& name);
 
+        /**
+         * @brief Material name
+         * @param id        Material ID, from range [0, materialCount()).
+         *
+         * @see materialForName()
+         */
+        virtual std::string materialName(std::uint32_t id);
+
         /**
          * @brief Material
          * @param id        Material ID, from range [0, materialCount()).
@@ -286,10 +350,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief %Texture ID for given name
          *
          * If no texture for given name exists, returns -1.
-         * @see TextureData::name()
+         * @see textureName()
          */
         virtual std::int32_t textureForName(const std::string& name);
 
+        /**
+         * @brief %Texture name
+         * @param id        %Texture ID, from range [0, textureCount()).
+         *
+         * @see textureForName()
+         */
+        virtual std::string textureName(std::uint32_t id);
+
         /**
          * @brief %Texture
          * @param id        %Texture ID, from range [0, textureCount()).
@@ -306,10 +378,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief One-dimensional image ID for given name
          *
          * If no image for given name exists, returns -1.
-         * @see ImageData1D::name()
+         * @see image1Dname()
          */
         virtual std::int32_t image1DForName(const std::string& name);
 
+        /**
+         * @brief One-dimensional image name
+         * @param id        %Image ID, from range [0, image1DCount()).
+         *
+         * @see image1DForName()
+         */
+        virtual std::string image1DName(std::uint32_t id);
+
         /**
          * @brief One-dimensional image
          * @param id        %Image ID, from range [0, image1DCount()).
@@ -325,10 +405,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Two-dimensional image ID for given name
          *
          * If no image for given name exists, returns -1.
-         * @see ImageData2D::name()
+         * @see image2DName()
          */
         virtual std::int32_t image2DForName(const std::string& name);
 
+        /**
+         * @brief Two-dimensional image name
+         * @param id        %Image ID, from range [0, image2DCount()).
+         *
+         * @see image2DForName()
+         */
+        virtual std::string image2DName(std::uint32_t id);
+
         /**
          * @brief Two-dimensional image
          * @param id        %Image ID, from range [0, image2DCount()).
@@ -344,10 +432,18 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
          * @brief Three-dimensional image ID for given name
          *
          * If no image for given name exists, returns -1.
-         * @see ImageData3D::name()
+         * @see image3DName()
          */
         virtual std::int32_t image3DForName(const std::string& name);
 
+        /**
+         * @brief Three-dimensional image name
+         * @param id        %Image ID, from range [0, image3DCount()).
+         *
+         * @see image3DForName()
+         */
+        virtual std::string image3DName(std::uint32_t id);
+
         /**
          * @brief Three-dimensional image
          * @param id        %Image ID, from range [0, image3DCount()).
@@ -363,28 +459,40 @@ CORRADE_ENUMSET_OPERATORS(AbstractImporter::Features)
 
 /* Implementations for inline functions with unused parameters */
 inline std::int32_t AbstractImporter::sceneForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::sceneName(std::uint32_t) { return {}; }
 inline SceneData* AbstractImporter::scene(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::lightForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::lightName(std::uint32_t) { return {}; }
 inline LightData* AbstractImporter::light(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::cameraForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::cameraName(std::uint32_t) { return {}; }
 inline CameraData* AbstractImporter::camera(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::object2DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::object2DName(std::uint32_t) { return {}; }
 inline ObjectData2D* AbstractImporter::object2D(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::object3DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::object3DName(std::uint32_t) { return {}; }
 inline ObjectData3D* AbstractImporter::object3D(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::mesh2DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::mesh2DName(std::uint32_t) { return {}; }
 inline MeshData2D* AbstractImporter::mesh2D(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::mesh3DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::mesh3DName(std::uint32_t) { return {}; }
 inline MeshData3D* AbstractImporter::mesh3D(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::materialForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::materialName(std::uint32_t) { return {}; }
 inline AbstractMaterialData* AbstractImporter::material(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::textureForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::textureName(std::uint32_t) { return {}; }
 inline TextureData* AbstractImporter::texture(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::image1DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::image1DName(std::uint32_t) { return {}; }
 inline ImageData1D* AbstractImporter::image1D(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::image2DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::image2DName(std::uint32_t) { return {}; }
 inline ImageData2D* AbstractImporter::image2D(std::uint32_t) { return nullptr; }
 inline std::int32_t AbstractImporter::image3DForName(const std::string&) { return -1; }
+inline std::string AbstractImporter::image3DName(std::uint32_t) { return {}; }
 inline ImageData3D* AbstractImporter::image3D(std::uint32_t) { return nullptr; }
 
 }}

src/Trade/AbstractMaterialData.h

@@ -42,22 +42,17 @@ class AbstractMaterialData {
 
         /**
          * @brief Constructor
-         * @param name      Material name
          * @param type      Material type
          */
-        inline AbstractMaterialData(const std::string& name, Type type): _name(name), _type(type) {}
+        inline AbstractMaterialData(Type type): _type(type) {}
 
         /** @brief Destructor */
         virtual ~AbstractMaterialData() = 0;
 
-        /** @brief Material name */
-        inline std::string name() const { return _name; }
-
         /** @brief Material type */
         inline Type type() const { return _type; }
 
     private:
-        std::string _name;
         Type _type;
 };
 

src/Trade/CameraData.h

@@ -31,19 +31,6 @@ class MAGNUM_EXPORT CameraData {
     CameraData(CameraData&& other) = delete;
     CameraData& operator=(const CameraData& other) = delete;
     CameraData& operator=(CameraData&& other) = delete;
-
-    public:
-        /**
-         * @brief Constructor
-         * @param name      %Camera name
-         */
-        inline CameraData(const std::string& name): _name(name) {}
-
-        /** @brief %Camera name */
-        inline std::string name() const { return _name; }
-
-    private:
-        std::string _name;
 };
 
 }}

src/Trade/ImageData.h

@@ -38,7 +38,6 @@ template<std::uint8_t dimensions> class ImageData: public AbstractImage {
 
         /**
          * @brief Constructor
-         * @param name              %Image name
          * @param size              %Image size
          * @param format            Format of pixel data
          * @param type              Data type of pixel data
@@ -47,14 +46,11 @@ template<std::uint8_t dimensions> class ImageData: public AbstractImage {
          * Note that the image data are not copied on construction, but they
          * are deleted on class destruction.
          */
-        inline ImageData(const std::string& name, const typename DimensionTraits<Dimensions, GLsizei>::VectorType& size, Format format, Type type, GLvoid* data): AbstractImage(format, type), _name(name), _size(size), _data(reinterpret_cast<char*>(data)) {}
+        inline ImageData(const typename DimensionTraits<Dimensions, GLsizei>::VectorType& size, Format format, Type type, GLvoid* data): AbstractImage(format, type), _size(size), _data(reinterpret_cast<char*>(data)) {}
 
         /** @brief Destructor */
         inline ~ImageData() { delete[] _data; }
 
-        /** @brief %Image name */
-        inline std::string name() const { return _name; }
-
         /** @brief %Image size */
         inline typename DimensionTraits<Dimensions, GLsizei>::VectorType size() const { return _size; }
 
@@ -63,7 +59,6 @@ template<std::uint8_t dimensions> class ImageData: public AbstractImage {
         inline const void* data() const { return _data; } /**< @overload */
 
     private:
-        std::string _name;
         Math::Vector<Dimensions, GLsizei> _size;
         char* _data;
 };

src/Trade/LightData.h

@@ -31,19 +31,6 @@ class MAGNUM_EXPORT LightData {
     LightData(LightData&& other) = delete;
     LightData& operator=(const LightData& other) = delete;
     LightData& operator=(LightData&& other) = delete;
-
-    public:
-        /**
-         * @brief Constructor
-         * @param name      %Light name
-         */
-        inline LightData(const std::string& name): _name(name) {}
-
-        /** @brief %Light name */
-        inline std::string name() const { return _name; }
-
-    private:
-        std::string _name;
 };
 
 }}

src/Trade/MeshData2D.h

@@ -42,7 +42,6 @@ class MAGNUM_EXPORT MeshData2D {
     public:
         /**
          * @brief Constructor
-         * @param name              %Mesh name
          * @param primitive         Primitive
          * @param indices           Array with indices or 0, if this is not
          *      indexed mesh
@@ -51,14 +50,11 @@ class MAGNUM_EXPORT MeshData2D {
          * @param textureCoords2D   Array with two-dimensional texture
          *      coordinate arrays or empty array
          */
-        inline MeshData2D(const std::string& name, Mesh::Primitive primitive, std::vector<std::uint32_t>* indices, std::vector<std::vector<Point2D>*> positions, std::vector<std::vector<Vector2>*> textureCoords2D): _name(name), _primitive(primitive), _indices(indices), _positions(positions), _textureCoords2D(textureCoords2D) {}
+        inline MeshData2D(Mesh::Primitive primitive, std::vector<std::uint32_t>* indices, std::vector<std::vector<Point2D>*> positions, std::vector<std::vector<Vector2>*> textureCoords2D): _primitive(primitive), _indices(indices), _positions(positions), _textureCoords2D(textureCoords2D) {}
 
         /** @brief Destructor */
         ~MeshData2D();
 
-        /** @brief %Mesh name */
-        inline std::string name() const { return _name; }
-
         /** @brief Primitive */
         inline Mesh::Primitive primitive() const { return _primitive; }
 
@@ -94,7 +90,6 @@ class MAGNUM_EXPORT MeshData2D {
         inline const std::vector<Vector2>* textureCoords2D(std::uint32_t id) const { return _textureCoords2D[id]; } /**< @overload */
 
     private:
-        std::string _name;
         Mesh::Primitive _primitive;
         std::vector<std::uint32_t>* _indices;
         std::vector<std::vector<Point2D>*> _positions;

src/Trade/MeshData3D.h

@@ -42,7 +42,6 @@ class MAGNUM_EXPORT MeshData3D {
     public:
         /**
          * @brief Constructor
-         * @param name              %Mesh name
          * @param primitive         Primitive
          * @param indices           Array with indices or 0, if this is not
          *      indexed mesh
@@ -52,14 +51,11 @@ class MAGNUM_EXPORT MeshData3D {
          * @param textureCoords2D   Array with two-dimensional texture
          *      coordinate arrays or empty array
          */
-        inline MeshData3D(const std::string& name, Mesh::Primitive primitive, std::vector<std::uint32_t>* indices, std::vector<std::vector<Point3D>*> positions, std::vector<std::vector<Vector3>*> normals, std::vector<std::vector<Vector2>*> textureCoords2D): _name(name), _primitive(primitive), _indices(indices), _positions(positions), _normals(normals), _textureCoords2D(textureCoords2D) {}
+        inline MeshData3D(Mesh::Primitive primitive, std::vector<std::uint32_t>* indices, std::vector<std::vector<Point3D>*> positions, std::vector<std::vector<Vector3>*> normals, std::vector<std::vector<Vector2>*> textureCoords2D): _primitive(primitive), _indices(indices), _positions(positions), _normals(normals), _textureCoords2D(textureCoords2D) {}
 
         /** @brief Destructor */
         ~MeshData3D();
 
-        /** @brief %Mesh name */
-        inline std::string name() const { return _name; }
-
         /** @brief Primitive */
         inline Mesh::Primitive primitive() const { return _primitive; }
 
@@ -107,7 +103,6 @@ class MAGNUM_EXPORT MeshData3D {
         inline const std::vector<Vector2>* textureCoords2D(std::uint32_t id) const { return _textureCoords2D[id]; } /**< @overload */
 
     private:
-        std::string _name;
         Mesh::Primitive _primitive;
         std::vector<std::uint32_t>* _indices;
         std::vector<std::vector<Point3D>*> _positions;

src/Trade/MeshObjectData2D.h

@@ -38,7 +38,6 @@ class MeshObjectData2D: public ObjectData2D {
     public:
         /**
          * @brief Constructor
-         * @param name              %Mesh object name
          * @param children          Child objects
          * @param transformation    Transformation (relative to parent)
          * @param instance          Instance ID
@@ -46,7 +45,7 @@ class MeshObjectData2D: public ObjectData2D {
          *
          * Creates object with mesh instance type.
          */
-        inline MeshObjectData2D(const std::string& name, const std::vector<std::uint32_t>& children, const Matrix4& transformation, std::uint32_t instance, std::uint32_t material): ObjectData2D(name, children, transformation, InstanceType::Mesh, instance), _material(material) {}
+        inline MeshObjectData2D(const std::vector<std::uint32_t>& children, const Matrix4& transformation, std::uint32_t instance, std::uint32_t material): ObjectData2D(children, transformation, InstanceType::Mesh, instance), _material(material) {}
 
         /** @brief Material ID */
         inline std::uint32_t material() const { return _material; }

src/Trade/MeshObjectData3D.h

@@ -38,7 +38,6 @@ class MeshObjectData3D: public ObjectData3D {
     public:
         /**
          * @brief Constructor
-         * @param name              %Mesh object name
          * @param children          Child objects
          * @param transformation    Transformation (relative to parent)
          * @param instance          Instance ID
@@ -46,7 +45,7 @@ class MeshObjectData3D: public ObjectData3D {
          *
          * Creates object with mesh instance type.
          */
-        inline MeshObjectData3D(const std::string& name, const std::vector<std::uint32_t>& children, const Matrix4& transformation, std::uint32_t instance, std::uint32_t material): ObjectData3D(name, children, transformation, InstanceType::Mesh, instance), _material(material) {}
+        inline MeshObjectData3D(const std::vector<std::uint32_t>& children, const Matrix4& transformation, std::uint32_t instance, std::uint32_t material): ObjectData3D(children, transformation, InstanceType::Mesh, instance), _material(material) {}
 
         /** @brief Material ID */
         inline std::uint32_t material() const { return _material; }

src/Trade/ObjectData2D.h

@@ -19,7 +19,9 @@
  * @brief Class Magnum::Trade::ObjectData2D
  */
 
-#include "Math/Matrix4.h"
+#include <vector>
+
+#include "Math/Matrix3.h"
 #include "Magnum.h"
 
 namespace Magnum { namespace Trade {
@@ -47,28 +49,23 @@ class ObjectData2D {
 
         /**
          * @brief Constructor
-         * @param name              Object name
          * @param children          Child objects
          * @param transformation    Transformation (relative to parent)
          * @param instanceType      Instance type
          * @param instanceId        Instance ID
          */
-        inline ObjectData2D(const std::string& name, const std::vector<std::uint32_t>& children, const Matrix3& transformation, InstanceType instanceType, std::uint32_t instanceId): _name(name), _children(children), _transformation(transformation), _instanceType(instanceType), _instanceId(instanceId) {}
+        inline ObjectData2D(const std::vector<std::uint32_t>& children, const Matrix3& transformation, InstanceType instanceType, std::uint32_t instanceId): _children(children), _transformation(transformation), _instanceType(instanceType), _instanceId(instanceId) {}
 
         /**
          * @brief Constructor for empty instance
-         * @param name              Object name
          * @param children          Child objects
          * @param transformation    Transformation (relative to parent)
          */
-        inline ObjectData2D(const std::string& name, const std::vector<std::uint32_t>& children, const Matrix3& transformation): _name(name), _children(children), _transformation(transformation), _instanceType(InstanceType::Empty), _instanceId(-1) {}
+        inline ObjectData2D(const std::vector<std::uint32_t>& children, const Matrix3& transformation): _children(children), _transformation(transformation), _instanceType(InstanceType::Empty), _instanceId(-1) {}
 
         /** @brief Destructor */
         inline virtual ~ObjectData2D() {}
 
-        /** @brief %Object name */
-        inline std::string name() const { return _name; }
-
         /** @brief Child objects */
         inline std::vector<std::uint32_t>& children() { return _children; }
 
@@ -92,7 +89,6 @@ class ObjectData2D {
         inline std::int32_t instanceId() const { return _instanceId; }
 
     private:
-        std::string _name;
         std::vector<std::uint32_t> _children;
         Matrix3 _transformation;
         InstanceType _instanceType;

src/Trade/ObjectData3D.h

@@ -19,6 +19,8 @@
  * @brief Class Magnum::Trade::ObjectData3D
  */
 
+#include <vector>
+
 #include "Math/Matrix4.h"
 #include "Magnum.h"
 
@@ -48,28 +50,23 @@ class ObjectData3D {
 
         /**
          * @brief Constructor
-         * @param name              Object name
          * @param children          Child objects
          * @param transformation    Transformation (relative to parent)
          * @param instanceType      Instance type
          * @param instanceId        Instance ID
          */
-        inline ObjectData3D(const std::string& name, const std::vector<std::uint32_t>& children, const Matrix4& transformation, InstanceType instanceType, std::uint32_t instanceId): _name(name), _children(children), _transformation(transformation), _instanceType(instanceType), _instanceId(instanceId) {}
+        inline ObjectData3D(const std::vector<std::uint32_t>& children, const Matrix4& transformation, InstanceType instanceType, std::uint32_t instanceId): _children(children), _transformation(transformation), _instanceType(instanceType), _instanceId(instanceId) {}
 
         /**
          * @brief Constructor for empty instance
-         * @param name              Object name
          * @param children          Child objects
          * @param transformation    Transformation (relative to parent)
          */
-        inline ObjectData3D(const std::string& name, const std::vector<std::uint32_t>& children, const Matrix4& transformation): _name(name), _children(children), _transformation(transformation), _instanceType(InstanceType::Empty), _instanceId(-1) {}
+        inline ObjectData3D(const std::vector<std::uint32_t>& children, const Matrix4& transformation): _children(children), _transformation(transformation), _instanceType(InstanceType::Empty), _instanceId(-1) {}
 
         /** @brief Destructor */
         inline virtual ~ObjectData3D() {}
 
-        /** @brief %Object name */
-        inline std::string name() const { return _name; }
-
         /** @brief Child objects */
         inline std::vector<std::uint32_t>& children() { return _children; }
 
@@ -93,7 +90,6 @@ class ObjectData3D {
         inline std::int32_t instanceId() const { return _instanceId; }
 
     private:
-        std::string _name;
         std::vector<std::uint32_t> _children;
         Matrix4 _transformation;
         InstanceType _instanceType;

src/Trade/PhongMaterialData.h

@@ -32,13 +32,12 @@ class PhongMaterialData: public AbstractMaterialData {
     public:
         /**
          * @brief Constructor
-         * @param name              Material name
          * @param ambientColor      Ambient color
          * @param diffuseColor      Diffuse color
          * @param specularColor     Specular color
          * @param shininess         Shininess
          */
-        PhongMaterialData(const std::string& name, const Vector3& ambientColor, const Vector3& diffuseColor, const Vector3& specularColor, GLfloat shininess): AbstractMaterialData(name, Phong), _ambientColor(ambientColor), _diffuseColor(diffuseColor), _specularColor(specularColor), _shininess(shininess) {}
+        PhongMaterialData(const Vector3& ambientColor, const Vector3& diffuseColor, const Vector3& specularColor, GLfloat shininess): AbstractMaterialData(Phong), _ambientColor(ambientColor), _diffuseColor(diffuseColor), _specularColor(specularColor), _shininess(shininess) {}
 
         /** @brief Ambient color */
         inline Vector3 ambientColor() const { return _ambientColor; }

src/Trade/SceneData.h

@@ -36,14 +36,10 @@ class MAGNUM_EXPORT SceneData {
     public:
         /**
          * @brief Constructor
-         * @param name          Scene name
          * @param children2D    Two-dimensional child objects
          * @param children3D    Three-dimensional child objects
          */
-        inline SceneData(const std::string& name, const std::vector<std::uint32_t>& children2D, const std::vector<std::uint32_t>& children3D): _name(name), _children2D(children2D), _children3D(children3D) {}
+        inline SceneData(const std::vector<std::uint32_t>& children2D, const std::vector<std::uint32_t>& children3D): _children2D(children2D), _children3D(children3D) {}
-
-        /** @brief Scene name */
-        inline std::string name() const { return _name; }
 
         /** @brief Two-dimensional child objects */
         inline const std::vector<std::uint32_t>& children2D() const { return _children2D; }
@@ -52,7 +48,6 @@ class MAGNUM_EXPORT SceneData {
         inline const std::vector<std::uint32_t>& children3D() const { return _children3D; }
 
     private:
-        std::string _name;
         std::vector<std::uint32_t> _children2D,
             _children3D;
 };

src/Trade/TextureData.h

@@ -31,19 +31,6 @@ class MAGNUM_EXPORT TextureData {
     TextureData(TextureData&& other) = delete;
     TextureData& operator=(const TextureData& other) = delete;
     TextureData& operator=(TextureData&& other) = delete;
-
-    public:
-        /**
-         * @brief Constructor
-         * @param name      %Texture name
-         */
-        inline TextureData(const std::string& name): _name(name) {}
-
-        /** @brief %Texture name */
-        inline std::string name() const { return _name; }
-
-    private:
-        std::string _name;
 };
 
 }}