1

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

1
2
3
4
5
6
7
8
9

::安装 MSVC
choco install visualstudio2019buildtools --yes
choco install vcredist140 --yes

::安装 gcc
choco install mingw --yes

::安装 clang
choco install llvm --yes

1
2

C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\Common7\Tools\VsDevCmd.bat
cl /Zi /std:c++20 /EHsc /Fe: main.exe main.cpp

1

g++ -g -std=c++20 main.exe main.cpp

1

clang -g -std=c++20 main.exe main.cpp

1

"cpp": "cd $dir && g++ -g -std=c++20 *.cpp -o $fileNameWithoutExt && $dir$fileNameWithoutExt",

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

import pyeml.core as pm
from maya import OpenMaya
PAINT_CTX = "artAttrColorPerVertexContext"
color_set_representation = {
    "R": "RGB",
    "G": "RGB",
    "B": "RGB",
    "A": "A",
}
def get_color_sets(node):
    color_sets = pm.polyColorSet(node, q=1, allColorSets=1)
    return color_sets or pm.polyColorSet(node, create=1)

def filter_color(color, index, source_color=None):
    if index > 3:
        return color
    is_color = isinstance(source_color, OpenMaya.MColor)
    color_list = list(source_color) if is_color else [0, 0, 0, 1]
    color_list[index] = color[index]
    return OpenMaya.MColor(*color_list)

# NOTES(timmyliang): 获取当前正在绘制的节点
for node in set(pm.artAttrPaintVertexCtx(PAINT_CTX, q=1, pna=1).split()):
    node = pm.PyNode(node)
    node.displayColors.set(1)
    color_sets = get_color_sets(node)
    main_color_set = color_sets[0]

    mesh = node.__apimfn__()
    
    # NOTES(timmyliang): 获取主 color set 顶点色
    color_array = OpenMaya.MColorArray()
    mesh.getVertexColors(color_array, main_color_set)

    # NOTES(timmyliang): 获取顶点序号数组
    vtx_array = OpenMaya.MIntArray()
    for array_index in range(color_array.length()):
        vtx_array.append(array_index)

    final_colors = OpenMaya.MColorArray()
    for channel_index, color_channel in enumerate(cls.CHANNELS):
        # NOTES(timmyliang): 如果通道 color set 不存在则创建
        color_set = "VertexColor{0}".format(color_channel)
        if color_set not in color_sets:
            rpt = color_set_representation.get(color_channel)
            pm.polyColorSet(node, create=1, rpt=rpt, colorSet=color_set)

        mesh.setCurrentColorSetName(color_set)
        final_colors.clear()
        for array_index in range(color_array.length()):
            full_color = color_array[array_index]
            color = filter_color(full_color, index=channel_index)
            final_colors.append(color)
        # NOTES(timmyliang): 批量设置顶点色
        mesh.setVertexColors(final_colors, vtx_array)
    mesh.setCurrentColorSetName(main_color_set)

1
2
3
4
5
6
7
8
9
10

# NOTES(timmyliang): 获取 UI 的颜色和透明值
rgb = pm.colorSliderGrp("colorPerVertexColor", q=1, rgb=1)
alpha = pm.floatSliderGrp("colorPerVertexAlpha", q=1, value=1)
rgb.append(alpha)
# NOTES(timmyliang): 组装颜色，过滤掉相应的通道。
# 获取 ui 的选项
sel = pm.radioButtonGrp(SINGLE_CONTROL, q=1, sl=1)
# 过滤颜色
color = filter_color(rgb, index=sel)
pm.artAttrPaintVertexCtx(PAINT_CTX, e=1, cl4=tuple(color))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

def apply_color_channel(cls):
    index = pm.radioButtonGrp(cls.SINGLE_CONTROL, q=1, sl=1)
    mode = cls.OPTION_ITEMS[index + 1]
    is_rgb = mode == "RGB"
    for node in cls.get_paint_nodes():
        dag_path = node.__apimdagpath__()
        mesh = OpenMaya.MFnMesh(dag_path)
        color_sets = cls.get_color_sets(node)
        main_color_set = color_sets[0]

        current_color_set = mesh.currentColorSetName()

        main_colors = OpenMaya.MColorArray()
        mesh.getVertexColors(main_colors, main_color_set)
        vtx_array = cls.vertex_color_data[node.fullPathName()]
        final_colors = OpenMaya.MColorArray()

        # NOTES(timmyliang): 如果当前绘制为非单通道
        if is_rgb:
            # NOTES(timmyliang): 将当前的主颜色 拆分到各个通道上
            for channel_index, color_channel in enumerate(cls.CHANNELS):
                final_colors.clear()
                color_set = "VertexColor{0}".format(color_channel)
                mesh.setCurrentColorSetName(color_set)
                for vtx_index in vtx_array:
                    main_color = main_colors[vtx_index]
                    color = cls.filter_color(main_color, channel_index)
                    final_colors.append(color)
                mesh.setVertexColors(final_colors, vtx_array)
        else:
            mode_index = cls.OPTION_ITEMS.index(mode) - 2
            channel_colors = OpenMaya.MColorArray()
            fix_colors = OpenMaya.MColorArray()
            color_set = "VertexColor{0}".format(mode)
            mesh.getVertexColors(channel_colors, color_set)
            # NOTES(timmyliang): 获取单通道的颜色 回馈到主颜色上
            for vtx_index in vtx_array:
                channel_color = channel_colors[vtx_index]
                main_color = main_colors[vtx_index]
                color = cls.filter_color(channel_color, mode_index, main_color)
                final_colors.append(color)
                fix_color = cls.filter_color(channel_color, mode_index)
                fix_colors.append(fix_color)

            mesh.setVertexColors(fix_colors, vtx_array)
            mesh.setCurrentColorSetName(main_color_set)
            mesh.setVertexColors(final_colors, vtx_array)

        mesh.setCurrentColorSetName(current_color_set)

