from maya import cmds
from maya.api import OpenMaya as om2

bind_position = om2.MPoint(cmds.pointPosition()) #リベットしたい頂点
bind_spine01_matrix = om2.MMatrix(cmds.xform("spine_01", q=True, matrix=True, ws=True)) #spine01のバインド時のマトリックス
bind_spine02_matrix = om2.MMatrix(cmds.xform("spine_02", q=True, matrix=True, ws=True)) #spine02のバインド時のマトリックス

delta_spine01_position = bind_position * bind_spine01_matrix.inverse() #リベットしたい頂点とspine01の差分値
delta_spine02_position = bind_position * bind_spine02_matrix.inverse() #リベットしたい頂点とspine02の差分値

from maya import cmds
nodes = cmds.ls(sl=True)
for node in nodes:
    ue4_name = "SM_" + node[0].upper() + node[1:]
    cmds.rename(node, ue4_name)

import os
from maya import cmds
from maya import OpenMaya as om

nodes = cmds.ls(sl=True)
for node in nodes:
    cmds.select(node)
    new_path = os.path.join(current_dir, "{}.fbx".format(node))
    new_path = new_path.replace("\\", "/")
    cmds.FBXPushSettings()
    try:
        cmds.FBXResetExport()
        cmds.FBXProperty("Export|IncludeGrp|Geometry|Triangulate", "-v", 1)
        cmds.FBXProperty("Export|IncludeGrp|Animation", "-v", 0)
        cmds.FBXExportInputConnections("-v", 0)
        cmds.FBXExportCameras("-v", 0)
        cmds.FBXExportConstraints("-v", 0)
        cmds.FBXExportLights("-v", 0)
        om.MGlobal.executeCommand('FBXExport("-f", "{}", "-s")'.format(new_path))
    finally:
        cmds.FBXPopSettings()

# -*- coding: utf-8 -*-
import os
from maya import cmds
from PySide2 import QtWidgets
from PySide2.QtUiTools import QUiLoader
from maya.app.general.mayaMixin import MayaQWidgetBaseMixin

# designer.exeで作ったUIファイルを取得する
CURRENT_FILE = os.path.normpath(__file__)
path, ext = os.path.splitext(CURRENT_FILE)
UI_FILE = path + ".ui"

class TRSConnectorWindow(MayaQWidgetBaseMixin, QtWidgets.QMainWindow):
    def __init__(self, *args, **kwargs):
        super(TRSConnectorWindow, self).__init__(*args, **kwargs)

        # 作ったUIファイルをロードして変数に入れる
        self.widget = QUiLoader().load(UI_FILE)
        self.setWindowTitle(self.widget.windowTitle())

        # QMainWindowの中央のウィジェットに入れる
        self.setCentralWidget(self.widget)

        # ボタンとのコネクションを作る
        self.widget.pb_t.clicked.connect(self.clicked_connect_translate)
        self.widget.pb_r.clicked.connect(self.clicked_connect_rotate)
        self.widget.pb_s.clicked.connect(self.clicked_connect_scale)

    def clicked_connect_translate(self): # 移動を接続する関数
        src, dst = cmds.ls(os=True)
        cmds.connectAttr("{}.translate".format(src), "{}.translate".format(dst))

    def clicked_connect_rotate(self): # 回転を接続する関数
        src, dst = cmds.ls(os=True)
        cmds.connectAttr("{}.rotate".format(src), "{}.rotate".format(dst))

    def clicked_connect_scale(self): # スケールを接続する関数
        src, dst = cmds.ls(os=True)
        cmds.connectAttr("{}.scale".format(src), "{}.scale".format(dst))

from maya import cmds
from maya.api import OpenMaya as om2

def getClosestVertexPoint(in_pos, in_mesh):
    
    # 選択リストを作ってターゲットメッシュを追加する
    sl = om2.MSelectionList()
    sl.add(in_mesh)
    
    # 選択リストの0番目の要素をMDagPath型で取得する
    dagpath = sl.getDagPath(0)
    
    # 取得したMDagPathをMFnMeshに入れる
    mesh = om2.MFnMesh(dagpath)
    
    # MFnMeshのコマンドが使えるようになったので最近接頂点取得コマンドを使ってみる。
    poly_pt, poly_id = \
        mesh.getClosestPoint(om2.MPoint(in_pos),om2.MSpace.kWorld)
        
    # 指定したポリゴン内の頂点IDを取得する
    poly_ids = mesh.getPolygonVertices(poly_id)
    
    # 入力頂点から最も近い頂点IDの位置を取得する
    closest_vtx_pos = None
    temp_length = None
    for i in range(len(poly_ids)):
        temp_pos = mesh.getPoint(poly_ids[i], om2.MSpace.kWorld)
        delta = (temp_pos - om2.MPoint(in_pos)).length()
        if temp_length is None or delta < temp_length:
            closest_vtx_pos = temp_pos
            temp_length = delta
    return list(closest_vtx_pos)[:3]

