Maya에서 Alembic 게시

Maya에서 Alembic 게시

이 튜토리얼에서는 Maya에서 지오메트리 그룹을 게시할 때 Alembic 파일을 내보내도록 Multi Publish를 구성하는 방법을 보여 줍니다.

시작하기 전에

Maya에서 Alembic 캐시 파일을 게시하려면 플러그인 매니저에서 AbcExport 플러그인이 로드되어야 합니다. 게시 준비가 된, 그룹 지정된 일부 메쉬가 있는 샷 씬이 필요할 수도 있습니다.

 

ae_prerequisites.ko.png

1단계 - 환경 준비

먼저 Shot_Step 환경에 대한 tk-multi-publish 앱을 설치합니다.

환경에 앱을 추가하는 것 외에도 App Store에서 앱을 다운로드하고 최신 버전을 실행 중인지도 확인합니다.

앱이 설치되면 Shot_Step 환경 파일을 열고(일반적으로 <pipeline_configuration_root>/config/env/Shot_Step.yml에 있음) tk-maya 엔진 아래 수정할 tk-multi-publish 앱 항목을 찾습니다.

engines:
  tk-maya:
    apps:
      tk-multi-publish:
        ...

팁: 앱의 새 구성을 테스트해 보려면 환경의 항목을 복제하여 다른 이름으로 지정할 수 있습니다. 대부분의 앱은 기본 메뉴에서 구분할 수 있도록 별도의 표시 이름도 지원합니다.

이 예에서는 앱 이름 및 표시 이름을 tk-multi-publish-alembic-examplePublish Alembic Example로 각각 수정합니다. 이제 초기 구성이 다음과 같이 표시됩니다.

tk-multi-publish-alembic-example:
  allow_taskless_publishes: true
  display_name: Publish Alembic Example
  expand_single_items: false
  hook_copy_file: default
  hook_post_publish: default
  hook_primary_pre_publish: default
  hook_primary_publish: default
  hook_scan_scene: default
  hook_secondary_pre_publish: default
  hook_secondary_publish: default
  hook_thumbnail: default
  location: {name: tk-multi-publish, type: app_store, version: v0.2.7}
  primary_description: Publish and version up the current work file
  primary_display_name: Current Work File
  primary_icon: ''
  primary_publish_template: maya_shot_publish
  primary_scene_item_type: work_file
  primary_tank_type: Maya Scene
  secondary_outputs: []
  template_work: maya_shot_work

이 설정 중 일부를 변경하지만 전체 참조의 경우 Multi Publish 설명서를 참조하십시오.

구성을 저장한 다음 Maya에서 엔진과 앱을 다시 로드합니다. 이제 기본 메뉴에 새 Publish Alembic Example 항목이 생깁니다.

2단계 - 씬 스캔

앱에서 가장 먼저 수행하는 작업은 게시할 항목에 대한 씬을 스캔하는 것입니다. 이를 위해 hook_scan_scene 설정에서 지정된 후크를 사용합니다. 기본 구현에서는 씬 자체를 검색하므로 이를 시작점으로 사용하여 씬을 확장하여 씬에서 그룹 지정된 지오메트리를 추가로 찾을 수 있습니다.

신속하게 요약하자면 이 구현의 시작점으로 기본 후크를 사용하려면 다음을 수행해야 합니다.

  • 기본 구현을 찾습니다. <code_root>/install/apps/app_store/tk-multi-publish/<version>/hooks/scan_scene_tk-maya.py에서 찾을 수 있습니다.
  • 이 후크를 현재 파이프라인 구성의 후크 디렉토리에 복사합니다(예: <pc_root>/config/hooks).
  • 고유한 이름으로 변경합니다(예: alembic_example_scan_scene.py).
  • hook_scan_scene: alembic_example_scan_scene 후크를 사용하도록 hook_scan_scene 설정을 업데이트합니다.

이제 앱에서 스캔 씬 후크 버전을 사용하므로 계속 진행하여 엽니다.