1
2

from maya import cmds
cmds.radioButtonGrp('artAttrColorChannelChoices',e=1,gbc=[255,0,0])

1
2
3
4
5
6
7
8
9
10

from maya import cmds
parent = cmds.radioButtonGrp('artAttrColorChannelChoices',q=1,parent=1)
print(parent)
# ToolSettings|MainToolSettingsLayout|tabLayout1|artAttrColorPerVertex|artCommonOperationFrame|columnLayout1061|columnLayout1065
window = cmds.window()
column_layout = cmds.columnLayout()
for control in cmds.layout(parent,q=1,childArray=1):
    cmds.control(control, e=1, p=column_layout)
    
cmds.showWindow(window)

1
2
3
4
5
6
7
8
9
10
11

from maya import cmds
window = cmds.window()
cmds.setUITemplate("OptionsTemplate", pushTemplate=1)

column_layout = cmds.columnLayout()
parent = cmds.radioButtonGrp('artAttrColorChannelChoices',q=1,parent=1)
for control in cmds.layout(parent,q=1,childArray=1):
    cmds.control(control, e=1, p=column_layout)
    
cmds.setUITemplate(popTemplate=1)
cmds.showWindow(window)

1
2
3
4
5
6
7
8
9
10
11
12
13

from maya import cmds
window = cmds.window()
cmds.setUITemplate("OptionsTemplate", pushTemplate=1)

column_layout = cmds.columnLayout()
parent = cmds.radioButtonGrp('artAttrColorChannelChoices',q=1,parent=1)
for control in cmds.layout(parent,q=1,childArray=1):
    cmds.control(control, e=1, p=column_layout)
    if control == "artAttrColorChannelChoices":
        cmds.button(label="click me")
    
cmds.setUITemplate(popTemplate=1)
cmds.showWindow(window)

1
2
3
4
5
6
7
8
9
10
11
12

from maya import cmds
parent = cmds.radioButtonGrp('artAttrColorChannelChoices',q=1,parent=1)
cmds.setParent(parent)
cmds.setUITemplate("OptionsTemplate", pushTemplate=1)
column_layout = cmds.columnLayout()

for control in cmds.layout(parent,q=1,childArray=1):
    cmds.control(control, e=1, p=column_layout)
    if control == "artAttrColorChannelChoices":
        cmds.button(label="click me")
    
cmds.setUITemplate(popTemplate=1)

1
2
3
4
5
6
7
8
9
10

import pymel.core as pm
from Qt import QtWidgets
widget = pm.uitypes.toQtObject("artAttrColorChannelChoices")
parent = widget.parent()
print(parent.objectName())
# columnLayout1065 objectName 和 mel 的 controlName 是一样的
layout = parent.layout()
print(layout)
# <PySide2.QtWidgets.QLayout object at 0x0000014DB0917648>
layout.addWidget(QtWidgets.QPushButton("asd"))

1
2
3
4
5
6
7
8
9
10

import pymel.core as pm
from Qt import QtWidgets
widget = pm.uitypes.toQtObject("artAttrColorChannelChoices")
parent = widget.parent()
layout = parent.layout()
index = layout.indexOf(widget)
widget_list = [layout.takeAt(0).widget() for _ in range(layout.count())]
widget_list.insert(index,QtWidgets.QPushButton("click me"))
for widget in widget_list:
    layout.addWidget(widget)

1
2
3

import maya.cmds as cmds
ctx = cmds.marqueeToolContext()
cmds.setToolTo(ctx)

1
2
3

import maya.cmds as cmds
ctx = cmds.helixToolContext()
cmds.setToolTo(ctx)

1
2
3
4
5
6

from pymel.tools import mel2py
path = r"C:\Program Files\Autodesk\Maya2018\scripts\others\customtoolPaint.mel"
with open(path,'r') as rf:
    content = rf.read()
py_str = mel2py.mel2pyStr(content, pymelNamespace="pm")
print(py_str)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