from maya import cmds
from maya.api import OpenMaya as om2

# スナップ先のポリゴンメッシュ名
tgt= "tgtShape"

# 選択頂点でリストを作ってくれる。cmds.ls(sl=True)みたいなもの。
sl = om2.MGlobal.getActiveSelectionList()

# メッシュのDagPathと頂点といったコンポーネント情報を取得
dagpath, obj = sl.getComponent(0)

# 頂点のインデックス情報を取得できるのがMFnSingleIndexedComponent
fn_comp = om2.MFnSingleIndexedComponent(obj)
ids = fn_comp.getElements()

# 以下で作った関数を利用してスナップまで行う
fn_mesh = om2.MFnMesh(dagpath)
for i in range(len(ids)):
    vtx_point = fn_mesh.getPoint(ids[i], om2.MSpace.kWorld)
    closest_point = getClosestVertexPoint(vtx_point, tgt)
    cmds.xform("{0}.vtx[{1}]".format(dagpath.fullPathName(), ids[i]), t=closest_point, ws=True)

from maya import cmds
from maya.api import OpenMaya as om2

# 選択した頂点を保存しておく
vtxs = cmds.ls(sl=True,fl=True)
for vtx in vtxs:
    in_pos = cmds.xform(vtx, q=True, t=True)
    closest_pos = getClosestVertexPoint(in_pos, "tgtShape")
    cmds.xform(vtx, t=closest_pos, ws=True)

from maya import cmds
from maya.api import OpenMaya as om2

# 入力頂点
in_pos = cmds.xform("in_locator", q=True, t=True)

# 選択リストを作ってターゲットメッシュを追加する
sl = om2.MSelectionList()
sl.add("body_smooth_skinShape")

# 選択リストの0番目の要素をMDagPath型で取得する
dagpath = sl.getDagPath(0)

# 取得したMDagPathをMFnMeshに入れる
mesh = om2.MFnMesh(dagpath)

# MFnMeshのコマンドが使えるようになったので最近接頂点取得コマンドを使ってみる。
poly_pt, poly_id = \
    mesh.getClosestPoint(om2.MPoint(in_pos),om2.MSpace.kWorld)
    
# 指定したポリゴン内の頂点IDを取得する
poly_ids = mesh.getPolygonVertices(poly_id)

# 入力頂点から最も近い頂点IDの位置を取得する
closest_vtx_pos = None
temp_length = None
for i in range(len(poly_ids)):
    temp_pos = mesh.getPoint(poly_ids[i], om2.MSpace.kWorld)
    delta = (temp_pos - om2.MPoint(in_pos)).length()
    if temp_length is None or delta < temp_length:
        closest_vtx_pos = temp_pos
        temp_length = delta

# 取得した最も近い頂点位置に"out_locator"をセットする
cmds.xform("out_locator", t=list(closest_vtx_pos)[:3])

# coding: utf-8
import os
from pysbs import context
from pysbs import sbsenum
from pysbs import sbsgenerator

def createSBSGraph(aDestFileAbsPath):
    aContext = context.Context()
    startPos = [48, 48, 0]
    xOffset  = [192, 0, 0]
    yOffset  = [0, 192, 0]

    try:
        # ファイルと"SimpleMaterial"グラフをを作成する
        sbsDoc = sbsgenerator.createSBSDocument(
                                aContext,
                                aFileAbsPath = aDestFileAbsPath,
                                aGraphIdentifier = 'SimpleMaterial'
                                )

        # SimpleMaterialグラフを取得する
        aGraph = sbsDoc.getSBSGraph(aGraphIdentifier = 'SimpleMaterial')

        # BaseColor用のUniformカラーノードを作成する
        baseColor = aGraph.createCompFilterNode(
                        aFilter = sbsenum.FilterEnum.UNIFORM,
                        aParameters = {sbsenum.CompNodeParamEnum.OUTPUT_COLOR: [1, 0, 0, 1]},
                        aGUIPos     = startPos
                        )

        # Metallic用のUniformカラーノードを作成する
        metallic = aGraph.createCompFilterNode(
                        aFilter = sbsenum.FilterEnum.UNIFORM,
                        aParameters = {
                            sbsenum.CompNodeParamEnum.COLOR_MODE: sbsenum.ColorModeEnum.GRAYSCALE,
                            sbsenum.CompNodeParamEnum.OUTPUT_COLOR: 0.6
                            },
                        aGUIPos = baseColor.getOffsetPosition(yOffset)
                        )

        # BaseColorのアウトプットノードを作成する
        outBaseColor = aGraph.createOutputNode(
                            aIdentifier = 'BaseColor',
                            aGUIPos = baseColor.getOffsetPosition(xOffset),
                            aUsages = {
                                sbsenum.UsageEnum.BASECOLOR: {
                                    sbsenum.UsageDataEnum.COMPONENTS:sbsenum.ComponentsEnum.RGBA
                                    }
                                }
                            )

        # Metallicのアウトプットノードを作成する
        outMetallic = aGraph.createOutputNode(
                            aIdentifier = 'Metallic',
                            aGUIPos = metallic.getOffsetPosition(xOffset),
                            aUsages = {
                                sbsenum.UsageEnum.METALLIC: {
                                    sbsenum.UsageDataEnum.COMPONENTS:sbsenum.ComponentsEnum.RGBA
                                    }
                                }
                            )

        # Uniform ColorノードとOutputノードを接続する
        aGraph.connectNodes(aLeftNode = baseColor, aRightNode = outBaseColor)
        aGraph.connectNodes(aLeftNode = metallic,  aRightNode = outMetallic)

        # sbsファイルに書き込む
        sbsDoc.writeDoc()

        return True

    except BaseException as error:
        raise error


