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()