후크는 씬에서 찾은 항목 목록을 반환하고 기본 구현은 씬 자체를 찾으므로 하나 이상의 메쉬가 포함된 최상위 레벨의 그룹을 모두 찾을 수 있도록 확장합니다. 이를 위해 실행 메서드의 끝에 다음 코드를 추가합니다.

...

# look for root level groups that have meshes as children:
for grp in cmds.ls(assemblies=True, long=True):
    if cmds.ls(grp, dag=True, type="mesh"):
        # include this group as a 'mesh_group' type
        items.append({"type":"mesh_group", "name":grp})

...

목록에 항목을 추가할 때 mesh_group 형식을 지정합니다.

items.append({"type":"mesh_group", "name":grp})

1분 후에 앱에서 이 type이 각 항목과 출력을 연결하는 데 어떻게 사용되는지 확인할 수 있습니다. 매우 중요하므로 기억하십시오.

다음은 alembic_example_scan_scene.py의 전체 버전입니다.

import os
import maya.cmds as cmds

import tank
from tank import Hook
from tank import TankError

class ScanSceneHook(Hook):
    """
    Hook to scan scene for items to publish
    """

    def execute(self, **kwargs):
        """
        Main hook entry point
        :returns:       A list of any items that were found to be published.  
                        Each item in the list should be a dictionary containing 
                        the following keys:
                        {
                            type:   String
                                    This should match a scene_item_type defined in
                                    one of the outputs in the configuration and is 
                                    used to determine the outputs that should be 
                                    published for the item

                            name:   String
                                    Name to use for the item in the UI

                            description:    String
                                            Description of the item to use in the UI

                            selected:       Bool
                                            Initial selected state of item in the UI.  
                                            Items are selected by default.

                            required:       Bool
                                            Required state of item in the UI.  If True then
                                            item will not be deselectable.  Items are not
                                            required by default.

                            other_params:   Dictionary
                                            Optional dictionary that will be passed to the
                                            pre-publish and publish hooks
                        }
        """   

        items = []

        # get the main scene:
        scene_name = cmds.file(query=True, sn=True)
        if not scene_name:
            raise TankError("Please Save your file before Publishing")

        scene_path = os.path.abspath(scene_name)
        name = os.path.basename(scene_path)

        # create the primary item - this will match the primary output 'scene_item_type':            
        items.append({"type": "work_file", "name": name})

        # look for root level groups that have meshes as children:
        for grp in cmds.ls(assemblies=True, long=True):
            if cmds.ls(grp, dag=True, type="mesh"):
                # include this group as a 'mesh_group' type
                items.append({"type":"mesh_group", "name":grp})

        return items

이제 씬에서 메쉬 그룹을 찾는 방법을 앱에 지정했습니다. 다음 단계는 이 그룹에서 사용할 수 있는 출력을 지정하는 것입니다.

3단계 - 출력 정의

Multi Publish 앱에는 다음 두 가지 유형의 출력이 있습니다.

  • Primary - 일반적으로 기본 출력은 씬 파일을 나타내는 데 사용됩니다. 기본 출력은 하나만 있을 수 있습니다.
  • Secondary - 게시할 추가 항목은 보조 출력으로 표시됩니다. 필요한 만큼 정의할 수 있습니다.

이러한 출력은 다음과 같이 기본 인터페이스의 다른 영역에 표시됩니다.

 

ae_outputs.ko.png

이 예에서는 씬 내의 모든 최상위 메쉬 그룹에 대한 새로운 Alembic 캐시 보조 출력을 정의합니다. 이를 위해 tk-multi-publish-alembic 구성에서 secondary_outputs 설정을 편집합니다.

몇 가지 상세 정보를 입력하고 중요한 사항을 살펴보겠습니다.

...
secondary_outputs:
- description: 'Publish Alembic Cache data for the model'
  display_group: Caches
  display_name: Alembic Cache
  icon: 'icons/alembic_output.png'
  name: alembic_cache
  publish_template: maya_shot_mesh_alembic_cache
  required: false
  scene_item_type: mesh_group
  selected: false
  tank_type: 'Alembic Cache'
