Ce contenu est destiné aux débutants qui souhaitent essayer d'utiliser des modèles de conception avec Maya Python. Je laisserai l'explication détaillée du modèle de conception à d'autres sites, Comment le code s'améliore-t-il lorsque vous l'utilisez réellement? Se concentrer sur. Comme exemple d'application, prenez quelque chose comme un exportateur de données comme exemple.
Je souhaite améliorer ma capacité de conception et la qualité de mon code en utilisant réellement des modèles de conception. Je veux trouver un modèle qui puisse être utilisé en particulier dans la mise en œuvre d'outils.
Le modèle suivant est utilisé cette fois. Pour plus de détails sur le modèle, veuillez consulter le site de référence en bas de page.
| modèle | Aperçu (ma perception) | mérite |
|---|---|---|
| TemplateMethod | Abstenez la méthode appelée par la classe parent et laissez l'implémentation à l'intérieur de la méthode à la sous-classe. | Flux de processusDe chaque processus en liantComportementEst laissé à la sous-classe. |
| FactoryMethod | Lors de l'utilisation d'un autre objet dans la classe, abstraire le processus de génération et utiliser l'objet de génération (abstrait). Le processus de génération et la mise en œuvre de la méthode sont laissés à chaque sous-classe. | Il hérite de la bonté de la méthode de modèle. Lors de la création d'un autre objet et de l'appel d'une méthodeFlux de processus・produire・ComportementPeut être séparé. |
| Factory | Préparez et utilisez une classe qui crée uniquement des objets selon les conditions spécifiées. | Du côté qui utilise l'objet, l'objet selon les conditionsproduirePeut être séparé. |
J'ai choisi le processus d'exportation des informations de scène Maya car je pensais que c'était un processus relativement important. L'image est comme la sortie des données appropriées à l'aide de l'exportation FBX. Il est reconnu que les spécifications sont susceptibles d'être modifiées ultérieurement, comme la sélection des données de sortie ou l'exécution d'un traitement spécial en fonction des conditions. Il décrit à quoi ressemblera le code avant et après l'application du modèle de conception.
Si vous organisez les processus sans penser à rien en particulier, cela ressemblera à ce qui suit.
scene_exporter.py
def scene_export(option):
"""Modèles de sortie et animations dans la scène"""
#Pré-traitement
if option.mode == ExportMode.head:
#Rechercher les données de maillage de tête dans la hiérarchie
#Faire quelque chose
#Exportation
if option.mode == ExportMode.body:
#Rechercher les données de maillage corporel dans la hiérarchie
#Faire quelque chose
#Exportation
if option.mode == ExportMode.animation:
#Rechercher des données de squelette dans la hiérarchie
#Faire quelque chose
#Exportation
#Post-traitement
Pour le moment, appliquez le modèle de méthode modèle pour standardiser le processus d'exportation.
exporter.py
from abc import ABCMeta, abstractmethod
class BaseExporter(object):
"""Classe de base de l'exportateur"""
__metaclass__ = ABCMeta
def export(self):
select_export_targets()
export_selection()
@abstractmethod
def select_export_targets(self):
"""Sélectionnez la cible d'exportation"""
pass
@abstractmethod
def export_selection(self):
"""Exporter l'objet sélectionné"""
pass
class HeadExporter(BaseExporter):
"""Classe d'exportateur pour HEAD"""
def select_export_targets(self):
cmds.select("|char|mesh|head")
def export_selection(self):
#Implémentation du traitement de sortie pour HEAD
class BodyExporter(BaseExporter):
"""Classe d'exportateur pour BODY"""
def select_export_targets(self):
cmds.select("|char|mesh|body")
def export_selection(self):
#Implémentation du traitement de sortie pour BODY
class AnimExporter(BaseExporter):
"""Classe d'exportateur pour ANIM"""
def select_export_targets(self):
cmds.select("|char|skel|root")
def export_selection(self):
#Implémentation du traitement de sortie pour ANIM
scene_exporter_v2.py
def scene_export(option):
"""Modèles de sortie et animations dans la scène"""
#Pré-traitement
if option.mode == ExportMode.head:
HeadExporter().export()
if option.mode == ExportMode.body:
BodyExporter().export()
if option.mode == ExportMode.animation:
AnimExporter().export()
#Post-traitement
Même si TemplateMethod est appliqué, la maintenabilité lors de l'ajout d'un mode n'a pas encore été améliorée. Créez une nouvelle classe Factory et laissez-la créer des branches et générer. Le processus principal utilise simplement la sous-classe BaseExporter où export () existe.
exporter_factory.py
class BaseExporterFactory(object):
"""Classe d'usine de la classe BaseExporter"""
def create(option):
if option.mode == ExportMode.head:
return HeadExporter()
if option.mode == ExportMode.body:
return BodyExporter()
if option.mode == ExportMode.animation:
return AnimExporter()
scene_exporter_v3.py
def scene_export(option):
"""Modèles de sortie et animations dans la scène"""
#Pré-traitement
BaseExporterFactory().create(option).export()
#Post-traitement
Lorsque la spécification est ajoutée, nous "créerons et utiliserons un objet journal dans la classe BaseExporter". Appliquez FactoryMethod car vous allez créer et utiliser des objets dans la classe BaseExporter.
Implémentez le parent et les sous-classes d'ExporterLog, qui est le produit de FactoryMethod.
exporter_log.py
from abc import ABCMeta, abstractmethod
class BaseExporterLog(object):
"""Classe de base du journal de l'exportateur"""
__metaclass__ = ABCMeta
@abstractmethod
def open(self):
"""Commencer la journalisation"""
pass
@abstractmethod
def close(self):
"""Terminer la journalisation"""
pass
class MyExporterLog(BaseExporterLog):
"""Sous-classe du journal des exportateurs"""
def open(self):
print "export logging start"
def close(self):
print "export logging close"
Définissez la génération et l'utilisation du journal dans BaseExporter, le créateur de FactoryMethod, et laissez l'implémentation aux sous-classes.
exporter.py
from abc import ABCMeta, abstractmethod
class BaseExporter(object):
"""Classe de base de l'exportateur"""
__metaclass__ = ABCMeta
def export(self):
self.log = create_exporter_log()
self.log.open()
select_export_targets()
export_selection()
self.log.close()
@abstractmethod
def create_exporter_log(self):
"""Générer un journal d'exportation"""
pass
@abstractmethod
def select_export_targets(self):
"""Sélectionnez la cible d'exportation"""
pass
@abstractmethod
def export_selection(self):
"""Exporter l'objet sélectionné"""
pass
class HeadExporter(BaseExporter):
"""Classe d'exportateur pour HEAD"""
def create_exporter_log(self):
return MyExporterLog()
def select_export_targets(self):
cmds.select("|char|mesh|head")
def export_selection(self):
#Implémentation du traitement de sortie pour HEAD
Après cela, je pense que cela peut ou non être comme utiliser des journaux du côté du traitement principal.
scene_exporter_v4.py
def scene_export(option):
"""Modèles de sortie et animations dans la scène"""
#Pré-traitement
exporter = BaseExporterFactory().create(option)
exporter.export()
#Traiter ou non le journal
#Post-traitement
Indépendamment du fait que la reconnaissance et les exemples sont appropriés, regarder le code après l'adaptation du modèle est quelque peu convaincant. Si c'est juste la quantité de code, le code de base est le plus petit, mais étant donné qu'il sera changé plus tard, j'ai utilisé un modèle Il est efficace de consacrer du temps à la refactorisation.
Avec le modèle utilisé cette fois, j'ai du mal à comprendre le modèle de la méthode d'usine. Cela ressemble à une dérivation du modèle Factory à partir du nom, mais j'ai reconnu qu'il s'agissait d'une dérivation de la méthode du modèle. Parce que je le pensais, le flux d'adaptation des modèles a également amené la méthode des modèles en premier.
Je souhaite continuer à étudier en attendant des conseils et des conseils issus de domaines variés.
Recommended Posts