ScatterToInstance_v1_Align

# ScatterToInstance_v1_Align
# Select mesh, then scatter object
from pymel.core import *
import maya.cmds as cmds
import random as r
sl = selected()
scatterObjs = sl[:-1]
scatterBase = sl[-1]

print scatterObjs
select(cl=1)

# Scatter Node
scatCheck = ls(scatterBase+"_scatter")
if not scatCheck:
    scat = soup().create('scatter')
    rename(scat[0], scatterBase+"_scatter")
    scat = ls(scatterBase+"_scatter")
    scatterBase.getShape().worldMesh[0] >> scat[0].inGeometry
    scatterBase.worldMatrix[0] >> scat[0].inWorldMatrix
    setAttr(scat[0].scatterMode,1)

# Curve node thing
pointCloudToCurveThingCheck = ls(scatterBase+"_pointCloudToCurve")
if not pointCloudToCurveThingCheck:
    pointCloudToCurveThing = createNode("pointCloudToCurve")
    rename(pointCloudToCurveThing, scatterBase+"_pointCloudToCurve")
    scat[0].outPositionPP >> pointCloudToCurveThing.inArray

# Point Node
pointNode = ls(scatterBase+"_pointNode")
if not pointNode:
    pointNode = createNode("point")
    rename(pointNode, scatterBase+"_pointNode")
    pointNode = ls(scatterBase+"_pointNode")
    pointCloudToCurveThing.outCurve >> pointNode[0].inGeometry

# pointsOnMeshInfo Node s
pointsOnMeshInfoNode = ls(scatterBase+"_pointsOnMeshInfo")
if not pointsOnMeshInfoNode:
    pointsOnMeshInfoNode = createNode("pointsOnMeshInfo")
    rename(pointsOnMeshInfoNode, scatterBase+"_rbg_pointsOnMeshInfo0")
    pointsOnMeshInfoNode = ls(scatterBase+"_rbg_pointsOnMeshInfo0")
    scatterBase.worldMesh[0] >> pointsOnMeshInfoNode[0].inMesh
    scat[0].outPositionPP >> pointsOnMeshInfoNode[0].inPositionPP
    pointsOnMeshInfoNode[0].outRgbaPP >> pointNode[0].inRgbaPP
    setAttr(pointsOnMeshInfoNode[0].colors, 1)
    #node 2
    pointsOnMeshInfoNode1 = createNode("pointsOnMeshInfo")
    rename(pointsOnMeshInfoNode1, scatterBase+"_rbg_pointsOnMeshInfo1")
    pointsOnMeshInfoNode1 = ls(scatterBase+"_rbg_pointsOnMeshInfo1")
    scatterBase.worldMesh[0] >> pointsOnMeshInfoNode1[0].inMesh
    pointNode[0].outPositionPP >> pointsOnMeshInfoNode1[0].inPositionPP
    setAttr(pointsOnMeshInfoNode1[0].normals, 1)
    setAttr(pointsOnMeshInfoNode1[0].colors, 1)



# DisplayComponent Node
displayNode = ls(scatterBase+"_displayComponents")
if not displayNode:
    displayNode = createNode("displayComponents")
    rename(displayNode, scatterBase+"_displayComponents")
    displayNode = ls(scatterBase+"_displayComponents")
    pointNode[0].outGeometry >> displayNode[0].inGeometry
    pointNode[0].outRadiusPP >> displayNode[0].inDataPP

################################################################################
# textureToArray Node
textureToArray = ls(scatterBase+"_textureToArray")
if not textureToArray:
    textureToArray = createNode("textureToArray")
    rename(textureToArray, scatterBase+"_textureToArray")
    textureToArray = ls(scatterBase+"_textureToArray")
    pointCloudToCurveThing.outCurve >> textureToArray[0].inGeometry
    textureToArray[0].outRgbaPP >> pointNode[0].inWeightPP









# position_arrayToDynArrays Node
posArray = ls(scatterBase+"_position_arrayToDynArrays")
if not posArray:
    posArray = createNode("arrayToDynArrays")
    rename(posArray, scatterBase+"_position_arrayToDynArrays")
    posArray = ls(scatterBase+"_position_arrayToDynArrays")
    pointNode[0].outPositionPP >> posArray[0].inArray
    setAttr(scatterBase+"_position_arrayToDynArrays"+".name","position",type="string")
    setAttr(pointNode[0].enablePosition,1)