import pymel.core as pm
from pymel.tools import py2mel

def helixProperties():
    pm.setUITemplate("DefaultTemplate", pushTemplate=1)
    parent = str(pm.toolPropertyWindow(q=1, location=1))
    pm.setParent(parent)
    pm.columnLayout("helix")
    pm.tabLayout("helixTabs", childResizable=True)
    pm.columnLayout("helixTab")
    pm.frameLayout("helixFrame", cll=True, l="Helix Options", cl=False)
    pm.columnLayout("helixOptions")
    pm.separator(style="none")
    pm.intSliderGrp(
        "numCVs", field=1, minValue=20, maxValue=100, value=1, label="Number of CVs"
    )
    pm.checkBoxGrp("upsideDownGrp", numberOfCheckBoxes=1, l1=" ", label="Upside Down")
    pm.setParent("..")
    # helixOptions
    pm.setParent("..")
    # helixFrame
    pm.setParent("..")
    # helixTab
    pm.setParent("..")
    # helixTabs
    pm.setParent("..")
    # helix
    # Name the tabs; -tl does not allow tab labelling upon creation
    pm.tabLayout("helixTabs", tl=("helixTab", "Tool Defaults"), e=1)
    pm.setUITemplate(popTemplate=1)
    helixSetCallbacks(parent)

def helixSetCallbacks(parent):
    pm.setParent(parent)
    pm.checkBoxGrp(
        "upsideDownGrp",
        e=1,
        on1=lambda *args: pm.helixToolContext(pm.currentCtx(), upsideDown=True, e=1),
        of1=lambda *args: pm.helixToolContext(pm.currentCtx(), upsideDown=False, e=1),
    )
    pm.intSliderGrp(
        "numCVs",
        e=1,
        cc=lambda *args: pm.helixToolContext(pm.currentCtx(), numCVs=args[0], e=1),
    )

def helixValues(toolName):
    parent=(str(pm.toolPropertyWindow(q=1, location=1)) + "|helix|helixTabs|helixTab")
    pm.setParent(parent)
    icon="helixTool.xpm"
    help=""
    pm.mel.toolPropertySetCommon(toolName, icon, help)
    pm.frameLayout('helixFrame', en=True, e=1, cl=False)
    helixOptionValues(toolName)
    pm.mel.toolPropertySelect('helix')

def helixOptionValues(toolName):
    
    cv_num = 0
    cv_num=int(pm.mel.eval("helixToolContext -q -numCVs " + toolName))
    pm.intSliderGrp('numCVs', e=1, value=cv_num)
    cv_num=int(pm.mel.eval("helixToolContext -q -upsideDown " + toolName))
    if cv_num:
        pm.checkBoxGrp('upsideDownGrp', e=1, value1=1)
    else:
        pm.checkBoxGrp('upsideDownGrp', e=1, value1=0)

py2mel.py2melProc(helixProperties, procName="helixProperties")
py2mel.py2melProc(helixValues, procName="helixValues")

1
2
3

import maya.cmds as cmds
ctx = cmds.grabUVContext()
cmds.setToolTo(ctx)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

