Skip to content

pre_celaction_setup

CelactionPrelaunchHook

Bases: PreLaunchHook

Bootstrap celacion with AYON

Source code in client/ayon_celaction/hooks/pre_celaction_setup.py
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
class CelactionPrelaunchHook(PreLaunchHook):
    """Bootstrap celacion with AYON"""
    app_groups = {"celaction"}
    platforms = {"windows"}
    launch_types = {LaunchTypes.local}

    def execute(self):
        folder_attributes = self.data["folder_entity"]["attrib"]
        width = folder_attributes["resolutionWidth"]
        height = folder_attributes["resolutionHeight"]

        # Add workfile path to launch arguments
        workfile_path = self.workfile_path()
        if workfile_path:
            self.launch_context.launch_args.append(workfile_path)

        # setting output parameters
        path_user_settings = "\\".join([
            "Software", "CelAction", "CelAction2D", "User Settings"
        ])
        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path_user_settings)
        hKey = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER, path_user_settings, 0,
            winreg.KEY_ALL_ACCESS
        )

        path_to_cli = os.path.join(
            CELACTION_ROOT_DIR, "scripts", "publish_cli.py"
        )
        subprocess_args = get_ayon_launcher_args("run", path_to_cli)
        executable = subprocess_args.pop(0)
        workfile_settings = self.get_workfile_settings()

        winreg.SetValueEx(
            hKey,
            "SubmitAppTitle",
            0,
            winreg.REG_SZ,
            executable
        )

        # add required arguments for workfile path
        parameters = subprocess_args + [
            "--currentFile", "*SCENE*"
        ]

        # Add custom parameters from workfile settings
        if "render_chunk" in workfile_settings["submission_overrides"]:
            parameters += [
                "--chunk", "*CHUNK*"
           ]
        if "resolution" in workfile_settings["submission_overrides"]:
            parameters += [
                "--resolutionWidth", "*X*",
                "--resolutionHeight", "*Y*"
            ]
        if "frame_range" in workfile_settings["submission_overrides"]:
            parameters += [
                "--frameStart", "*START*",
                "--frameEnd", "*END*"
            ]

        winreg.SetValueEx(
            hKey, "SubmitParametersTitle", 0, winreg.REG_SZ,
            subprocess.list2cmdline(parameters)
        )

        self.log.debug(f"__ parameters: \"{parameters}\"")

        # setting resolution parameters
        path_submit = "\\".join([
            path_user_settings, "Dialogs", "SubmitOutput"
        ])
        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path_submit)
        hKey = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER, path_submit, 0,
            winreg.KEY_ALL_ACCESS
        )
        winreg.SetValueEx(hKey, "SaveScene", 0, winreg.REG_DWORD, 1)
        winreg.SetValueEx(hKey, "CustomX", 0, winreg.REG_DWORD, width)
        winreg.SetValueEx(hKey, "CustomY", 0, winreg.REG_DWORD, height)

        # making sure message dialogs don't appear when overwriting
        path_overwrite_scene = "\\".join([
            path_user_settings, "Messages", "OverwriteScene"
        ])
        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path_overwrite_scene)
        hKey = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER, path_overwrite_scene, 0,
            winreg.KEY_ALL_ACCESS
        )
        winreg.SetValueEx(hKey, "Result", 0, winreg.REG_DWORD, 6)
        winreg.SetValueEx(hKey, "Valid", 0, winreg.REG_DWORD, 1)

        # set scane as not saved
        path_scene_saved = "\\".join([
            path_user_settings, "Messages", "SceneSaved"
        ])
        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path_scene_saved)
        hKey = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER, path_scene_saved, 0,
            winreg.KEY_ALL_ACCESS
        )
        winreg.SetValueEx(hKey, "Result", 0, winreg.REG_DWORD, 1)
        winreg.SetValueEx(hKey, "Valid", 0, winreg.REG_DWORD, 1)

    def workfile_path(self):
        workfile_path = self.data["last_workfile_path"]

        # copy workfile from template if doesn't exist any on path
        if not os.path.exists(workfile_path):
            # TODO add ability to set different template workfile path via
            # settings
            template_path = os.path.join(
                CELACTION_ROOT_DIR,
                "resources",
                "celaction_template_scene.scn"
            )

            if not os.path.exists(template_path):
                self.log.warning(
                    "Couldn't find workfile template file in {}".format(
                        template_path
                    )
                )
                return

            self.log.info(
                f"Creating workfile from template: \"{template_path}\""
            )

            # Copy template workfile to new destinantion
            shutil.copy2(
                os.path.normpath(template_path),
                os.path.normpath(workfile_path)
            )
            self._create_workfile_info(workfile_path)

        self.log.info(f"Workfile to open: \"{workfile_path}\"")

        return workfile_path

    def get_workfile_settings(self):
        return self.data["project_settings"]["celaction"]["workfile"]

    def _create_workfile_info(self, workfile_path: str) -> None:
        # Backwards compatibility before ayon-core 1.5.0
        if save_workfile_info is None or find_workfile_rootless_path is None:
            return

        # NOTE This won't store version or comment
        host_name = self.host_name
        anatomy = self.data["anatomy"]
        project_name = self.data["project_name"]
        project_settings = self.data["project_settings"]
        project_entity = self.data["project_entity"]
        folder_entity = self.data["folder_entity"]
        task_entity = self.data["task_entity"]
        rootless_path = find_workfile_rootless_path(
            workfile_path,
            project_name,
            folder_entity,
            task_entity,
            host_name,
            project_entity=project_entity,
            project_settings=project_settings,
            anatomy=anatomy,
        )
        save_workfile_info(
            project_name,
            task_entity["id"],
            rootless_path,
            host_name,
        )