# Instancer Node
instancerNode = ls(scatterBase+"_instancerNode")
if not instancerNode:
    instancerNode = createNode("instancer")
    rename(instancerNode, scatterBase+"_instancerNode")
    instancerNode = ls(scatterBase+"_instancerNode")
    #cmds.instancer(instancerNode[0], e=1, a=1, obj = slList)
    posArray[0].outDynamicArrays >> instancerNode[0].inputPoints
    i = 0
    for s in scatterObjs:
        print s
        s.matrix >> instancerNode[0].inputHierarchy[i]
        i += 1
# Index_arrayToDynArrays Node
objIndexArray = ls(scatterBase+"_objIndex_arrayToDynArrays")
if not objIndexArray:
    objIndexArray = createNode("arrayToDynArrays")
    rename(objIndexArray, scatterBase+"_objIndex_arrayToDynArrays")
    objIndexArray = ls(scatterBase+"_objIndex_arrayToDynArrays")
    pointNode[0].outWeightPP >> objIndexArray[0].inArray
    setAttr(scatterBase+"_objIndex_arrayToDynArrays"+".name","objectIndex",type="string")
    setAttr(pointNode[0].enableWeight,1)
    objIndexArray[0].outDynamicArrays >> posArray[0].inDynamicArrays
    scaterLength = str(len(scatterObjs))
    setAttr(pointNode[0]+".stringWeight","// POINT WEIGHT "+"\n"+"$x ="+ scaterLength +";" +"\n"+"$W=rand(0,$x);",type="string")

# scale_arrayToDynArrays Node
scaleArray = ls(scatterBase+"_scale_arrayToDynArrays")
if not scaleArray:
    scaleArray = createNode("arrayToDynArrays")
    rename(scaleArray, scatterBase+"_scale_arrayToDynArrays")
    scaleArray = ls(scatterBase+"_scale_arrayToDynArrays")
    pointNode[0].outRadiusPP >> scaleArray[0].inArray
    scaleArray[0].outDynamicArrays >> objIndexArray[0].inDynamicArrays
    setAttr(scatterBase+"_scale_arrayToDynArrays"+".name","scale",type="string")
    setAttr(pointNode[0].enableRadius,1)
    setAttr(pointNode[0]+".stringRadius","// POINT RADIUS "+"\n"+"$R= $CR;"+"\n"+"if ($CR <= .2)"+"\n"+"$R = 0;"+"\n"+"if ($CR >= 1)",type="string")

# AimWorldUp_arrayToDynArrays Node
aimWorldUpArray = ls(scatterBase+"_aimWorldUp_arrayToDynArrays")
if not aimWorldUpArray:
    aimWorldUpArray = createNode("arrayToDynArrays")
    rename(aimWorldUpArray, scatterBase+"_aimWorldUp_arrayToDynArrays")
    aimWorldUpArray = ls(scatterBase+"_aimWorldUp_arrayToDynArrays")
    aimWorldUpArray[0].outDynamicArrays >> scaleArray[0].inDynamicArrays
    pointNode[0].outNormalPP >> aimWorldUpArray[0].inArray
    setAttr(scatterBase+"_aimWorldUp_arrayToDynArrays"+".name","aimWorldUp",type="string")
    setAttr(pointNode[0].enableNormal,1)

# rotate_arrayToDynArrays Node
aimDirectionArray = ls(scatterBase+"_aimDirection_arrayToDynArrays")
if not aimDirectionArray:
    aimDirectionArray = createNode("arrayToDynArrays")
    rename(aimDirectionArray, scatterBase+"_aimDirection_arrayToDynArrays")
    aimDirectionArray = ls(scatterBase+"_aimDirection_arrayToDynArrays")


    aimDirectionArray[0].outDynamicArrays >> aimWorldUpArray[0].inDynamicArrays
    pointsOnMeshInfoNode1[0].outNormalPP >> aimDirectionArray[0].inArray

    setAttr(scatterBase+"_aimDirection_arrayToDynArrays"+".name","aimDirection",type="string")
    setAttr(pointNode[0].enableNormal,1)
    setAttr(pointNode[0]+".stringNormal","// POINT NORMAL "+"\n"+"$X=rand(-$WEIGHT,$WEIGHT);"+"\n"+"$Y=$NY;"+"\n"+"$Z=rand(-$WEIGHT,$WEIGHT);",type="string")

select(scat)
polyColorPerVertex(scatterBase, r=1,g=1,b=1,a=1,cdo=1)