MStatus curveBrushContext::doPtrMoved(MEvent &event, MHWRender::MUIDrawManager &drawMgr, const MHWRender::MFrameContext &context)
{
    short x, y;
    event.getPosition(x, y);
    mBrushCenterScreenPoint = MPoint(x, y);
    auto radius = mBrushConfig.size();

    drawMgr.beginDrawable();
    if (bFalloffMode)
    {
        for (unsigned int index = 0; index < objDagPathArray.length(); ++index)
        {
            MPointArray pointArray;
            MColorArray colorArray;
            MFnNurbsCurve curveFn(objDagPathArray[index]);
            unsigned int segmentCount = 100;
            for (unsigned int pointIndex = 0; pointIndex < segmentCount; ++pointIndex)
            {
                MPoint point;
                auto param = curveFn.findParamFromLength(curveFn.length() * pointIndex / segmentCount);
                curveFn.getPointAtParam(param, point, MSpace::kWorld);
                pointArray.append(point);

                // NOTE(timmyliang): draw falloff
                short x_pos, y_pos;
                view.worldToView(point, x_pos, y_pos);
                MPoint screenPoint(x_pos, y_pos);
                auto distance = (mBrushCenterScreenPoint - screenPoint).length();
                auto field = 1 - distance / radius;
                // NOTE(timmyliang): transparent
                colorArray.append(distance > radius ? MColor(0.f) : MColor(field, field, field));
            }

            drawMgr.setLineWidth(12.0f);
            drawMgr.mesh(MHWRender::MUIDrawManager::kLineStrip, pointArray, NULL, &colorArray);
        }
    }

    drawMgr.setColor(MColor(1.f, 1.f, 1.f));
    drawMgr.setLineWidth(2.0f);
    drawMgr.circle2d(mBrushCenterScreenPoint, radius);

    drawMgr.endDrawable();
    return MS::kSuccess;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

MStatus curveBrushContext::doPress(MEvent &event, MHWRender::MUIDrawManager &drawMgr, const MHWRender::MFrameContext &context)
{
    view = M3dView::active3dView();
    event.getPosition(startPosX, startPosY);
    fStartBrushSize = mBrushConfig.size();
    fStartBrushStrength = mBrushConfig.strength();

    return MS::kSuccess;
}

MStatus curveBrushContext::doDrag(MEvent &event, MHWRender::MUIDrawManager &drawMgr, const MHWRender::MFrameContext &context)
{
    view.refresh(false, true);
    short currentPosX, currentPosY;
    event.getPosition(currentPosX, currentPosY);
    auto currentPos = MPoint(currentPosX, currentPosY);

    MPoint start(startPosX, startPosY);
    MVector delta = MVector(currentPos - start);

    drawMgr.beginDrawable();
    drawMgr.setColor(MColor(1.f, 1.f, 1.f));
    drawMgr.setLineWidth(2.0f);
    // NOTE(timmyliang): hold down `B` key
    if (eDragMode == kBrushSize)
    {
        float deltaValue;
        char info[64];
        // NOTES(timmyliang): left mouse for size
        if (event.mouseButton() == MEvent::kLeftMouse)
        {
            deltaValue = delta.x > 0 ? delta.length() : -delta.length();
            mBrushConfig.setSize(fStartBrushSize + deltaValue);
            sprintf(info, "Brush Size: %.2f", mBrushConfig.size());
            drawMgr.text2d(currentPos, info);
        }
        // NOTES(timmyliang): middle mouse for strength
        else if (event.mouseButton() == MEvent::kMiddleMouse)
        {
            deltaValue = delta.y > 0 ? delta.length() : -delta.length();
            mBrushConfig.setStrength(fStartBrushStrength + deltaValue);
            sprintf(info, "Brush Strength: %.2f", mBrushConfig.strength());
            drawMgr.text2d(currentPos, info);
        }
        drawMgr.line2d(start, MPoint(startPosX, startPosY + mBrushConfig.strength() * 2));
    }
    else
    {
        MPoint startNearPos, startFarPos, currNearPos, currFarPos;
        view.viewToWorld(currentPosX, currentPosY, currNearPos, currFarPos);
        view.viewToWorld(startPosX, startPosY, startFarPos, startFarPos);
        // NOTE(timmyliang): use tool command for undo
        curveBrushTool *cmd = (curveBrushTool *)newToolCommand();
        cmd->setStrength(mBrushConfig.strength());
        cmd->setRadius(mBrushConfig.size());
        cmd->setMoveVector((currFarPos - startFarPos).normal());
        cmd->setStartPoint(start);
        cmd->setDagPathArray(objDagPathArray);
        cmd->redoIt();
        cmd->finalize();
    }

    drawMgr.circle2d(start, mBrushConfig.size());
    drawMgr.endDrawable();
    return MS::kSuccess;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

MStatus curveBrushTool::redoIt()
{

    MVector offsetVector = moveVector * 0.002 * strength;
    M3dView view = M3dView::active3dView();

    // NOTE(timmyliang): move curves cv in radius
    short x_pos, y_pos;
    for (unsigned int index = 0; index < dagPathArray.length(); ++index)
    {
        MFnNurbsCurve curveFn(dagPathArray[index]);
        std::map<int, MVector> offsetMap;
        for (MItCurveCV cvIter(dagPathArray[index]); !cvIter.isDone(); cvIter.next())
        {
            MPoint pos = cvIter.position(MSpace::kWorld);
            int cvIndex = cvIter.index();
            curvePointMap[index][cvIndex] = pos;
            view.worldToView(pos, x_pos, y_pos);
            if ((startPoint - MPoint(x_pos, y_pos)).length() < radius)
            {
                offsetMap[cvIndex] = pos + offsetVector;
            }
        }
        for (const auto &it : offsetMap)
        {
            curveFn.setCV(it.first, it.second, MSpace::kWorld);
        }
        curveFn.updateCurve();
    }
    return MStatus::kSuccess;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

MStatus curveBrushTool::undoIt()
{
    // NOTE(timmyliang): reset point position
    for (const auto &kv : curvePointMap)
    {
        MFnNurbsCurve curveFn(dagPathArray[kv.first]);
        for (const auto &it : kv.second)
        {
            int cvIndex = it.first;
            MPoint pos = it.second;
            curveFn.setCV(cvIndex, pos, MSpace::kWorld);
        }
    }

    return MStatus::kSuccess;
}

1
2
3
4
5

from maya import OpenMayaRender
OpenMayaRender.MUIDrawManager 
# Error: AttributeError: file <maya console> line 2: 'module' object has no attribute 'MUIDrawManager' # 
from maya.api import OpenMayaRender
OpenMayaRender.MUIDrawManager

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def initializePlugin(plugin):
    pluginFn = om.MFnPlugin(plugin)
    try:
        pluginFn.registerContextCommand(CONTEXT_NAME, CurveBrushContextCmd.creator)
        # TODO(timmyliang): not support MPxToolCommand registered
        # pluginFn.registerContextCommand(
        #     CONTEXT_NAME,
        #     CurveBrushContextCmd.creator,
        #     CONTEXT_TOOL_NAME,
        #     CurveBrushTool.creator,
        #     CurveBrushTool.newSyntax,
        # )
    except:
        sys.stderr.write("Failed to register command: %s\n" % CONTEXT_NAME)
        raise

1

# Error: TypeError: file F:/repo/CMakeMaya/modules/Maya-CurveBrush/plug-ins/om2_curve_brush.py line 448: function takes exactly 2 arguments (5 given) # 

1
2
3
4
5
6
7
8
9
10

class CurveBrushTool(omui.MPxToolCommand):
    def finalize(self):
        command = om.MArgList()
        command.addArg(self.commandString)
        for flag, config in self.flags_data.items():
            long_flag = config.get("long")
            command.addArg(flag)
            command.addArg(getattr(self, long_flag[1:]))
        # TODO(timmyliang): not accept the command argument
        # return self.doFinalize(command)

1
2
3
4
5
6
7
8
9
10
11
12

class CanvasOverlay(QtWidgets.QWidget):
    def __init__(self, context):
        # type: (CurveBrushContext) -> None
        super(CanvasOverlay, self).__init__()
        self.setWindowFlags(
            QtCore.Qt.FramelessWindowHint
            | QtCore.Qt.SplashScreen
            | QtCore.Qt.WindowStaysOnTopHint
            | QtCore.Qt.WindowTransparentForInput
        )
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
        self.setAttribute(QtCore.Qt.WA_NoSystemBackground)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class AppFilter(QtCore.QObject):
    def __init__(self, canvas):
        # type: (CurveBrushContext) -> None
        super(AppFilter, self).__init__()
        self.canvas = canvas

    def eventFilter(self, receiver, event):
        if event.type() == QtCore.QEvent.MouseButtonPress:
            widget = QtWidgets.QApplication.widgetAt(QtGui.QCursor.pos())
            panel = isinstance(widget, QtCore.QObject) and widget.parent()
            name = panel and panel.objectName()
            if name:
                is_model_editor = cmds.objectTypeUI(name, i="modelEditor")
                self.canvas.setVisible(is_model_editor)
                if is_model_editor:
                    QtCore.QTimer.singleShot(0, self.canvas.setup_active_viewport)
        return super(AppFilter, self).eventFilter(receiver, event)

class CurveBrushContext(OpenMayaMPx.MPxContext):
    # 省略 ...
    def toolOnSetup(self):
        self.canvas = CanvasOverlay(self)
        # NOTES(timmyliang): 获取 QApplication 进行监听
        app = QtWidgets.QApplication.instance()
        app_filter = AppFilter(self.canvas)
        app.installEventFilter(app_filter)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import shiboken2
import maya.OpenMaya as om
import maya.OpenMayaUI as omui

from PySide2.QtWidgets import QWidget
from PySide2.QtCore import QObject

def active_view():
    """ return the active 3d view """
    return omui.M3dView.active3dView()

def active_view_wdg():
    """ return the active 3d view wrapped in a QWidget """
    view = active_view()
    active_view_widget = shiboken2.wrapInstance(long(view.widget()), QWidget)
    return active_view_widget

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class MouseFilter(QtCore.QObject):
    wheel = QtCore.Signal(QtCore.QEvent)
    moved = QtCore.Signal(QtCore.QEvent)
    clicked = QtCore.Signal(QtCore.QEvent)
    dragged = QtCore.Signal(QtCore.QEvent)
    released = QtCore.Signal(QtCore.QEvent)
    entered = QtCore.Signal()
    leaved = QtCore.Signal()

    def __init__(self, *args, **kwargs):
        super(MouseFilter, self).__init__(*args, **kwargs)
        self.is_clicked = False

    def eventFilter(self, receiver, event):
        event_type = event.type()
        if event_type == QtCore.QEvent.MouseMove:
            self.moved.emit(event)
            if self.is_clicked:
                self.dragged.emit(event)
        elif (
            event_type == QtCore.QEvent.MouseButtonPress
            or event_type == QtCore.QEvent.MouseButtonDblClick
        ):
            self.is_clicked = True
            self.clicked.emit(event)
        elif event_type == QtCore.QEvent.MouseButtonRelease:
            self.is_clicked = False
            self.released.emit(event)
        elif event_type == QtCore.QEvent.Enter:
            self.entered.emit()
        elif event_type == QtCore.QEvent.Leave:
            self.leaved.emit()
        elif event_type == QtCore.QEvent.Wheel:
            self.wheel.emit(event)

        return super(MouseFilter, self).eventFilter(receiver, event)

viewport = active_view_wdg()
mouse_filter = MouseFilter()
viewport.installEventFilter(mouse_filter)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

def paintEvent(self, event):
    self.draw_shape(self.create_brush_cricle(), QtCore.Qt.white, 2)
    if self.is_press_B:
        self.draw_shape(self.create_brush_line(), QtCore.Qt.white, 2)
    self.draw_text(self._message_info)
    for curve, data in self.color_data.items():
        self.draw_shape(data.get("points"), data.get("colors"), 10)

    return super(CanvasOverlay, self).paintEvent(event)

def create_brush_cricle(self, count=60):
    shape = []
    radius = self.radius
    pt = self.start_pos if self.is_press_B else self.current_pos
    for index in range(count + 1):
        theta = math.radians(360 * index / count)
        pos_x = pt.x() + radius * math.cos(theta)
        pos_y = pt.y() + radius * math.sin(theta)
        shape.append(QtCore.QPointF(pos_x, pos_y))
    return shape

def create_brush_line(self):
    shape = []
    start_pt = self.start_pos if self.is_press_B else self.current_pos
    shape.append(start_pt)
    shape.append(QtCore.QPoint(start_pt.x(), start_pt.y() - self.strength))
    return shape

def draw_shape(self, line_shapes, colors, width=1):
    if len(line_shapes) < 2:
        return
    colors = colors or QtCore.Qt.white
    painter = QtGui.QPainter(self)

    painter.setRenderHint(painter.Antialiasing)
    painter.begin(self)

    if (
        isinstance(colors, Iterable)
        and not isinstance(colors, six.string_types)
        and len(colors) == len(line_shapes)
    ):
        # NOTES(timmyliang): paint falloff
        for index, point in enumerate(line_shapes[:-1]):
            start_point = point
            end_point = line_shapes[index + 1]
            grandient_color = QtGui.QLinearGradient(start_point, end_point)
            start_color = colors[index]
            end_color = colors[index + 1]
            grandient_color.setColorAt(0, start_color)
            grandient_color.setColorAt(1, end_color)
            pen = QtGui.QPen(grandient_color, width)
            pen.setCapStyle(QtCore.Qt.RoundCap)
            pen.setJoinStyle(QtCore.Qt.RoundJoin)
            painter.setPen(pen)
            painter.drawLine(start_point, end_point)
    else:
        path = QtGui.QPainterPath()
        path.moveTo(line_shapes[0])
        [path.lineTo(point) for point in line_shapes]
        color = QtGui.QColor(colors)
        pen = QtGui.QPen(color, width)
        painter.setPen(pen)
        painter.drawPath(path)

    painter.end()

def draw_text(self, text, pos=None, color=QtCore.Qt.white, width=1):
    if not text:
        return
    painter = QtGui.QPainter(self)
    pen = QtGui.QPen(color, width)
    painter.setPen(pen)
    pos = pos or self.current_pos + QtCore.QPoint(10, 0)
    painter.drawText(pos, text)
    painter.end()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def world_to_view(position, invertY=True):
    """
    convert the given 3d position to  2d viewport coordinates
    """
    view = OpenMayaUI.M3dView.active3dView()
    arg_x = OpenMaya.MScriptUtil(0)
    arg_y = OpenMaya.MScriptUtil(0)

    arg_x_ptr = arg_x.asShortPtr()
    arg_y_ptr = arg_y.asShortPtr()
    view.worldToView(position, arg_x_ptr, arg_y_ptr)
    x_pos = arg_x.getShort(arg_x_ptr)
    y_pos = arg_y.getShort(arg_y_ptr)

    if invertY:
        y_pos = view.portHeight() - y_pos

    return (x_pos, y_pos)

1

mayapy -m lib2to3 -w F:\repo\Maya-CurveBrush\scripts\ysv\ysvView.py

1
2

from pymel.core import *
modelEditor(getPanel(wf=1), e=1, nurbsCurves=1)

1
2
3
4
5

from pymel.core import *
for mp in getPanel(type="modelPanel"):
    if modelEditor(mp, q=1, av=1):
        modelEditor(mp, e=1, nurbsCurves=1)
        break

1
2
3
4
5
6
7

for crv in self.inViewCurves:
    for cv in [crv.cv[0], crv.cv[-1]]:
        cv = str(cv) # fix add here
        setAttr(cv + ".xv", lock=1)
        setAttr(cv + ".yv", lock=1)
        setAttr(cv + ".zv", lock=1)
        

1
2
3
4
5
6
7

FAssetEditorToolkit
  GetToolkitFName
  GetBaseToolkitName
  GetWorldCentricTabPrefix
  GetWorldCentricTabColorScale
  Initialize
  RegisterTabSpawners

1
2
3
4
5
6
7
8
9
10
11

FYaksueTestAssetTypeActions::FYaksueTestAssetTypeActions()
{
// NOTE: 注册新的分类
IAssetTools &AssetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get();
    AssetCategory = AssetTools.RegisterAdvancedAssetCategory(FName(TEXT("Custom Assets")), LOCTEXT("CustomAssetCategory", "Custom Assets"));
}

uint32 FYaksueTestAssetTypeActions::GetCategories()
{
return AssetCategory;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

// Put your tab content here!
SNew(SOverlay)
+ SOverlay::Slot()//底层
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot().FillWidth(0.3f)//占30%
[
SNew(SButton)1
]
+ SHorizontalBox::Slot().FillWidth(0.7f)//占70%
[
SNew(SVerticalBox)
+ SVerticalBox::Slot().FillHeight(0.5f)//占50%
[
SNew(SButton)
]
+ SVerticalBox::Slot().FillHeight(0.5f)//占50%
[
SNew(SButton)
]
]
]
+ SOverlay::Slot()//顶层
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot().FillWidth(1.0f)//占满剩余空间
+ SHorizontalBox::Slot().AutoWidth()
[
SNew(SVerticalBox)
+ SVerticalBox::Slot().FillHeight(1.0f)//占满剩余空间
+ SVerticalBox::Slot().AutoHeight()
[
SNew(SBox)
.HeightOverride(128)
.WidthOverride(128)
[
SNew(SButton)
]
]
+ SVerticalBox::Slot().FillHeight(1.0f)//占满剩余空间
]
+ SHorizontalBox::Slot().FillWidth(1.0f)//占满剩余空间
]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

void FTestLayoutWindowModule::StartupModule()
{
// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module

FTestLayoutWindowStyle::Initialize();
FTestLayoutWindowStyle::ReloadTextures();

FTestLayoutWindowCommands::Register();

PluginCommands = MakeShareable(new FUICommandList);

PluginCommands->MapAction(
FTestLayoutWindowCommands::Get().OpenLayoutWindow,
FExecuteAction::CreateRaw(this, &FTestLayoutWindowModule::PluginButtonClicked),
FCanExecuteAction());

FLevelEditorModule& LevelEditorModule = FModuleManager::LoadModuleChecked<FLevelEditorModule>("LevelEditor");

{
TSharedPtr<FExtender> MenuExtender = MakeShareable(new FExtender());
MenuExtender->AddMenuExtension("WindowLayout", EExtensionHook::After, PluginCommands, FMenuExtensionDelegate::CreateRaw(this, &FTestLayoutWindowModule::AddMenuExtension));

LevelEditorModule.GetMenuExtensibilityManager()->AddExtender(MenuExtender);
}

{
TSharedPtr<FExtender> ToolbarExtender = MakeShareable(new FExtender);
ToolbarExtender->AddToolBarExtension("Settings", EExtensionHook::After, PluginCommands, FToolBarExtensionDelegate::CreateRaw(this, &FTestLayoutWindowModule::AddToolbarExtension));

LevelEditorModule.GetToolBarExtensibilityManager()->AddExtender(ToolbarExtender);
}

FGlobalTabmanager::Get()->RegisterNomadTabSpawner(TestLayoutWindowTabName, FOnSpawnTab::CreateRaw(this, &FTestLayoutWindowModule::OnSpawnPluginTab))
.SetDisplayName(LOCTEXT("FTestLayoutWindowTabTitle", "TestLayoutWindow"))
.SetMenuType(ETabSpawnerMenuType::Hidden);

// ! InnerTab的内容：
FGlobalTabmanager::Get()->RegisterNomadTabSpawner(InnerTabName, FOnSpawnTab::CreateLambda([](const FSpawnTabArgs& SpawnTabArgs)
{
return
SNew(SDockTab)
.TabRole(ETabRole::NomadTab)
[
SNew(STextBlock)
.Text(FText::FromString("InnerTab"))
];
}))
.SetDisplayName(LOCTEXT("InnerTab", "InnerTab"))
.SetMenuType(ETabSpawnerMenuType::Hidden);

// ! InnerTab2的内容：
FGlobalTabmanager::Get()->RegisterNomadTabSpawner(InnerTabName2, FOnSpawnTab::CreateLambda([](const FSpawnTabArgs& SpawnTabArgs)
{
return
SNew(SDockTab)
.TabRole(ETabRole::NomadTab)
[
SNew(STextBlock)
.Text(FText::FromString("InnerTab2"))
];
}))
.SetDisplayName(LOCTEXT("InnerTab2", "InnerTab2"))
.SetMenuType(ETabSpawnerMenuType::Hidden);
}

1
2
3
4

void FTestLayoutWindowModule::PluginButtonClicked()
{
FGlobalTabmanager::Get()->InvokeTab(TestLayoutWindowTabName);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

TSharedRef<SDockTab> FTestLayoutWindowModule::OnSpawnPluginTab(const FSpawnTabArgs& SpawnTabArgs)
{
//原来的分页：
const TSharedRef<SDockTab> NomadTab = SNew(SDockTab)
.TabRole(ETabRole::NomadTab);

//创建TabManager
if (!TabManager.IsValid())
{
TabManager = FGlobalTabmanager::Get()->NewTabManager(NomadTab);
}

//创建布局：
if (!TabManagerLayout.IsValid())
{
TabManagerLayout = FTabManager::NewLayout("TestLayoutWindow")
->AddArea
(
FTabManager::NewPrimaryArea()
->SetOrientation(Orient_Vertical)
->Split
(
FTabManager::NewStack()
->SetSizeCoefficient(.4f)
->AddTab(InnerTabName, ETabState::OpenedTab)
)
->Split
(
FTabManager::NewStack()
->SetSizeCoefficient(.4f)
->AddTab(InnerTabName2, ETabState::OpenedTab)
)
);

}

//从布局中恢复得到控件
TSharedRef<SWidget> TabContents = TabManager->RestoreFrom(TabManagerLayout.ToSharedRef(), TSharedPtr<SWindow>()).ToSharedRef();

//设置内容控件
NomadTab->SetContent(
TabContents
);

return NomadTab;
}

1
2
3
4
5

TSharedRef<FEditorViewportClient> STestLevelEditorViewport::MakeEditorViewportClient()
{
TSharedPtr<FEditorViewportClient> EditorViewportClient = MakeShareable(new FEditorViewportClient(nullptr));
return EditorViewportClient.ToSharedRef();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

TSharedRef<FEditorViewportClient> STestEditorViewport::MakeEditorViewportClient()
{
PreviewScene = MakeShareable(new FPreviewScene());

//向预览场景中加一个测试模型
{
//读取模型
UStaticMesh* SM = LoadObject<UStaticMesh>(NULL, TEXT("StaticMesh'/Engine/EngineMeshes/Cube.Cube'"), NULL, LOAD_None, NULL);
//创建组件
UStaticMeshComponent* SMC = NewObject<UStaticMeshComponent>();
SMC->SetStaticMesh(SM);
//向预览场景中增加组件
PreviewScene->AddComponent(SMC, FTransform::Identity);
}

TSharedPtr<FEditorViewportClient> EditorViewportClient = MakeShareable(new FEditorViewportClient(nullptr, PreviewScene.Get()));

return EditorViewportClient.ToSharedRef();
}

1
2
3
4
5

TSharedPtr<SWidget> STestEditorViewport::MakeViewportToolbar()
{
return SNew(SCommonEditorViewportToolbarBase, SharedThis(this));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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

#include <Python.h>
#include <maya/MGlobal.h>
#include <stdio.h>

static const char MAYA_PYTHON_C_EXT_DOCSTRING[] = "An example Python C extension that makes use of Maya functionality.";
static const char HELLO_WORLD_MAYA_DOCSTRING[] = "Says hello world!";

// NOTE(timmyliang): 调用 MGlobal API 打印 Python 传递的字符串
static PyObject *pyHelloWorldMaya(PyObject *module, PyObject *args)
{
const char *inputString;
if (!PyArg_ParseTuple(args, "s", &inputString))
{
return NULL;
}

PyGILState_STATE pyGILState = PyGILState_Ensure();

MGlobal::displayInfo(inputString);

PyObject *result = Py_BuildValue("s", inputString);

PyGILState_Release(pyGILState);

return result;
}

// NOTE(timmyliang): 定义模块的函数列表
static PyMethodDef mayaPythonCExtMethods[] = {
{"hello_world_maya", pyHelloWorldMaya, METH_VARARGS, HELLO_WORLD_MAYA_DOCSTRING},
{NULL, NULL, 0, NULL} // NOTE: (sonictk) Sentinel value for Python
};


// NOTE(timmyliang): python2 初始化函数规范 init<module_name> 
#if PY_MAJOR_VERSION == 2
extern "C" PyMODINIT_FUNC initpy_hello()
{
return Py_InitModule3("py_hello",
  mayaPythonCExtMethods,
  MAYA_PYTHON_C_EXT_DOCSTRING);
}
// NOTE(timmyliang): python3 初始化函数规范 PyInit_<module_name> 
#elif PY_MAJOR_VERSION == 3
extern "C" PyMODINIT_FUNC PyInit_py_hello()
{
static PyModuleDef hello_module = {
PyModuleDef_HEAD_INIT,
"py_hello", // Module name to use with Python import statements
MAYA_PYTHON_C_EXT_DOCSTRING, // Module description
0,
mayaPythonCExtMethods // Structure that defines the methods of the module
};
return PyModule_Create(&hello_module);
}
#endif

1
2
3
4

Traceback (most recent call last):
  File "d:/Obsidian/Personal/2_Area/📝Blog/CG/Maya/C++/test_load.py", line 5, in <module>
    import py_hello
ImportError: DLL load failed while importing py_hello: 找不到指定的程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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