...

대부분 자체적으로 설명 가능하지만 자세한 정보는 Multi Publish 참조 설명서를 참조하십시오.

이 예에서 주의해야 할 설정은 다음과 같습니다.

name: alembic_cache

이름은 모든 출력에서 고유해야 하며 primary는 기본 출력용으로 예약되어 있기 때문에 사용할 수 없습니다. 나중에 실제로 게시할 때 이 이름을 사용합니다.

scene_item_type: mesh_group

2단계의 스캔 씬 후크에서 각 항목에 대해 반환된 유형을 기억하십니까? 출력에서 scene_item_type을 동일한 유형으로 설정하면 앱이 mesh_group 유형의 모든 항목에 대해 Alembic Cache 출력을 게시하게 됩니다.

팁: 이 메커니즘을 사용하면 다양한 여러 출력을 하나의 항목 유형과 연결할 수 있으므로 나중에 OBJ 내보내기와 같은 다른 출력을 추가하려는 경우 스캔 후크를 다시 수정하지 않고도 이 작업을 수행할 수 있습니다.

publish_template: maya_shot_mesh_alembic_cache

이 설정을 사용하면 게시된 Alembic 캐시 파일에 사용할 템플릿을 지정할 수 있습니다. 게시할 때 액세스할 수 있습니다.

이 예에서는 다음 템플릿이 사용되었습니다.

# excerpt from templates.yml
keys:
    ...
    grp_name:
        type: str

paths:        
    ...
    maya_shot_mesh_alembic_cache: '@shot_root/publish/maya/{name}[_{grp_name}].v{version}.abc'

기본 구성을 사용하는 경우 이 설정을 templates.yml 파일에 추가할 수 있습니다. 그렇지 않은 경우 템플릿 및/또는 후크가 올바르게 작동하도록 조정해야 할 수 있습니다.

tank_type: Alembic Cache

이 유형은 Shotgun에서 Alembic 캐시 파일을 등록할 때 사용할 고유한 게시 유형입니다. 다시 말하지만, 게시할 때 액세스할 수 있습니다.

icon: 'icons/alembic_output.png'

앱이 이 새로운 유형의 출력을 나타내는 데 사용할 아이콘입니다. 이 아이콘을

구성의 'icons' 디렉토리(예: <pc_root>/config/icons/alembic_output.png)에 저장합니다.

어떻게 표시되는지 보겠습니다. 구성을 저장하고, Maya에서 앱을 다시 로드하고, 테스트 샷 씬을 열고, 메뉴에서 Publish Alembic Example 명령을 실행합니다. 모든 것이 계획대로 진행되면 UI에 나열된 몇 가지 보조 게시를 찾을 수 있습니다.

 

ae_alembic_outputs.ko.png

계속해서 Alembic 캐시 파일을 내보내는 코드를 추가하고 Shotgun에 등록해야 하므로 아직 Publish를 클릭하지 마십시오.

4단계 - 게시 전 확인

게시는 다음 세 단계로 나뉩니다.

  • 게시 전
  • 게시
  • 게시 후

첫 번째는 게시 전 단계로, 게시할 항목의 유효성을 확인하고 사용자에게 문제를 보고할 수 있습니다.

씬을 스캔하는 것과 마찬가지로 게시 전 단계는 hook_secondary_pre_publish 설정에 의해 앱 구성에서 정의된 후크를 통해 구현됩니다.

Step 2의 지침에 따라 기본 후크 <code_root>/install/apps/app_store/tk-multi-publish/<version>/hooks/secondary_pre_publish_tk-maya.py를 구성 후크 디렉토리에 저장하고 이름을 alembic_example_secondary_pre_publish.py로 변경합니다.

그런 다음 구성의 설정을 다음과 같이 편집합니다.

hook_secondary_pre_publish: alembic_example_secondary_pre_publish

