maya_zen_tools.loft

loft_distribute_vertices_between_edges

loft_distribute_vertices_between_edges(
    *selected_edges: str,
    distribution_type: str = maya_zen_tools.options.DistributionType.UNIFORM,
    create_deformer: bool = False
) -> (
    tuple[str, ...] | tuple[tuple[str, ...], str, str, str]
)

Given a selection of edge loop segments, aligned parallel to one another on a polygon mesh, distribute the vertices sandwiched between along a loft.

Source code in src/maya_zen_tools/loft.py

def loft_distribute_vertices_between_edges(
    *selected_edges: str,
    distribution_type: str = options.DistributionType.UNIFORM,
    create_deformer: bool = False,
) -> tuple[str, ...] | tuple[tuple[str, ...], str, str, str]:
    """
    Given a selection of edge loop segments, aligned parallel to one
    another on a polygon mesh, distribute the vertices sandwiched between
    along a loft.
    """
    cleanup_items: list[str] = []
    selected_edges = selected_edges or tuple(iter_selected_components("e"))
    selected_edge_loops: tuple[tuple[str, ...], ...] = tuple(
        iter_aligned_contiguous_edges(*selected_edges)
    )
    cmds.waitCursor(state=True)
    index: int
    edge_loop: tuple[str, ...]
    curve_transforms: list[str] = []
    curve_shapes: list[str] = []
    loft: str = cmds.createNode("loft", name="loft#")
    for index, edge_loop in enumerate(selected_edge_loops):
        rebuild_curve: str = create_edges_rebuild_curve(edge_loop)
        if create_deformer:
            curve_transform: str = cmds.createNode(
                "transform", name="loftCurve#", skipSelect=True
            )
            curve_shape: str = cmds.createNode(
                "nurbsCurve",
                name="loftCurveShape#",
                parent=curve_transform,
                skipSelect=True,
            )
            cmds.connectAttr(
                f"{rebuild_curve}.outputCurve", f"{curve_shape}.create"
            )
            center_pivot(curve_transform)
            cmds.connectAttr(
                f"{curve_shape}.worldSpace[0]", f"{loft}.inputCurve[{index}]"
            )
            curve_transforms.append(curve_transform)
            curve_shapes.append(curve_shape)
        else:
            cmds.connectAttr(
                f"{rebuild_curve}.outputCurve", f"{loft}.inputCurve[{index}]"
            )
        cleanup_items.append(rebuild_curve)
    rebuild_surface: str = cmds.createNode(
        "rebuildSurface", name="loftBetweenEdgesRebuildSurface#"
    )
    cleanup_items.append(rebuild_surface)
    cmds.connectAttr(
        f"{loft}.outputSurface",
        f"{rebuild_surface}.inputSurface",
    )
    cmds.setAttr(f"{rebuild_surface}.spansU", len(selected_edge_loops) - 1)
    cmds.setAttr(f"{rebuild_surface}.spansV", len(selected_edge_loops[0]))
    cmds.setAttr(f"{rebuild_surface}.keepRange", 2)
    cmds.setAttr(f"{rebuild_surface}.endKnots", 1)
    cmds.setAttr(f"{rebuild_surface}.direction", 0)
    vertices: set[str] = _surface_distribute_vertices_between_edges(
        f"{rebuild_surface}.outputSurface",
        edge_loops=selected_edge_loops,
        distribution_type=distribution_type,
    )
    faces: tuple[str, ...] = tuple(
        cmds.ls(
            *cmds.polyListComponentConversion(
                *vertices, fromVertex=True, toFace=True, internal=True
            ),
            flatten=True,
        )
    )
    if create_deformer:
        surface_transform: str = cmds.createNode(
            "transform", name="loftBetweenEdges#"
        )
        surface_shape: str = cmds.createNode(
            "nurbsSurface",
            name=f"{surface_transform}Shape",
            parent=surface_transform,
        )
        cmds.connectAttr(
            f"{loft}.outputSurface",
            f"{surface_shape}.create",
        )
        cmds.connectAttr(
            f"{rebuild_surface}.outputSurface",
            f"{surface_shape}.create",
            force=True,
        )
        cmds.setAttr(f"{surface_shape}.intermediateObject", 1)
        cmds.parent(*curve_transforms, surface_transform)
        wrap: str = _create_wrap_deformer(
            f"{rebuild_surface}.outputSurface",
            f"{surface_shape}.local",
            vertices,
        )

        def cleanup() -> None:
            """
            Disconnect the curves from the mesh, and the rebuilt surface
            from the base, so that changes aren't negated by having a base
            transform in concert with the driver
            """
            cmds.delete(*curve_shapes, constructionHistory=True)
            cmds.disconnectAttr(
                f"{rebuild_surface}.outputSurface", f"{surface_shape}.create"
            )

        cmds.evalDeferred(cleanup)
        cmds.waitCursor(state=False)
        # Go into object selection mode, in order to manipulate locators
        cmds.selectMode(object=True)
        # Select the middle locator
        cmds.select(curve_transforms[ceil(len(curve_transforms) / 2) - 1])
        return (faces, surface_shape, surface_transform, wrap)
    cmds.delete(*cleanup_items)
    cmds.waitCursor(state=False)
    cmds.select(*faces)
    return faces