def main():
    destFileAbsPath = os.path.join(os.path.dirname(__file__), 'sample/resultDemoHelloWorld.sbs')
    createSBSGraph(destFileAbsPath)


if __name__ == "__main__":
    main()

# coding: utf-8
from PySide2.QtCore import *
from PySide2.QtGui import *
from PySide2.QtWidgets import *

# Mayaとは依存関係のない単なるボタン付きウインドウ
class SimpleButtonUIBase(QWidget):    
    def __init__(self, *args, **kwargs):
        super(SimpleButtonUIBase, self).__init__(*args, **kwargs)
        
        # ウインドウのタイプを決める
        self.setWindowFlags(Qt.Window)

        # ウインドウのオブジェクト名とタイトル名を設定する
        self.setObjectName('simple_button')        
        self.setWindowTitle('Simple Button')

        # いろいろ作る部分
        # １．レイアウトを作る
        main_layout = QVBoxLayout(self)
        # ２．部品を作る
        self.buttonA = QPushButton("Button A", self)
        self.buttonB = QPushButton("Button B", self)
        # ３．部品をレイアウトに追加する
        main_layout.addWidget(self.buttonA)
        main_layout.addWidget(self.buttonB)
        # ４．部品をクリックした時の振る舞いを作る
        self.buttonA.clicked.connect(self.buttonA_onClicked)
        self.buttonB.clicked.connect(self.buttonB_onClicked)

    def buttonA_onClicked(self):
        print("ButtonA Clicked.")

    def buttonB_onClicked(self):
        print("ButtonB Clicked.")


# Mayaと依存関係のないウインドウ
window_instance = SimpleButtonUIBase()
window_instance.show()


##########################################################
# ここからMaya依存にしたGUIを作っていきます。
##########################################################
from maya import cmds
from maya import OpenMayaUI as omui
from shiboken2 import wrapInstance

# SimpleButtonUIBase継承したMaya用のクラス
class MayaSimpleButtonUI(SimpleButtonUIBase):
    def __init__(self, parent):
        super(MayaSimpleButtonUI, self).__init__(parent)
        self.setWindowTitle("Create Primitive")
        self.buttonA.setText("Poly Cube")
        self.buttonB.setText("Poly Sphere")
        
    def buttonA_onClicked(self):
        print("Maya ButtonA Clicked")
        cmds.polyCube()
        
    def buttonB_onClicked(self):
        print("Maya ButtonB Clicked")
        cmds.polySphere()


# mayaのメインウインドウを取得する
def get_maya_main_window():
    omui.MQtUtil.mainWindow()
    ptr = omui.MQtUtil.mainWindow()
    widget = wrapInstance(long(ptr), QWidget)
    return widget


# 依存関係のないウインドウを継承して作ったMaya用のボタンUI
maya_window_instance = MayaSimpleButtonUI(parent=get_maya_main_window())
maya_window_instance.show()

from sd.api.sdproperty import SDPropertyCategory
from sd.api.sdvaluecolorrgba import SDValueColorRGBA
from sd.api.sdbasetypes import ColorRGBA

# 現在開いているグラフを取得する
g = uiMgr.getCurrentGraph()

# グラフ内の選択しているノードを取得する
selection = uiMgr.getCurrentGraphSelection()
for node in selection:
    # ノードに存在するインプット関連のパラメーターを取得する。
    props = node.getProperties(SDPropertyCategory.Input)
    for prop in props:
        # パラメーター名が"Output Color"の場合は赤色をセットする
        if prop.getLabel() == "Output Color":
            value = node.setPropertyValue(
                prop,
                SDValueColorRGBA.sNew(ColorRGBA(1,0,0,1))
            )