이제 앱에서 게시 전 후크 버전을 사용하므로 계속 진행하여 엽니다.

후크는 태스크 목록을 기본 입력으로 사용합니다.

def execute(self, tasks, work_template, progress_cb, **kwargs):
    ...

이 목록은 UI에서 사용자의 선택을 기반으로 하므로 사용자가 게시하도록 선택한 항목만 포함됩니다.

각 태스크는 itemoutput을 포함하는 사전입니다.

  • item은 2단계의 스캔 씬 후크에서 반환된 항목입니다.
  • output에는 3단계의 보조 출력용으로 구성한 name, publish_template 및 tank_type이 포함됩니다.

이 후크의 기본 구현은 사용자가 선택한 모든 태스크를 반복하기 위한 발판을 제공하고 출력 처리 방법을 모를 경우 오류를 보고합니다.

사용자가 스캔 씬 후크에 의해 반환된 그룹을 삭제하거나 수정했을 수 있으므로 삭제 또는 수정하지 않았는지, 게시할 모든 준비가 되었는지 확인하도록 이 구현을 확장해야 합니다.

이렇게 하려면 먼저 아래 내용을

# pre-publish item here, e.g.
#if output["name"] == "foo":
#    ...
#else:
# don't know how to publish this output types!
errors.append("Don't know how to publish this item!")

다음으로 바꿉니다.

# pre-publish alembic_cache output
if output["name"] == "alembic_cache":
    errors.extend(self._validate_item_for_alembic_cache_publish(item))
else:
    # don't know how to publish this output types!
    errors.append("Don't know how to publish this item!")

그런 다음 PrePublishHook 클래스에 새 유효성 확인 메서드를 추가합니다.

def _validate_item_for_alembic_cache_publish(self, item):
    """
    Validate that the item is valid to be exported 
    to an alembic cache
    """
    errors = []
    # check that the group still exists:
    if not cmds.objExists(item["name"]):
        errors.append("This group couldn't be found in the scene!")

    # and that it still contains meshes:
    elif not cmds.ls(item["name"], dag=True, type="mesh"):
        errors.append("This group doesn't appear to contain any meshes!")

    # finally return any errors
    return errors

발견된 모든 문제점이 반환되면 사용자가 게시하기 전에 수정할 수 있습니다. 물론 항목의 유효성 확인을 보다 포괄적으로 수행하기 위해 이를 확장할 수도 있습니다.

다음은 alembic_example_secondary_pre_publish.py의 전체 버전입니다.

import os
import maya.cmds as cmds

import tank
from tank import Hook
from tank import TankError

class PrePublishHook(Hook):
    """
    Single hook that implements pre-publish functionality
    """
    def execute(self, tasks, work_template, progress_cb, **kwargs):
        """
        Main hook entry point
        :tasks:         List of tasks to be pre-published.  Each task is be a 
                        dictionary containing the following keys:
                        {   
                            item:   Dictionary
                                    This is the item returned by the scan hook 
                                    {   
                                        name:           String
                                        description:    String
                                        type:           String
                                        other_params:   Dictionary
                                    }

                            output: Dictionary
                                    This is the output as defined in the configuration - the 
                                    primary output will always be named 'primary' 
                                    {
                                        name:             String
                                        publish_template: template
                                        tank_type:        String
                                    }
                        }

        :work_template: template
                        This is the template defined in the config that
                        represents the current work file

        :progress_cb:   Function
                        A progress callback to log progress during pre-publish.  Call:

                            progress_cb(percentage, msg)

                        to report progress to the UI

        :returns:       A list of any tasks that were found which have problems that
                        need to be reported in the UI.  Each item in the list should
                        be a dictionary containing the following keys:
                        {
                            task:   Dictionary
                                    This is the task that was passed into the hook and
                                    should not be modified
                                    {
                                        item:...
                                        output:...
                                    }

                            errors: List
                                    A list of error messages (strings) to report    
                        }
        """       
        results = []

        # validate tasks:
        for task in tasks:
            item = task["item"]
            output = task["output"]
            errors = []

            # report progress:
            progress_cb(0, "Validating", task)

             # pre-publish alembic_cache output
            if output["name"] == "alembic_cache":
                errors.extend(self._validate_item_for_alembic_cache_publish(item))
            else:
                # don't know how to publish this output types!
                errors.append("Don't know how to publish this item!")       

            # if there is anything to report then add to result
            if len(errors) > 0:
                # add result:
                results.append({"task":task, "errors":errors})

            progress_cb(100)

        return results

    def _validate_item_for_alembic_cache_publish(self, item):
        """
        Validate that the item is valid to be exported 
        to an alembic cache
        """
        errors = []
        # check that the group still exists:
        if not cmds.objExists(item["name"]):
            errors.append("This group couldn't be found in the scene!")

        # and that it still contains meshes:
        elif not cmds.ls(item["name"], dag=True, type="mesh"):
            errors.append("This group doesn't appear to contain any meshes!")

        # finally return any errors
        return errors