loft_distribute_uvs_between_edges_or_uvs

loft_distribute_uvs_between_edges_or_uvs(
    *selection: str,
    distribution_type: str = maya_zen_tools.options.DistributionType.UNIFORM
) -> tuple[str, ...]

Given a selection of edge loop segments or uv loop segments, aligned parallel to one another on a polygon mesh, distribute the UVs sandwiched between along a loft.

Source code in src/maya_zen_tools/loft.py

def loft_distribute_uvs_between_edges_or_uvs(
    *selection: str,
    distribution_type: str = options.DistributionType.UNIFORM,
) -> tuple[str, ...]:
    """
    Given a selection of edge loop segments or uv loop segments, aligned
    parallel to one another on a polygon mesh, distribute the UVs sandwiched
    between along a loft.
    """
    cleanup: list[str] = []
    selection = selection or tuple(iter_selected_components("e", "map"))
    selected_uvs: set[str] = set(
        iter_selected_components("map", selection=selection)
    )
    selected_edges: set[str] = set(
        iter_selected_components("e", selection=selection)
    )
    if selected_edges:
        selected_uvs |= set(
            cmds.ls(
                *cmds.polyListComponentConversion(
                    *selected_edges,
                    fromEdge=True,
                    toUV=True,
                ),
                flatten=True,
            )
        )
    selected_uv_loops: tuple[tuple[str, ...], ...] = tuple(
        iter_aligned_contiguous_uvs(*selected_uvs)
    )
    cmds.waitCursor(state=True)
    index: int
    uv_loop: tuple[str, ...]
    loft: str = cmds.createNode("loft", name="loftBetweenUVs#")
    for index, uv_loop in enumerate(selected_uv_loops):
        rebuild_curve: str
        curve_shape: str
        curve_transform: str
        rebuild_curve, curve_shape, curve_transform = create_uvs_rebuild_curve(
            uv_loop
        )
        cleanup.extend((rebuild_curve, curve_shape, curve_transform))
        cmds.connectAttr(
            f"{rebuild_curve}.outputCurve", f"{loft}.inputCurve[{index}]"
        )
    rebuild_surface: str = cmds.createNode(
        "rebuildSurface", name="loftBetweenEdgesRebuildSurface#"
    )
    cleanup.append(rebuild_surface)
    cmds.connectAttr(
        f"{loft}.outputSurface",
        f"{rebuild_surface}.inputSurface",
    )
    cmds.setAttr(f"{rebuild_surface}.spansU", len(selected_uv_loops) - 1)
    cmds.setAttr(f"{rebuild_surface}.spansV", len(selected_uv_loops[0]))
    cmds.setAttr(f"{rebuild_surface}.keepRange", 2)
    cmds.setAttr(f"{rebuild_surface}.endKnots", 1)
    cmds.setAttr(f"{rebuild_surface}.direction", 0)
    uvs: set[str] = _surface_distribute_uvs(
        f"{rebuild_surface}.outputSurface",
        uv_loops=selected_uv_loops,
        distribution_type=distribution_type,
    )
    faces: tuple[str, ...] = tuple(
        cmds.ls(
            *cmds.polyListComponentConversion(
                *uvs, fromUV=True, toFace=True, internal=True
            ),
            flatten=True,
        )
    )
    cmds.delete(*cleanup)
    cmds.waitCursor(state=False)
    cmds.select(*faces)
    return faces

show_loft_distribute_vertices_between_edges_options

show_loft_distribute_vertices_between_edges_options() -> (
    None
)

Show a window with options to use when executing loft_distribute_vertices_between_edges.

Source code in src/maya_zen_tools/loft.py

def show_loft_distribute_vertices_between_edges_options() -> None:
    """
    Show a window with options to use when executing
    `loft_distribute_vertices_between_edges`.
    """
    # Get saved options
    get_option: Callable[[str], str | int | float | None] = partial(
        options.get_tool_option, "loft_distribute_vertices_between_edges"
    )
    # Create the window
    if cmds.window(WINDOW, exists=True):
        cmds.deleteUI(WINDOW)
    cmds.window(
        WINDOW,
        width=240,
        height=100,
        title=(
            f"ZenTools: {LOFT_DISTRIBUTE_VERTICES_BETWEEN_EDGES_LABEL} Options"
        ),
    )
    column_layout: str = cmds.columnLayout(
        adjustableColumn=True, parent=WINDOW, columnAlign="left", margins=15
    )
    selected: int = 1
    with contextlib.suppress(ValueError):
        selected = ("UNIFORM", "PROPORTIONAL").index(
            get_option(  # type: ignore
                "distribution_type", options.DistributionType.UNIFORM
            )
        ) + 1
    cmds.radioButtonGrp(
        label="Distribution Type:",
        parent=column_layout,
        numberOfRadioButtons=2,
        label1="Uniform",
        label2="Proportional",
        columnAlign=(1, "left"),
        changeCommand1=(
            "from maya_zen_tools import options\n"
            "options.set_tool_option("
            "'loft_distribute_vertices_between_edges', 'distribution_type', "
            "'UNIFORM')"
        ),
        changeCommand2=(
            "from maya_zen_tools import options\n"
            "options.set_tool_option("
            "'loft_distribute_vertices_between_edges', 'distribution_type', "
            "'PROPORTIONAL')"
        ),
        select=selected,
        height=30,
    )
    cmds.separator(parent=column_layout)
    cmds.checkBox(
        label="Create Deformer",
        parent=column_layout,
        value=get_option("create_deformer", False),  # type: ignore
        onCommand=(
            "from maya_zen_tools import options\n"
            "options.set_tool_option("
            "'loft_distribute_vertices_between_edges', 'create_deformer', "
            "True)"
        ),
        offCommand=(
            "from maya_zen_tools import options\n"
            "options.set_tool_option("
            "'loft_distribute_vertices_between_edges', 'create_deformer', "
            "False)"
        ),
        height=30,
    )
    cmds.button(
        label="Distribute",
        parent=column_layout,
        command=(
            "from maya_zen_tools import loft\n"
            "from maya import cmds\n"
            "loft.do_loft_distribute_vertices_between_edges()\n"
            f"cmds.deleteUI('{WINDOW}')"
        ),
    )
    cmds.showWindow(WINDOW)

