Unigine::ImportProcessor Class
| Header: | #include <UnigineImport.h> |
This class is used to manage import processors. An import processor is a module that saves objects generated by an importer on the basis of metadata on the whole scene or some of its components to files in UNIGINE native format and performs auxiliary operations during the import process (data preparation, file management, etc.). You can use a set of different processors for each scene component or a single processor for all of them. There are also two specific types of processors:
- Pre-processors - perform additional operations with scene metadata prior to generation of UNIGINE's objects.
- Post-processors - perform additional operations with files generated in the process of import (e.g. copying files to other folders, adding files to packages, etc.).
Notice
This is a base class for all import processors. Your custom import processor class must be inherited from it.
You can override one (or all) onProcess*() methods to define the types of components to be processed by it, these overridden methods will be called by the importer when corresponding import operations are performed.
Notice
For pre- and post-processors only the onProcessScene() method is to be overridden.
ImportProcessor Class
Members
ImportProcessor ( ) #
Constructor. Creates an empty import processor.Ptr<ImportProcessor> getImportProcessor ( ) const#
Returns the import processor itself.Return value
Import processor itself.void setImporter ( const Ptr<Importer> & importer ) #
Sets the importer for the import processor.Arguments
Ptr<Importer> getImporter ( ) const#
Returns the importer for the import processor.Return value
Importer currently used.void setOutputPath ( const char * path ) #
Sets the specified output path to be used to put files with imported scene elements to.Arguments
- const char * path - Output path to be set.
const char * getOutputPath ( ) const#
Returns the current output path used to put files with imported scene elements to.Return value
Current output path.bool processScene ( const Ptr<ImportScene> & scene ) #
Performs scene processing: modifies the metadata of scene elements or files generated in the process of importing the scene.Notice
This method is used by pre-processors and post-processors. To customize actions to be performed on scene processing, when implementing a custom pre- or post-processor, you can override the onProcessScene() method.
Arguments
- const Ptr<ImportScene> & scene - Scene to be processed.
Return value
true if the specified scene is successfully processed; otherwise, false.bool processTexture ( const Ptr<ImportTexture> & import_texture ) #
Performs texture processing: saves the specified generated texture to a corresponding file in the output directory.Notice
To customize actions to be performed on texture processing, when implementing a custom import processor, you can override the onProcessTexture() method.
Arguments
- const Ptr<ImportTexture> & import_texture - Instance of the ImportTexture class containing information about the imported texture.
Return value
true if the specified texture is successfully imported to a file; otherwise, false.bool processMesh ( const Ptr<Mesh> & mesh, const Ptr<ImportMesh> & import_mesh ) #
Performs mesh processing: saves the specified generated mesh to a corresponding *.mesh file in the output directory.Notice
To customize actions to be performed on mesh processing, when implementing a custom import processor, you can override the onProcessMesh() method.
Arguments
- const Ptr<Mesh> & mesh - UNIGINE's mesh instance generated for the specified imported mesh.
- const Ptr<ImportMesh> & import_mesh - Instance of the ImportMesh class containing information about the imported mesh.
Return value
true if the specified mesh is successfully imported to a file; otherwise, false.bool processLight ( const Ptr<Light> & light, const Ptr<ImportLight> & import_light ) #
Performs light processing: saves the specified generated light source to a corresponding file in the output directory.Notice
To customize actions to be performed on light processing, when implementing a custom import processor, you can override the onProcessLight() method.
Arguments
- const Ptr<Light> & light - UNIGINE's light instance generated for the specified imported light.
- const Ptr<ImportLight> & import_light - Instance of the ImportLight class containing information about the imported light.
Return value
true if the specified light is successfully processed; otherwise, false.bool processCamera ( const Ptr<Player> & camera, const Ptr<ImportCamera> & import_camera ) #
Performs camera processing: saves the specified generated player to a corresponding file in the output directory.Notice
To customize actions to be performed on camera processing, when implementing a custom import processor, you can override the onProcessCamera() method.
Arguments
- const Ptr<Player> & camera - UNIGINE's player instance generated for the specified imported camera.
- const Ptr<ImportCamera> & import_camera - Instance of the ImportCamera class containing information about the imported camera.
Return value
true if the specified camera is successfully processed; otherwise, false.bool processAnimation ( const Ptr<MeshAnimation> & animation, const Ptr<ImportAnimation> & import_animation ) #
Performs mesh animation processing: saves the specified generated mesh animation to a corresponding file in the output directory.Notice
To customize actions to be performed on mesh animation processing, when implementing a custom import processor, you can override the onProcessAnimation() method.
Arguments
- const Ptr<MeshAnimation> & animation - UNIGINE's mesh animation instance generated for the specified imported animation.
- const Ptr<ImportAnimation> & import_animation - Instance of the ImportAnimation class containing information about the imported animation.
Return value
true if the specified animation is successfully processed; otherwise, false.bool processAnimation ( const Ptr<MeshAnimation> & animation, const Ptr<ImportMesh> & import_mesh, const Ptr<ImportAnimation> & import_animation ) #
Performs mesh animation processing: saves the specified generated mesh animation to a corresponding file in the output directory.Notice
To customize actions to be performed on mesh animation processing, when implementing a custom import processor, you can override the onProcessAnimation() method.
Arguments
- const Ptr<MeshAnimation> & animation - UNIGINE's mesh animation instance generated for the specified imported animation.
- const Ptr<ImportMesh> & import_mesh - Instance of the ImportMesh class containing information about the imported mesh.
- const Ptr<ImportAnimation> & import_animation - Instance of the ImportAnimation class containing information about the imported animation.
Return value
true if the specified animation is successfully processed; otherwise, false.bool processNode ( const Ptr<Node> & node, const Ptr<ImportNode> & import_node ) #
Performs node processing: saves the specified generated node to a corresponding *.node file in the output directory.Notice
To customize actions to be performed on node processing, when implementing a custom import processor, you can override the onProcessNode() method.
Arguments
- const Ptr<Node> & node - UNIGINE's node instance generated for the specified imported node.
- const Ptr<ImportNode> & import_node - Instance of the ImportNode class containing information about the imported node.
Return value
true if the specified node is successfully processed; otherwise, false.bool processNodeChild ( const Ptr<Node> & node_parent, const Ptr<ImportNode> & import_node_parent, const Ptr<Node> & node_child, const Ptr<ImportNode> & import_node_child ) #
Performs node processing: saves the specified generated node along with the specified child to a corresponding *.node file in the output directory.Notice
To customize actions to be performed on node processing, when implementing a custom import processor, you can override the onProcessNodeChild() method.
Arguments
- const Ptr<Node> & node_parent - Target UNIGINE's node instance to store the specified imported parent node.
- const Ptr<ImportNode> & import_node_parent - Instance of the ImportNode class containing information about the imported parent node.
- const Ptr<Node> & node_child
- const Ptr<ImportNode> & import_node_child - Instance of the ImportNode class containing information about the imported child node.
Return value
true if the specified parent node with its specified child node is successfully processed; otherwise, false.bool processMaterial ( const Ptr<Material> & material, const Ptr<ImportMaterial> & import_material ) #
Performs material processing: saves the specified generated material to a corresponding file in the output directory.Notice
To customize actions to be performed on material processing, when implementing a custom import processor, you can override the onProcessMaterial() method.
Arguments
- const Ptr<Material> & material - UNIGINE's material instance generated for the specified imported material.
- const Ptr<ImportMaterial> & import_material - Instance of the ImportMaterial class containing information about the imported material.
Return value
true if the specified material is successfully processed; otherwise, false.bool onProcessScene ( const Ptr<ImportScene> & scene ) #
Scene processing event handler function. This function is called each time when the processScene() function is called. You can specify your custom actions to be performed: modify the metadata of scene elements (pre-process) or files generated in the process of importing the scene (post-process).Notice
This method is used by pre-processors and post-processors.
Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessScene(ImportScene *scene) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessScene(ImportScene *scene)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<ImportScene> & scene - Scene to be processed.
Return value
true if the specified scene is successfully processed; otherwise, false.bool onProcessTexture ( const Ptr<ImportTexture> & import_texture ) #
Texture processing event handler function. This function is called each time when the processTexture() function is called. You can specify your custom actions to be performed on texture processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessTexture(ImportTexture *import_texture) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessTexture(ImportTexture *import_texture)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<ImportTexture> & import_texture - Instance of the ImportTexture class containing information about the imported texture.
Return value
true if the specified texture is successfully processed; otherwise, false.bool onProcessMesh ( const Ptr<Mesh> & mesh, const Ptr<ImportMesh> & import_mesh ) #
Mesh processing event handler function. This function is called each time when the processMesh() function is called. You can specify your custom actions to be performed on mesh processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessMesh(MeshPtr &mesh, ImportMesh *import_mesh) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessMesh(MeshPtr &mesh, ImportMesh *import_mesh)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<Mesh> & mesh - UNIGINE's mesh instance generated for specified imported mesh.
- const Ptr<ImportMesh> & import_mesh - Instance of the ImportMesh class containing information about the imported mesh.
Return value
true if the specified mesh is successfully processed; otherwise, false.bool onProcessLight ( const Ptr<Light> & light, const Ptr<ImportLight> & import_light ) #
Light processing event handler function. This function is called each time when the processLight() function is called. You can specify your custom actions to be performed on light processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessLight(LightPtr &light, ImportLight *import_light) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessLight(LightPtr &light, ImportLight *import_light)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<Light> & light - UNIGINE's light instance generated for specified imported light.
- const Ptr<ImportLight> & import_light - Instance of the ImportLight class containing information about the imported light.
Return value
true if the specified light is successfully processed; otherwise, false.bool onProcessCamera ( const Ptr<Player> & camera, const Ptr<ImportCamera> & import_camera ) #
Camera processing event handler function. This function is called each time when the processCamera() function is called. You can specify your custom actions to be performed on camera processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessCamera(PlayerPtr &camera, ImportCamera *import_camera) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessCamera(PlayerPtr &camera, ImportCamera *import_camera)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<Player> & camera - UNIGINE's player instance generated for the specified imported camera.
- const Ptr<ImportCamera> & import_camera - Instance of the ImportCamera class containing information about the imported camera.
Return value
true if the specified camera is successfully processed; otherwise, false.bool onProcessAnimation ( const Ptr<MeshAnimation> & animation, const Ptr<ImportAnimation> & import_animation ) #
Animation processing event handler function. This function is called each time when the processAnimation() function is called. You can specify your custom actions to be performed on animation processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessAnimation(MeshAnimationPtr &animation, ImportMesh *import_mesh, ImportAnimation *import_animation) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessAnimation(MeshAnimationPtr &animation, ImportMesh *import_mesh, ImportAnimation *import_animation)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<MeshAnimation> & animation - UNIGINE's mesh animation instance generated for the specified imported mesh animation.
- const Ptr<ImportAnimation> & import_animation - Instance of the ImportAnimation class containing information about the imported animation.
Return value
true if the specified animation is successfully processed; otherwise, false.bool onProcessAnimation ( const Ptr<MeshAnimation> & animation, const Ptr<ImportMesh> & import_mesh, const Ptr<ImportAnimation> & import_animation ) #
Animation processing event handler function. This function is called each time when the processAnimation() function is called. You can specify your custom actions to be performed on animation processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessAnimation(MeshAnimationPtr &animation, ImportMesh *import_mesh, ImportAnimation *import_animation) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessAnimation(MeshAnimationPtr &animation, ImportMesh *import_mesh, ImportAnimation *import_animation)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<MeshAnimation> & animation - UNIGINE's mesh animation instance generated for the specified imported mesh animation.
- const Ptr<ImportMesh> & import_mesh - Instance of the ImportMesh class containing information about the imported mesh.
- const Ptr<ImportAnimation> & import_animation - Instance of the ImportAnimation class containing information about the imported animation.
Return value
true if the specified animation is successfully processed; otherwise, false.bool onProcessNode ( const Ptr<Node> & node, const Ptr<ImportNode> & import_node ) #
Node processing event handler function. This function is called each time when the processNode() function is called. You can specify your custom actions to be performed on node processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessNode(NodePtr &node, ImportNode *import_node) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessNode(NodePtr &node, ImportNode *import_node)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<Node> & node - UNIGINE's node instance generated for the specified imported node.
- const Ptr<ImportNode> & import_node - Instance of the ImportNode class containing information about the imported node.
Return value
true if the specified node is successfully processed; otherwise, false.bool onProcessNodeChild ( const Ptr<Node> & node_parent, const Ptr<ImportNode> & import_node_parent, const Ptr<Node> & node_child, const Ptr<ImportNode> & import_node_child ) #
Node processing event handler function for node hierarchies. This function is called each time when the processNodeChild() function is called. You can specify your custom actions to be performed on node processing (e.g. assigning properties to node's children).Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessNodeChild(const NodePtr &node_parent, const ImportNodePtr &import_node_parent, const NodePtr &node_child, const ImportNodePtr &import_node_child) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessNode(NodePtr &node, ImportNode *import_node)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<Node> & node_parent - Target UNIGINE's node instance to store the specified imported parent node.
- const Ptr<ImportNode> & import_node_parent - Instance of the ImportNode class containing information about the imported parent node.
- const Ptr<Node> & node_child - Target UNIGINE's node instance to store the specified imported child node.
- const Ptr<ImportNode> & import_node_child - Instance of the ImportNode class containing information about the imported child node.
Return value
true if the specified parent node is successfully processed with its specified child node; otherwise, false.bool onProcessMaterial ( const Ptr<Material> & material, const Ptr<ImportMaterial> & import_material ) #
Material processing event handler function. This function is called each time when the processMaterial() function is called. You can specify your custom actions to be performed on material processing.Source code (C++)
class MyCustomProcessor : public Unigine::ImportProcessor
{
public:
MyCustomProcessor();
virtual ~MyCustomProcessor();
/*...*/
// overrides of event functions
protected:
virtual bool onProcessMaterial(MaterialPtr &material, ImportMaterial *import_material) override;
/*...*/
};
/*...*/
bool MyCustomProcessor::onProcessMaterial(MaterialPtr &material, ImportMaterial *import_material)
{
bool result = false;
// your custom actions
return result;
}Arguments
- const Ptr<Material> & material - UNIGINE's material instance generated for the specified imported material.
- const Ptr<ImportMaterial> & import_material - Instance of the ImportMaterial class containing information about the imported material.
Return value
true if the specified material is successfully processed; otherwise, false.Last update:
2024-12-13
Help improve this article
Was this article helpful?
(or select a word/phrase and press Ctrl+Enter)