def compute(self,plug,data):
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
if (plug == randomNode.outPoints):
pointsData = data.outputValue(randomNode.outPoints)
pointsAAD = OpenMaya.MFnArrayAttrsData()
pointsObject = pointsAAD.create()
positionArray = pointsAAD.vectorArray("position")
idArray = pointsAAD.doubleArray("id")
for i in range(data.inputValue(randomNode.inNumPoints).asInt()):
x = random.uniform(data.inputValue(randomNode.inXMin).asFloat(),
data.inputValue(randomNode.inXMax).asFloat())
y = random.uniform(data.inputValue(randomNode.inYMin).asFloat(),
data.inputValue(randomNode.inYMax).asFloat())
z = random.uniform(data.inputValue(randomNode.inZMin).asFloat(),
data.inputValue(randomNode.inZMax).asFloat())
positionArray.append(OpenMaya.MVector(x, y, z))
idArray.append(i)
pointsData.setMObject(pointsObject)
data.setClean(plug)
def initialize_data(self):
""" get cache data from the sporeNode's instanceData plug/
:param instance_data_plug MPlug: instanceData plug """
node_fn = om.MFnDependencyNode(self.node)
self.data_plug = node_fn.findPlug('instanceData')
self.data_object = self.data_plug.asMObject()
array_attr_fn = om.MFnArrayAttrsData(self.data_object)
self.position = array_attr_fn.vectorArray('position')
self.scale = array_attr_fn.vectorArray('scale')
self.rotation = array_attr_fn.vectorArray('rotation')
self.instance_id = array_attr_fn.intArray('objectIndex')
self.visibility = array_attr_fn.intArray('visibility')
self.normal = array_attr_fn.vectorArray('normal')
self.tangent = array_attr_fn.vectorArray('tangent')
self.u_coord = array_attr_fn.doubleArray('u_coord')
self.v_coord = array_attr_fn.doubleArray('v_coord')
self.poly_id = array_attr_fn.intArray('poly_id')
self.color = array_attr_fn.vectorArray('color')
self.unique_id = array_attr_fn.intArray('unique_id')
# TODO - set bb
# get position as numpy array
for i in xrange(self.position.length()):
position = [[
self.position[i].x, self.position[i].y, self.position[i].z
]]
self.np_position = np.append(self.np_position, position, axis=0)
self.logger.debug('Initialize InstanceData object for: {}'.format(
self.node_name))
def compute(self, plug, data):
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
if plug == RealSimNode.outPnt:
time_ = data.inputValue(RealSimNode.time).asTime().value()
# inNPnt_ = data.inputValue(RealSimNode.inNPnt).asInt()
pointsData = data.outputValue(RealSimNode.outPnt)
pointsAAD = OpenMaya.MFnArrayAttrsData()
pointsObject = pointsAAD.create()
positionArr = pointsAAD.vectorArray("position")
idArr = pointsAAD.doubleArray("id")
for i in range(self.pos.shape[1]):
positionArr.append(
OpenMaya.MVector(*self.pos[time_ * 6][i]) / 50)
idArr.append(i)
pointsData.setMObject(pointsObject)
data.setClean(plug)
def compute(self, plug, data):
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
print "I'm computing\n"
if (plug == randomNode.outPoints):
print "I'm inside\n"
inNHandle = data.inputValue(randomNode.inNumPoints)
inN = inNHandle.asInt()
minBHandle = data.inputValue(randomNode.minBound)
minB = minBHandle.asDouble3()
miX = minB[0]
miY = minB[1]
miZ = minB[2]
maxBHandle = data.inputValue(randomNode.maxBound)
maxB = maxBHandle.asDouble3()
maX = maxB[0]
maY = maxB[1]
maZ = maxB[2]
pointsData = data.outputValue(randomNode.outPoints)
pointsAAD = OpenMaya.MFnArrayAttrsData()
pointsObject = pointsAAD.create()
positionArray = pointsAAD.vectorArray("position")
idArray = pointsAAD.doubleArray("id")
x = 0
while x < inN:
positionArray.append(
OpenMaya.MVector(random.uniform(miX, maX),
random.uniform(miY, maY),
random.uniform(miZ, maZ)))
idArray.append(x)
print "x\n"
x = x + 1
pointsData.setMObject(pointsObject)
data.setClean(plug)
else:
print plug.name()
if (randomNode.outPoints.isNull()):
print "Foook"
def compute(self, plug, data):
if (plug == randomNode.outPoints):
pointsData = data.outputValue(randomNode.outPoints)
pointsAAD = OpenMaya.MFnArrayAttrsData()
pointsObject = pointsAAD.create()
positionArray = pointsAAD.vectorArray("position")
idArray = pointsAAD.doubleArray("id")
for i in range(data.inputValue(randomNode.inNumPoints).asInt()):
x = random.uniform(data.inputValue(randomNode.inXMin).asFloat(),
data.inputValue(randomNode.inXMax).asFloat())
y = random.uniform(data.inputValue(randomNode.inYMin).asFloat(),
data.inputValue(randomNode.inYMax).asFloat())
z = random.uniform(data.inputValue(randomNode.inZMin).asFloat(),
data.inputValue(randomNode.inZMax).asFloat())
positionArray.append(OpenMaya.MVector(x, y, z))
idArray.append(i)
pointsData.setMObject(pointsObject)
data.setClean(plug)
def compute(self, plug, data):
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
if plug == randomNode.outPoints:
inNumPointsData = data.inputValue(randomNode.inNumPoints)
inNumPointsValue = inNumPointsData.asInt()
minVecData = data.inputValue(randomNode.minVec)
minVecData = minVecData.asDouble3()
maxVecData = data.inputValue(randomNode.maxVec)
maxVecData = maxVecData.asDouble3()
pointsData = data.outputValue(randomNode.outPoints)
pointsAAD = OpenMaya.MFnArrayAttrsData()
pointsObject = pointsAAD.create()
# Create the vectors for position and id
positionArray = pointsAAD.vectorArray("position")
idArray = pointsAAD.doubleArray("id")
# Loop to fill the arrays:
for num in range(0, inNumPointsValue):
sx = random.uniform(minVecData[0], maxVecData[0])
sy = random.uniform(minVecData[1], maxVecData[1])
sz = random.uniform(minVecData[2], maxVecData[2])
positionArray.append(OpenMaya.MVector(sx, sy, sz))
idArray.append(num)
# Finally set the output data handle
pointsData.setMObject(pointsObject)
data.setClean(plug)
def compute(self, plug, block):
mOutput = OpenMayaMPx.cvar.MPxEmitterNode_mOutput
# Determine if we are requesting the output plug for this emitter node.
#
if plug == mOutput:
# Get the logical index of the element this plug refers to,
# because the node can be emitting particles into more than
# one particle shape.
#
try:
multiIndex = plug.logicalIndex( )
# Get output data arrays (position, velocity, or parentId)
# that the particle shape is holding from the previous frame.
#
hOutArray = block.outputArrayValue ( mOutput )
# Create a builder to aid in the array construction efficiently.
#
bOutArray = hOutArray.builder( )
# Get the appropriate data array that is being currently evaluated.
#
hOut = bOutArray.addElement( multiIndex )
# Create the data and apply the function set,
# particle array initialized to length zero,
# fnOutput.clear()
#
fnOutput = OpenMaya.MFnArrayAttrsData()
dOutput = fnOutput.create( )
# Check if the particle object has reached it's maximum,
# hence is full. If it is full then just return with zero particles.
#
beenFull = simpleEmitter.isFullValue( self, multiIndex, block )
if beenFull == 1:
return
# Get input position and velocity arrays where new particles are from,
# also known as the owner. An owner is determined if connections exist
# to the emitter node from a shape such as nurbs, polymesh, curve,
# or a lattice shape.
#
# Get a single position from world transform
#
inPosAry = OpenMaya.MVectorArray()
inPosAry.clear()
worldPos = OpenMaya.MPoint(0.0, 0.0, 0.0)
simpleEmitter.getWorldPosition( self, worldPos )
worldV = OpenMaya.MVector(worldPos[0], worldPos[1], worldPos[2])
inPosAry.append( worldV )
# Create a single velocity
inVelAry = OpenMaya.MVectorArray()
inVelAry.clear()
velocity = OpenMaya.MVector(0, 0, 0)
inVelAry.append( velocity )
# Get deltaTime, currentTime and startTime.
# If deltaTime <= 0.0, or currentTime <= startTime,
# do not emit new pariticles and return.
#
cT = simpleEmitter.currentTimeValue( self, block )
sT = simpleEmitter.startTimeValue( self, multiIndex, block )
dT = simpleEmitter.deltaTimeValue( self, multiIndex, block )
dTValue = dT.value()
if cT <= sT or dTValue <= 0.0:
# We do not emit particles before the start time,
# and do not emit particles when moving backwards in time.
#
# This code is necessary primarily the first time to
# establish the new data arrays allocated, and since we have
# already set the data array to length zero it does
# not generate any new particles.
#
hOut.setMObject( dOutput )
block.setClean( plug )
return
# Compute and store an emission rate
#
emitCountPP = OpenMaya.MIntArray()
emitCountPP.clear()
plugIndex = plug.logicalIndex( )
# Get rate and delta time.
#
rate = simpleEmitter.rateValue( self, block )
dtRate = simpleEmitter.deltaTimeValue( self, plugIndex, block )
dtRateDbl = dtRate.as( OpenMaya.MTime.kSeconds )
dblCount = rate * dtRateDbl
intCount = int(dblCount)
emitCountPP.append( intCount )
# Get speed, direction vector, and inheritFactor attributes.
#
speed = simpleEmitter.speedValue( self, block )
dirV = simpleEmitter.directionValue( self, block )
inheritFactor = simpleEmitter.inheritFactorValue( self, multiIndex, block )
# Get the position, velocity, and normalized time arrays to append new particle data.
#
fnOutPos = fnOutput.vectorArray( "position" )
fnOutVel = fnOutput.vectorArray( "velocity" )
fnOutTime = fnOutput.doubleArray( "timeInStep" )
# Convert deltaTime into seconds.
#
dt = dT.as( OpenMaya.MTime.kSeconds )
# Rotate the direction attribute by world transform
rotatedV = simpleEmitter.useRotation( self, dirV )
# Start emitting particles.
#
simpleEmitter.emit( self, inPosAry, inVelAry, emitCountPP, dt, speed, inheritFactor,\
rotatedV, fnOutPos, fnOutVel, fnOutTime)
# Update the data block with new dOutput and set plug clean.
#
# sys.__stdout__.write( " handle: " + str(hOut) + "\n" )
hOut.setMObject( dOutput )
block.setClean( plug )
except:
sys.stderr.write("simpleEmitter compute error\n")
raise
else:
return OpenMaya.kUnknownParameter
def write_points(self, *args, **kwargs):
""" write the instanceData attribute, that can't be saved with the
maya scene, to the node's storage attributes to make sure all points
are svaed with the maya file """
# state = instance_data.SporeState(self.thisMObject())
node_fn = om.MFnDependencyNode(self.thisMObject())
data_plug = node_fn.findPlug('instanceData')
data_obj = data_plug.asMObject()
array_attr_fn = om.MFnArrayAttrsData(data_obj)
vect_array_fn = om.MFnVectorArrayData()
int_array_fn = om.MFnIntArrayData()
double_array_fn = om.MFnDoubleArrayData()
# store position
position = array_attr_fn.vectorArray('position')
position_obj = vect_array_fn.create(position)
position_plug = node_fn.findPlug('position')
position_plug.setMObject(position_obj)
# store scale
scale = array_attr_fn.vectorArray('scale')
scale_obj = vect_array_fn.create(scale)
scale_plug = node_fn.findPlug('scale')
scale_plug.setMObject(scale_obj)
#store rotation
rotation = array_attr_fn.vectorArray('rotation')
rotation_obj = vect_array_fn.create(rotation)
rotation_plug = node_fn.findPlug('rotation')
rotation_plug.setMObject(rotation_obj)
# store instance id
instance_id = array_attr_fn.intArray('objectIndex')
instance_id_obj = int_array_fn.create(instance_id)
instance_id_plug = node_fn.findPlug('instanceId')
instance_id_plug.setMObject(instance_id_obj)
# store visibility
visibility = array_attr_fn.intArray('visibility')
visibility_obj = int_array_fn.create(visibility)
visibility_plug = node_fn.findPlug('visibility')
visibility_plug.setMObject(visibility_obj)
normal = array_attr_fn.vectorArray('normal')
normal_obj = vect_array_fn.create(normal)
normal_plug = node_fn.findPlug('normal')
normal_plug.setMObject(normal_obj)
tangent = array_attr_fn.vectorArray('tangent')
tangent_obj = vect_array_fn.create(tangent)
tangent_plug = node_fn.findPlug('tangent')
tangent_plug.setMObject(tangent_obj)
u_coord = array_attr_fn.doubleArray('u_coord')
u_coord_obj = double_array_fn.create(u_coord)
u_coord_plug = node_fn.findPlug('uCoord')
u_coord_plug.setMObject(u_coord_obj)
v_coord = array_attr_fn.doubleArray('v_coord')
v_coord_obj = double_array_fn.create(v_coord)
v_coord_plug = node_fn.findPlug('vCoord')
v_coord_plug.setMObject(v_coord_obj)
poly_id = array_attr_fn.intArray('poly_id')
poly_id_obj = int_array_fn.create(poly_id)
poly_id_plug = node_fn.findPlug('polyId')
poly_id_plug.setMObject(poly_id_obj)
color = array_attr_fn.vectorArray('color')
color_obj = vect_array_fn.create(color)
color_plug = node_fn.findPlug('color')
color_plug.setMObject(color_obj)
unique_id = array_attr_fn.intArray('unique_id')
unique_id_obj = int_array_fn.create(unique_id)
unique_id_plug = node_fn.findPlug('uniqueId')
unique_id_plug.setMObject(unique_id_obj)
def initialize_state(self, plug, data):
""" initialize the instance data attribute by
creating all arrays needed. read data from the storage attributes
and add it the instance data """
# create array attr
output = data.outputValue(plug)
array_attr_fn = om.MFnArrayAttrsData()
attr_array_obj = array_attr_fn.create()
out_position = array_attr_fn.vectorArray('position')
out_scale = array_attr_fn.vectorArray('scale')
out_rotation = array_attr_fn.vectorArray('rotation')
out_id = array_attr_fn.intArray('objectIndex')
out_visibility = array_attr_fn.intArray('visibility')
normal = array_attr_fn.vectorArray('normal')
tangent = array_attr_fn.vectorArray('tangent')
u_coord = array_attr_fn.doubleArray('u_coord')
v_coord = array_attr_fn.doubleArray('v_coord')
poly_id = array_attr_fn.intArray('poly_id')
color = array_attr_fn.vectorArray('color')
unique_id = array_attr_fn.intArray('unique_id')
# load points from stored attributes oand copy to instance data attr
# this should happen only once when the scene is loaded
is_point_cached = data.inputValue(self.a_points_cached).asBool()
if not is_point_cached:
vect_array_fn = om.MFnVectorArrayData()
int_array_fn = om.MFnIntArrayData()
double_array_fn = om.MFnDoubleArrayData()
position_data = data.outputValue(self.a_position).data()
vect_array_fn.setObject(position_data)
vect_array_fn.copyTo(out_position)
rotation_data = data.outputValue(self.a_rotation).data()
vect_array_fn.setObject(rotation_data)
vect_array_fn.copyTo(out_rotation)
scale_data = data.outputValue(self.a_scale).data()
vect_array_fn.setObject(scale_data)
vect_array_fn.copyTo(out_scale)
instance_id_data = data.outputValue(self.a_instance_id).data()
int_array_fn.setObject(instance_id_data)
int_array_fn.copyTo(out_id)
visibility_data = data.outputValue(self.a_visibility).data()
int_array_fn.setObject(visibility_data)
int_array_fn.copyTo(out_visibility)
normal_data = data.outputValue(self.a_normal).data()
vect_array_fn.setObject(normal_data)
vect_array_fn.copyTo(normal)
tangent_data = data.outputValue(self.a_tangent).data()
vect_array_fn.setObject(tangent_data)
vect_array_fn.copyTo(tangent)
u_cood_data = data.outputValue(self.a_u_coord).data()
double_array_fn.setObject(u_cood_data)
double_array_fn.copyTo(u_coord)
v_cood_data = data.outputValue(self.a_v_coord).data()
double_array_fn.setObject(v_cood_data)
double_array_fn.copyTo(v_coord)
poly_id_data = data.outputValue(self.a_poly_id).data()
int_array_fn.setObject(poly_id_data)
int_array_fn.copyTo(poly_id)
color_data = data.outputValue(self.a_color).data()
vect_array_fn.setObject(color_data)
vect_array_fn.copyTo(color)
unique_id_data = data.outputValue(self.a_unique_id).data()
int_array_fn.setObject(unique_id_data)
int_array_fn.copyTo(unique_id)
# set points cached to true
is_point_cached_handle = data.outputValue(self.a_points_cached)
is_point_cached_handle.setBool(True)
# set the instance data attribute
output.setMObject(attr_array_obj)
self._state = instance_data.InstanceData(self.thisMObject())
self._state.initialize_data()
from maya import OpenMaya
import pymel.core as pm
# NOTE 删除之前生成的 loc
pm.delete([grp for grp in pm.ls(assemblies=1) if grp.startswith("frame")])
data = {}
min_time = pm.playbackOptions(q=1, min=1)
max_time = pm.playbackOptions(q=1, max=1)
for i in range(int(min_time), int(max_time) + 1):
pm.currentTime(i, update=1)
mashNetwork = mapi.Network("MASH1")
# NOTE 这个是 MASH1_Repro 节点
node = pm.PyNode(mashNetwork.instancer)
# NOTE 获取 MPlug 属性
obj = node.inputPoints.__apiobject__().asMObject()
inputPointsData = OpenMaya.MFnArrayAttrsData(obj)
positions = inputPointsData.getVectorData("position")
loc_list = []
# TODO 不能直接 for 循环 | 会导致 Maya 崩溃
for i in range(positions.length()):
pt = positions[i]
loc = pm.spaceLocator()
loc.t.set((pt.x, pt.y, pt.z))
loc_list.append(loc)
pm.group(loc_list, n="frame_%s" % i)
data[i] = mashNetwork.position
print(data)
def compute(self, plug, data):
if (plug == LSystemInstanceNode.branches
or plug == LSystemInstanceNode.flowers):
# get parameters
iterations = data.inputValue(
LSystemInstanceNode.iterations).asInt()
angle = data.inputValue(LSystemInstanceNode.angle).asFloat()
step = data.inputValue(LSystemInstanceNode.step).asFloat()
file = data.inputValue(LSystemInstanceNode.file).asString()
# update lsystem
if (angle != LSystemInstanceNode.lsystem.getDefaultAngle()):
LSystemInstanceNode.lsystem.setDefaultAngle(angle)
if (step != LSystemInstanceNode.lsystem.getDefaultStep()):
LSystemInstanceNode.lsystem.setDefaultStep(step)
LSystemInstanceNode.lsystem.loadProgram(file.encode())
# instantiate branches output object
branches = data.outputValue(LSystemInstanceNode.branches)
branchesAAD = OpenMaya.MFnArrayAttrsData()
branchesObject = branchesAAD.create()
branchesPosArray = branchesAAD.vectorArray("position")
branchesIdArray = branchesAAD.doubleArray("id")
branchesScaleArray = branchesAAD.vectorArray("scale")
branchesOrientArray = branchesAAD.vectorArray("aimDirection")
# instantiate flowers output object
flowers = data.outputValue(LSystemInstanceNode.flowers)
flowersAAD = OpenMaya.MFnArrayAttrsData()
flowersObject = flowersAAD.create()
flowersPosArray = flowersAAD.vectorArray("position")
flowersIdArray = flowersAAD.doubleArray("id")
flowersScaleArray = flowersAAD.vectorArray("scale")
# execute LSystem
branchesVec = LSystem.VectorPyBranch()
flowersVec = LSystem.VectorPyBranch()
LSystemInstanceNode.lsystem.processPy(iterations, branchesVec,
flowersVec)
# branches output
for branch in branchesVec:
midX = (branch[0] + branch[3]) / 2
midY = (branch[2] + branch[5]) / 2
midZ = (branch[4] + branch[1]) / 2
branchesPosArray.append(OpenMaya.MVector(midX, midY, midZ))
vecX = branch[3] - branch[0]
vecZ = branch[4] - branch[1]
vecY = branch[5] - branch[2]
vecBranch = OpenMaya.MVector(vecX, vecY, vecZ)
radius = LSystemInstanceNode.lsystem.getDefaultStep() * 0.1
branchesScaleArray.append(
OpenMaya.MVector(vecBranch.length(), radius, radius))
branchesOrientArray.append(OpenMaya.MVector(vecX, vecY, vecZ))
# flowers output
for flower in flowersVec:
flowersPosArray.append(
OpenMaya.MVector(flower[0], flower[2], flower[1]))
scale = LSystemInstanceNode.lsystem.getDefaultStep() * 0.2
flowersScaleArray.append(OpenMaya.MVector(scale, scale, scale))
branches.setMObject(branchesObject)
flowers.setMObject(flowersObject)
data.setClean(plug)
def compute(self, plug, data):
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
#input data
angleData = data.inputValue(LSystemInstanceNode.angle)
stepSizeData = data.inputValue(LSystemInstanceNode.stepSize)
grammarFileData = data.inputValue(LSystemInstanceNode.grammarFile)
iterData = data.inputValue(LSystemInstanceNode.iterations)
angleValue = angleData.asDouble()
stepSizeValue = stepSizeData.asDouble()
grammarFileValue = grammarFileData.asString()
iterValue = iterData.asInt()
#output data
outBranchesData = data.outputValue(LSystemInstanceNode.outputBranches)
outBranchesAAD = OpenMaya.MFnArrayAttrsData()
outBranchesObject = outBranchesAAD.create()
outFlowersData = data.outputValue(LSystemInstanceNode.outputFlowers)
outFlowersAAD = OpenMaya.MFnArrayAttrsData()
outFlowersObject = outFlowersAAD.create()
#vectors for pos, id, scale, aim for branches and flowers
branchPosArr = outBranchesAAD.vectorArray("position")
branchIDArr = outBranchesAAD.doubleArray("id")
branchScaleArr = outBranchesAAD.vectorArray("scale")
branchAimArr = outBranchesAAD.vectorArray("aimDirection")
flowerPosArr = outFlowersAAD.vectorArray("position")
flowerIDArr = outFlowersAAD.doubleArray("id")
lsystem = LSystem.LSystem()
lsystem.loadProgram(str(grammarFileValue))
lsystem.setDefaultAngle(angleValue)
lsystem.setDefaultStep(stepSizeValue)
branches = LSystem.VectorPyBranch()
flowers = LSystem.VectorPyBranch()
lsystem.processPy(iterValue, branches, flowers)
# fill branches and flowers
for j, branch in enumerate(branches):
aim = OpenMaya.MVector(branch[3] - branch[0],
branch[4] - branch[1],
branch[5] - branch[2])
branchPosArr.append(
OpenMaya.MVector((branch[3] + branch[0]) / 2.0,
(branch[4] + branch[1]) / 2.0,
(branch[5] + branch[2]) / 2.0))
branchIDArr.append(j)
aimlength = math.sqrt((branch[3] - branch[0]) *
(branch[3] - branch[0]) +
(branch[5] - branch[2]) *
(branch[5] - branch[2]) +
(branch[4] - branch[1]) *
(branch[4] - branch[1]))
branchScaleArr.append(OpenMaya.MVector(aimlength, 1.0, 1.0))
branchAimArr.append(aim)
for k, flower in enumerate(flowers):
pos = OpenMaya.MVector(flower[0], flower[1], flower[2])
flowerPosArr.append(pos)
flowerIDArr.append(k)
outBranchesData.setMObject(outBranchesObject)
outFlowersData.setMObject(outFlowersObject)
data.setClean(plug)
data.setClean(plug)
def compute(self, plug, data):
# TODO:: create the main functionality of the node. Your node should
# take in three floats for max position (X,Y,Z), three floats
# for min position (X,Y,Z), and the number of random points to
# be generated. Your node should output an MFnArrayAttrsData
# object containing the random points. Consult the homework
# sheet for how to deal with creating the MFnArrayAttrsData.
print "I'm computing\n"
if (plug == LSystemInstanceNode.branches
or plug == LSystemInstanceNode.flowers):
print "I'm inside\n"
angleHandle = data.inputValue(LSystemInstanceNode.angle)
d_angle = angleHandle.asDouble()
stepHandle = data.inputValue(LSystemInstanceNode.step)
d_step = stepHandle.asDouble()
grammarHandle = data.inputValue(LSystemInstanceNode.grammar)
s_grammar = str(grammarHandle.asString())
iterationHandle = data.inputValue(LSystemInstanceNode.iteration)
i_iteration = iterationHandle.asInt()
timeHandle = data.inputValue(LSystemInstanceNode.time)
t_time = timeHandle.asTime()
i_time = int(t_time.asUnits(OpenMaya.MTime.kFilm))
branchesHandle = data.outputValue(LSystemInstanceNode.branches)
branchesAAD = OpenMaya.MFnArrayAttrsData()
branchesObject = branchesAAD.create()
branchesPositionArray = branchesAAD.vectorArray("position")
branchesIdArray = branchesAAD.doubleArray("id")
branchesScaleArray = branchesAAD.vectorArray("scale")
branchesAimArray = branchesAAD.vectorArray("aimDirection")
flowersHandle = data.outputValue(LSystemInstanceNode.flowers)
flowersAAD = OpenMaya.MFnArrayAttrsData()
flowersObject = flowersAAD.create()
flowersPositionArray = flowersAAD.vectorArray("position")
flowersIdArray = flowersAAD.doubleArray("id")
flowersScaleArray = flowersAAD.vectorArray("scale")
flowersAimArray = flowersAAD.vectorArray("aimDirection")
vecBranch = LSystem.VectorPyBranch()
vecFlower = LSystem.VectorPyBranch()
l = LSystem.LSystem()
l.setDefaultAngle(d_angle)
l.setDefaultStep(d_step)
l.loadProgram(s_grammar) #s_grammar
l.processPy(i_time, vecBranch, vecFlower) #iteration
i = 0
for x in vecBranch:
length = ((x[0] - x[3]) * (x[0] - x[3]) + (x[1] - x[4]) *
(x[1] - x[4]) + (x[2] - x[5]) * (x[2] - x[5]))**0.5
branchesPositionArray.append(
OpenMaya.MVector((x[0] + x[3]) / 2, (x[1] + x[4]) / 2,
(x[2] + x[5]) / 2))
branchesIdArray.append(i)
branchesScaleArray.append(OpenMaya.MVector(length, 1, 1))
branchesAimArray.append(
OpenMaya.MVector((x[3] - x[0]), (x[4] - x[1]),
(x[5] - x[2])))
i += 1
print i
i = 0
for x in vecFlower:
length = (x[0] * x[0] + x[1] * x[1] + x[2] * x[2])**0.5
flowersPositionArray.append(OpenMaya.MVector(x[0], x[1], x[2]))
flowersIdArray.append(i)
flowersScaleArray.append(OpenMaya.MVector(1, 1, 1))
flowersAimArray.append(OpenMaya.MVector(x[0], x[1], x[2]))
i += 1
print i
branchesHandle.setMObject(branchesObject)
flowersHandle.setMObject(flowersObject)
data.setClean(plug)
else:
print plug.name()