5단계 - 게시

게시 단계에서는 Alembic 캐시 파일을 각 항목의 게시 경로로 내보낸 다음 Shotgun에 등록합니다. 이 예에서 수행해야 할 마지막 단계입니다.

이 단계는 hook_secondary_publish 설정에 의해 앱 구성에서 정의된 후크를 통해서도 구현됩니다.

이전 지침에 따라 다시 기본 후크 <code_root>/install/apps/app_store/tk-multi-publish/<version>/hooks/secondary_publish_tk-maya.py를 구성 후크 디렉토리에 저장하고 이름을 alembic_example_secondary_publish.py로 변경합니다. 그런 다음 구성의 설정을 다음과 같이 편집합니다.

hook_secondary_publish: alembic_example_secondary_publish

이제 앱에서 게시 후크 버전을 사용하므로 계속 진행하여 엽니다.

게시 후크에는 태스크 목록과 함께 몇 가지 추가 입력이 제공됩니다.

def execute(self, tasks, work_template, comment, thumbnail_path, 
            sg_task, primary_publish_path, progress_cb, **kwargs):
    ...
  • comment, thumbnail_pathsg_task는 UI를 통해 사용자가 제공한 정보를 나타냅니다.
  • primary_publish_path는 기본 게시 경로이며 이 경우 씬 파일 자체입니다.

게시 전 후크와 마찬가지로 기본 구현은 태스크를 반복하기 위한 발판을 제공하므로 제일 먼저 할 일은 새 alembic_cache 출력을 처리할 수 있도록 몇 가지 코드를 추가하는 것입니다.

이렇게 하려면 아래 내용을

# publish item here, e.g.
#if output["name"] == "foo":
#    ...
#else:
# don't know how to publish this output types!
errors.append("Don't know how to publish this item!")

다음으로 바꿉니다.

# publish alembic_cache output
if output["name"] == "alembic_cache":
    try:
       self._publish_alembic_cache_for_item(item, output, work_template, primary_publish_path, 
                                            sg_task, comment, thumbnail_path, progress_cb)
    except Exception, e:
       errors.append("Publish failed - %s" % e)
else:
    # don't know how to publish this output types!
    errors.append("Don't know how to publish this item!")

다음으로 PublishHook 클래스에 새 게시 메서드를 추가합니다.

def _publish_alembic_cache_for_item(self, item, output, work_template, primary_publish_path, 
                                    sg_task, comment, thumbnail_path, progress_cb)
    ...

이 새 메서드의 수행 작업에 대해 살펴보겠습니다.

먼저 work_template을 사용하여 현재 씬 경로에서 필드 사전을 추출합니다.

    scene_path = os.path.abspath(cmds.file(query=True, sn=True))
    fields = work_template.get_fields(scene_path)
    publish_version = fields["version"]

다음으로 필드에 그룹 이름을 추가한 다음 Alembic 캐시 파일에 사용할 게시 경로를 빌드합니다.

    fields["grp_name"] = group_name
    publish_path = publish_template.apply_fields(fields)