do_loft_distribute_vertices_between_edges

do_loft_distribute_vertices_between_edges() -> None

Execute loft_distribute_vertices_between_edges, getting arguments from the UI or saved options.

Source code in src/maya_zen_tools/loft.py

def do_loft_distribute_vertices_between_edges() -> None:
    """
    Execute `loft_distribute_vertices_between_edges`, getting arguments from
    the UI or saved options.
    """
    kwargs: dict[str, float | bool | str] = options.get_tool_options(
        "loft_distribute_vertices_between_edges"
    )
    loft_distribute_vertices_between_edges(**kwargs)  # type: ignore

show_loft_distribute_uvs_between_edges_or_uvs_options

show_loft_distribute_uvs_between_edges_or_uvs_options() -> (
    None
)

Show a window with options to use when executing loft_distribute_uvs_between_edges_or_uvs.

Source code in src/maya_zen_tools/loft.py

def show_loft_distribute_uvs_between_edges_or_uvs_options() -> None:
    """
    Show a window with options to use when executing
    `loft_distribute_uvs_between_edges_or_uvs`.
    """
    # Get saved options
    get_option: Callable[[str], str | int | float | None] = partial(
        options.get_tool_option, "loft_distribute_uvs_between_edges_or_uvs"
    )
    # Create the window
    if cmds.window(WINDOW, exists=True):
        cmds.deleteUI(WINDOW)
    cmds.window(
        WINDOW,
        width=240,
        height=100,
        title=(
            "ZenTools: "
            f"{LOFT_DISTRIBUTE_UVS_BETWEEN_EDGES_OR_UVS_LABEL} Options"
        ),
    )
    column_layout: str = cmds.columnLayout(
        adjustableColumn=True, parent=WINDOW, columnAlign="left", margins=15
    )
    selected: int = 1
    with contextlib.suppress(ValueError):
        selected = ("UNIFORM", "PROPORTIONAL").index(
            get_option(  # type: ignore
                "distribution_type", options.DistributionType.UNIFORM
            )
        ) + 1
    cmds.radioButtonGrp(
        label="Distribution Type:",
        parent=column_layout,
        numberOfRadioButtons=2,
        label1="Uniform",
        label2="Proportional",
        columnAlign=(1, "left"),
        changeCommand1=(
            "from maya_zen_tools import options\n"
            "options.set_tool_option("
            "'loft_distribute_uvs_between_edges_or_uvs', 'distribution_type', "
            "'UNIFORM')"
        ),
        changeCommand2=(
            "from maya_zen_tools import options\n"
            "options.set_tool_option("
            "'loft_distribute_uvs_between_edges_or_uvs', 'distribution_type', "
            "'PROPORTIONAL')"
        ),
        select=selected,
        height=30,
    )
    cmds.button(
        label="Distribute",
        parent=column_layout,
        command=(
            "from maya_zen_tools import loft\n"
            "from maya import cmds\n"
            "loft.do_loft_distribute_uvs_between_edges_or_uvs()\n"
            f"cmds.deleteUI('{WINDOW}')"
        ),
    )
    cmds.showWindow(WINDOW)

do_loft_distribute_uvs_between_edges_or_uvs

do_loft_distribute_uvs_between_edges_or_uvs() -> None

Retrieve options and execute loft_distribute_uvs_between_edges_or_uvs.

Source code in src/maya_zen_tools/loft.py

def do_loft_distribute_uvs_between_edges_or_uvs() -> None:
    """
    Retrieve options and execute `loft_distribute_uvs_between_edges_or_uvs`.
    """
    kwargs: dict[str, float | bool | str] = options.get_tool_options(
        "loft_distribute_uvs_between_edges_or_uvs"
    )
    loft_distribute_uvs_between_edges_or_uvs(**kwargs)  # type: ignore