그런 다음 이 경로를 사용하여 Alembic 캐시 내보내기 명령 AbcExport를 사용하여 그룹을 게시 경로로 내보냅니다.

    frame_start = int(cmds.playbackOptions(q=True, min=True))
    frame_end = int(cmds.playbackOptions(q=True, max=True))
    abc_publish_path = publish_path.replace("\\", "/")
    abc_export_cmd = ("AbcExport -j \"-fr %d %d -root %s -file %s\"" 
                        % (frame_start, frame_end, item["name"], abc_publish_path))
    try:
        self.parent.log_debug("Executing command: %s" % abc_export_cmd)
        mel.eval(abc_export_cmd)
    except Exception, e:
        raise TankError("Failed to export Alembic Cache: %s" % e)

마지막으로 게시된 Alembic 캐시 파일을 Shotgun에 등록합니다.

    self._register_publish(publish_path, ...

이제 완료되었습니다.

다음은 전체 alembic_example_secondary_publish.py입니다.

import os
import shutil
import maya.cmds as cmds
import maya.mel as mel

import tank
from tank import Hook
from tank import TankError

class PublishHook(Hook):
    """
    Single hook that implements publish functionality for secondary tasks
    """    
    def execute(self, tasks, work_template, comment, thumbnail_path, sg_task, primary_publish_path, progress_cb, **kwargs):
        """
        Main hook entry point
        :tasks:         List of secondary tasks to be published.  Each task is a 
                        dictionary containing the following keys:
                        {
                            item:   Dictionary
                                    This is the item returned by the scan hook 
                                    {   
                                        name:           String
                                        description:    String
                                        type:           String
                                        other_params:   Dictionary
                                    }

                            output: Dictionary
                                    This is the output as defined in the configuration - the 
                                    primary output will always be named 'primary' 
                                    {
                                        name:             String
                                        publish_template: template
                                        tank_type:        String
                                    }
                        }

        :work_template: template
                        This is the template defined in the config that
                        represents the current work file

        :comment:       String
                        The comment provided for the publish

        :thumbnail:     Path string
                        The default thumbnail provided for the publish

        :sg_task:       Dictionary (shotgun entity description)
                        The shotgun task to use for the publish    

        :primary_publish_path: Path string
                        This is the path of the primary published file as returned
                        by the primary publish hook

        :progress_cb:   Function
                        A progress callback to log progress during pre-publish.  Call:

                            progress_cb(percentage, msg)

                        to report progress to the UI

        :returns:       A list of any tasks that had problems that need to be reported 
                        in the UI.  Each item in the list should be a dictionary containing 
                        the following keys:
                        {
                            task:   Dictionary
                                    This is the task that was passed into the hook and
                                    should not be modified
                                    {
                                        item:...
                                        output:...
                                    }

                            errors: List
                                    A list of error messages (strings) to report    
                        }
        """
        results = []

        # publish all tasks:
        for task in tasks:
            item = task["item"]
            output = task["output"]
            errors = []

            # report progress:
            progress_cb(0, "Publishing", task)

            # publish alembic_cache output
            if output["name"] == "alembic_cache":
                try:
                    self._publish_alembic_cache_for_item(item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb)
                except Exception, e:
                    errors.append("Publish failed - %s" % e)
            else:
                # don't know how to publish this output types!
                errors.append("Don't know how to publish this item!")

            # if there is anything to report then add to result
            if len(errors) > 0:
                # add result:
                results.append({"task":task, "errors":errors})

            progress_cb(100)

        return results

    def _publish_alembic_cache_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb):
        """
        Export an Alembic cache for the specified item and publish it
        to Shotgun.
        """
        group_name = item["name"].strip("|")
        tank_type = output["tank_type"]
        publish_template = output["publish_template"]        

        # get the current scene path and extract fields from it
        # using the work template:
        scene_path = os.path.abspath(cmds.file(query=True, sn=True))
        fields = work_template.get_fields(scene_path)
        publish_version = fields["version"]

        # update fields with the group name:
        fields["grp_name"] = group_name

        # create the publish path by applying the fields 
        # with the publish template:
        publish_path = publish_template.apply_fields(fields)

        # build and execute the Alembic export command for this item:
        frame_start = int(cmds.playbackOptions(q=True, min=True))
        frame_end = int(cmds.playbackOptions(q=True, max=True))
        # The AbcExport command expects forward slashes!
        abc_publish_path = publish_path.replace("\\", "/")
        abc_export_cmd = "AbcExport -j \"-fr %d %d -root %s -file %s\"" % (frame_start, frame_end, item["name"], abc_publish_path)
        try:
            self.parent.log_debug("Executing command: %s" % abc_export_cmd)
            mel.eval(abc_export_cmd)
        except Exception, e:
            raise TankError("Failed to export Alembic Cache: %s" % e)

        # Finally, register this publish with Shotgun
        self._register_publish(publish_path, 
                               group_name, 
                               sg_task, 
                               publish_version, 
                               tank_type,
                               comment,
                               thumbnail_path, 
                               [primary_publish_path])

    def _register_publish(self, path, name, sg_task, publish_version, tank_type, comment, thumbnail_path, dependency_paths=None):
        """
        Helper method to register publish using the 
        specified publish info.
        """
        # construct args:
        args = {
            "tk": self.parent.tank,
            "context": self.parent.context,
            "comment": comment,
            "path": path,
            "name": name,
            "version_number": publish_version,
            "thumbnail_path": thumbnail_path,
            "task": sg_task,
            "dependency_paths": dependency_paths,
            "published_file_type":tank_type,
        }

        # register publish;
        sg_data = tank.util.register_publish(**args)

        return sg_data

다음은 Shot_Step 환경에서 전체 tk-multi-publish-alembic-example 구성입니다.

tk-multi-publish-alembic-example:
  allow_taskless_publishes: true
  display_name: Publish Alembic Example
  expand_single_items: false
  hook_copy_file: default
  hook_post_publish: default
  hook_primary_pre_publish: default
  hook_primary_publish: default
  hook_scan_scene: alembic_example_scan_scene
  hook_secondary_pre_publish: alembic_example_secondary_pre_publish
  hook_secondary_publish: alembic_example_secondary_publish
  hook_thumbnail: default
  location: {name: tk-multi-publish, type: app_store, version: v0.2.7}
  primary_description: Publish and version up the current work file
  primary_display_name: Current Work File
  primary_icon: ''
  primary_publish_template: maya_shot_publish
  primary_scene_item_type: work_file
  primary_tank_type: Maya Scene
  secondary_outputs:
  - description: 'Publish Alembic Cache data for the model'
    display_group: Caches
    display_name: Alembic Cache
    icon: 'icons/alembic_output.png'
    name: alembic_cache
    publish_template: maya_shot_mesh_alembic_cache
    required: false
    scene_item_type: mesh_group
    selected: false
    tank_type: 'Alembic Cache'
  template_work: maya_shot_work

이제 샷 씬에서 참조된 에셋에 대해 Alembic 캐시를 게시하기 위한 모든 설정이 완료되었습니다.

구성을 저장하고, Maya에서 앱을 다시 로드하고, 테스트 샷 씬을 열고, 메뉴에서 Publish Alembic Example 명령을 실행합니다.

커스텀 스캔 후크에 의해 발견된 Alembic 캐시 항목이 UI에서 선택되어 있는지 확인하고 코멘트를 추가한 후 Publish를 누릅니다. 앱은 먼저 새 게시 전 후크를 사용하여 참조가 유효한지 확인합니다. 모든 사항이 올바르면 Alembic 캐시를 내보내고 새 게시 후크를 사용하여 Shotgun의 게시 파일로 이 캐시를 등록합니다.

 

ae_success_shotgun.ko.png
 
팔로우

0 댓글

댓글을 남기려면 로그인하세요.