def createFrame(self): self.sels = self.UIMgr.getCurrentGraphSelection() expand = [100, 100] sizeX = None sizeY = None leftNode = None select = False if self.sels: self.currentGraph = self.UIMgr.getCurrentGraph() leftNode = self._getNodeOnLeft(self.sels) rightNode = self._getNodeOnRight(self.sels) topNode = self._getTopNode(self.sels) bottomNode = self._getBottomNode(self.sels) leftPos = leftNode.getPosition() rightPos = rightNode.getPosition() topPos = topNode.getPosition() bottomPos = bottomNode.getPosition() sizeX = rightPos[0] - leftPos[0] + 2 * expand[0] sizeY = bottomPos[1] - topPos[1] + 2 * expand[1] select = True frame = SDGraphObjectFrame.sNew(self.currentGraph) if select: frame.setSize(float2(sizeX, sizeY)) if select: frame.setPosition( float2(leftPos[0] - expand[0], topPos[1] - expand[1]))
def __snapPosition(aPosition, aNodeWidth, aNodeHeight, aSnapSize): def __alignvalue(aValue, aSnapSize): hSnapCellCountf = aValue / aSnapSize hSnapCellCounti = int(hSnapCellCountf) hSnapCellCountFrac = hSnapCellCountf - hSnapCellCounti newValue = aSnapSize * hSnapCellCounti if hSnapCellCountFrac > 0 and hSnapCellCountFrac > 0.5: newValue += aSnapSize elif hSnapCellCountFrac < 0 and abs(hSnapCellCountFrac) > 0.5: newValue -= aSnapSize return newValue newPosition = float2(aPosition.x, aPosition.y) # Apply offset offset = float2(aNodeWidth / 2.0, aNodeHeight / 2.0) newPosition.x -= offset.x newPosition.y -= offset.y # Align horizontally newPosition.x = __alignvalue(newPosition.x, aSnapSize) # Align vertically newPosition.y = __alignvalue(newPosition.y, aSnapSize) # undo offset newPosition.x += offset.x newPosition.y += offset.y return newPosition
def addFrame(item): uiMgr = getQt()[2] cGridSize = GraphGrid.sGetFirstLevelSize() try: graph = uiMgr.getCurrentGraph() except: print("ERROR: No graph active") return frame = SDGraphObjectFrame.sNew(graph) frame.setTitle('Title') frame.setDescription('Description') if item['rand'] == 1: #TODO: adjust size and pos based on selection frame.setColor( ColorRGBA(random.uniform(0, 1), random.uniform(0, 1), random.uniform(0, 1), item['alpha'])) else: frame.setColor( ColorRGBA(item['color'][0], item['color'][1], item['color'][2], item['alpha'])) selection = uiMgr.getCurrentGraphSelection() if len(selection) > 0: min = getMin(selection) max = getMax(selection) size = [max[0] - min[0], max[1] - min[1]] frame.setPosition(float2(min[0] - cGridSize, min[1] - cGridSize)) frame.setSize(float2(size[0] + cGridSize * 2, size[1] + cGridSize * 2)) else: frame.setPosition(float2(-cGridSize, -cGridSize)) frame.setSize(float2(2 * cGridSize, 2 * cGridSize))
def draw_line(self, func_graph, graph_pos: float2, p1: float2, p2: float2, thickness): f = func_graph segment_dist = self.const_float1(f, math.sqrt((p2.x-p1.x)**2 + (p2.y-p1.y)**2)) constant = self.const_float1(f, p2.x*p1.y - p2.y*p1.x) pvec = self.const_float2(f, float2(p2.y-p1.y, -(p2.x-p1.x))) current_pos = self.get_current_pos(f, graph_pos) dist_to_line = self.div(f, self.abs(f, self.add(f, self.dot_prod(f, pvec, current_pos), constant)), segment_dist) p1_node = self.const_float2(f, p1) p2_node = self.const_float2(f, p2) p1_to_cur = self.subtract(f, current_pos, p1_node) p2_to_cur = self.subtract(f, current_pos, p2_node) p1_to_p2 = self.subtract(f, p2_node, p1_node) p2_to_p1 = self.subtract(f, p1_node, p2_node) dot1 = self.dot_prod(f, p1_to_cur, p1_to_p2) dot2 = self.dot_prod(f, p2_to_cur, p2_to_p1) zero = self.const_float1(f, 0) on_segment = self.and_nodes(f, self.lessthan(f, zero, dot1), self.lessthan(f, zero, dot2)) return self.ifelse(f, self.and_nodes(f, self.lessthan(f, dist_to_line, self.const_float1(f, thickness)), on_segment), self.const_float1(f, 1), self.const_float1(f, 0))
def createNewNode(self): self.currentGraph = self.UIMgr.getCurrentGraph() if self.currentGraph and self.nodeName: if '::' in self.nodeName: newNode = self.currentGraph.newNode(self.nodeName) elif 'sbs' in self.nodeName: newNode = self._createInstanceNode() self.newNode = newNode if len(self.inputPropertyInheritanceMethods) > 0: method = None for inheritanceMethod in self.inputPropertyInheritanceMethods: print(inheritanceMethod) if inheritanceMethod['value'] == 'Absolute': method = SDPropertyInheritanceMethod.Absolute elif inheritanceMethod['value'] == 'RelativeToInput': method = SDPropertyInheritanceMethod.RelativeToInput elif inheritanceMethod['value'] == 'RelativeToParent': method = SDPropertyInheritanceMethod.RelativeToParent newNode.setInputPropertyInheritanceMethodFromId( inheritanceMethod['id'], method) if len(self.inputProps) > 0: for prop in self.inputProps: value = None if prop["type"] == 'int': value = SDValueInt.sNew(prop["value"]) elif prop["type"] == 'int2': value = SDValueInt2.sNew( int2(prop["value"][0], prop["value"][1])) elif prop["type"] == 'int3': value = SDValueInt3.sNew( int3(prop["value"][0], prop["value"][1], prop["value"][2])) elif prop["type"] == 'int4': value = SDValueInt4.sNew( int4(prop["value"][0], prop["value"][1], prop["value"][2], prop["value"][3])) elif prop["type"] == 'float': value = SDValueFloat.sNew(prop["value"]) elif prop["type"] == 'float2': value = SDValueFloat2.sNew( float2(prop["value"][0], prop["value"][1])) elif prop["type"] == 'float3': value = SDValueFloat3.sNew( float3(prop["value"][0], prop["value"][1], prop["value"][2])) elif prop["type"] == 'float4': value = SDValueFloat4.sNew( float4(prop["value"][0], prop["value"][1], prop["value"][2], prop["value"][3])) elif prop["type"] == 'bool': value = SDValueBool.sNew(prop["value"]) elif prop["type"] == 'enum': value = SDValueInt.sNew(prop["value"]) elif prop["type"] == 'string': value = SDValueString.sNew(prop["value"]) newNode.setInputPropertyValueFromId(prop["id"], value)
def addComment(item): uiMgr = getQt()[2] cGridSize = GraphGrid.sGetFirstLevelSize() try: graph = uiMgr.getCurrentGraph() except: print("ERROR: No graph active") return selection = uiMgr.getCurrentGraphSelection() if len(selection) > 0: comment = SDGraphObjectComment.sNewAsChild(selection[0]) comment.setPosition(float2(-cGridSize * 0.5, cGridSize * 0.5)) comment.setDescription('Comment') else: comment = SDGraphObjectComment.sNew(graph) comment.setPosition(float2(-cGridSize * 0.5, cGridSize * 0.5)) comment.setDescription('Comment')
def __render_command(self, util, func_graph, c, current_image, graph_pos): if c == "F": new_pos = float2(self.turtle_state.pos.x + self.turtle_state.dist*math.cos(math.pi/180 * self.turtle_state.angle), self.turtle_state.pos.y + self.turtle_state.dist*math.sin(math.pi/180 * self.turtle_state.angle)) line = util.draw_line(func_graph, graph_pos, self.turtle_state.pos, new_pos, self.turtle_state.thickness) self.turtle_state.pos = new_pos return util.union(func_graph, line, current_image) elif c == "f": self.turtle_state.pos = float2(self.turtle_state.pos.x + self.turtle_state.dist*math.cos(math.pi/180 * self.turtle_state.angle), self.turtle_state.pos.y + self.turtle_state.dist*math.sin(math.pi/180 * self.turtle_state.angle)) elif c == "+": self.turtle_state.angle -= self.angle_change elif c == "-": self.turtle_state.angle += self.angle_change elif c == "[": self.turtle_states.append(self.turtle_state.copy()) pass elif c == "]": if len(self.turtle_states) >= 1: self.turtle_state = self.turtle_states.pop() else: raise ValueError("No states left to POP") else: raise ValueError("Invalid character: " + c)
def lessthan(self, func_graph, node1, node2): lt = func_graph.newNode(LESSTHAN) input1 = lt.getPropertyFromId('a', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, lt, input1) input2 = lt.getPropertyFromId('b', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, lt, input2) lt.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return lt
def _setNewNodeToMousePos(self): pos = QtGui.QCursor.pos() qtGraphWidget = self.mainWindow.childAt(pos) if qtGraphWidget: qtGraphViewer = qtGraphWidget.parent() if qtGraphViewer.metaObject().className( ) == 'Pfx::Editor::Components::Graph::GraphView': viewPos = qtGraphViewer.mapFromGlobal(QtGui.QCursor().pos()) scenePos = qtGraphViewer.mapToScene(viewPos) moveTo = float2(scenePos.x(), scenePos.y()) self.newNode.setPosition(moveTo)
def dot_prod(self, func_graph, node1, node2): dot_prod = func_graph.newNode(DOT_PROD) input1 = dot_prod.getPropertyFromId('a', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, dot_prod, input1) input2 = dot_prod.getPropertyFromId('b', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, dot_prod, input2) dot_prod.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return dot_prod
def mul(self, func_graph, node1, node2): mul = func_graph.newNode(MUL) input1 = mul.getPropertyFromId('a', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, mul, input1) input2 = mul.getPropertyFromId('b', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, mul, input2) mul.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return mul
def add(self, func_graph, node1, node2): add = func_graph.newNode(ADD) input1 = add.getPropertyFromId('a', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, add, input1) input2 = add.getPropertyFromId('b', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, add, input2) add.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return add
def div(self, func_graph, node1, node2): div = func_graph.newNode(DIV) input1 = div.getPropertyFromId('a', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, div, input1) input2 = div.getPropertyFromId('b', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, div, input2) div.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return div
def render(self, util, graph_pos: float2): pixel_processor = util.pixel_processor(graph_pos) perpixel_prop = pixel_processor.getPropertyFromId('perpixel', SDPropertyCategory.Input) func_graph = pixel_processor.newPropertyGraph(perpixel_prop, 'SDSBSFunctionGraph') bg = util.const_float1(func_graph, 0) current_image = bg for i in range(0, len(self.state)): c = self.state[i] new_image = self.__render_command(util, func_graph, c, current_image, float2(450, i*100)) if new_image is not None: current_image = new_image func_graph.setOutputNode(current_image, True) return pixel_processor
def subtract(self, func_graph, node1, node2): sub = func_graph.newNode(SUBTRACT) input1 = sub.getPropertyFromId('a', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, sub, input1) input2 = sub.getPropertyFromId('b', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, sub, input2) sub.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return sub
def setNewNodePosition(self): self.sels = self.UIMgr.getCurrentGraphSelection() if self.newNode: if len(self.sels) < 1: self._setNewNodeToMousePos() elif len(self.sels) == 1: sel = self.sels[0] selNodePos = sel.getPosition() if self.newNode: self.newNode.setPosition( float2(selNodePos[0] + self.rightOffset, selNodePos[1])) elif len(self.sels) > 1: firstTwoNodes = [self.sels[0], self.sels[1]] rightNode = self._getNodeOnRight(firstTwoNodes) posX = rightNode.getPosition()[0] + self.rightOffset yTotal = 0 for node in firstTwoNodes: yTotal += node.getPosition()[1] posY = yTotal / len(firstTwoNodes) self.newNode.setPosition(float2(posX, posY))
def ifelse(self, func_graph, condition_node, node1, node2): ifelse = func_graph.newNode(IFELSE) input = ifelse.getPropertyFromId('condition', SDPropertyCategory.Input) output = condition_node.getProperties(SDPropertyCategory.Output)[0] condition_node.newPropertyConnection(output, ifelse, input) input1 = ifelse.getPropertyFromId('ifpath', SDPropertyCategory.Input) output1 = node1.getProperties(SDPropertyCategory.Output)[0] node1.newPropertyConnection(output1, ifelse, input1) input2 = ifelse.getPropertyFromId('elsepath', SDPropertyCategory.Input) output2 = node2.getProperties(SDPropertyCategory.Output)[0] node2.newPropertyConnection(output2, ifelse, input2) ifelse.setPosition(float2(max(node1.getPosition().x, node2.getPosition().x) + 150, (node1.getPosition().y + node2.getPosition().y) / 2)) return ifelse
def align_nodes(self): nodes = self.graph.getNodes() self.align_queue.clear() node: sd.api.SDNode output_nodes = self.graph.getOutputNodes() output_node_id = "" if len(output_nodes): output_node: sd.api.SDNode = output_nodes[0] output_node_id = output_node.getIdentifier() for node in nodes: out_property: sd.api.SDProperty = node.getPropertyFromId( output_id, sd.api.sdproperty.SDPropertyCategory.Output) is_output_connected = False if out_property: out_connections = node.getPropertyConnections(out_property) if len(out_connections): is_output_connected = True is_output_node = node.getIdentifier() == output_node_id if (not isinstance(node, sd.api.SDGraphObject) and not is_output_connected) or is_output_node: self.add_node_to_aligh_queue(node, 0) self.align_queue = [l for l in self.align_queue if len(l)] max_rows = len(max(self.align_queue, key=lambda l: len(l))) grid_size_h = grid_size * 1.3 graph_height = max_rows * grid_size graph_width = len(self.align_queue) * grid_size_h for col_index, col_nodes in enumerate(self.align_queue): col_x = graph_width - (col_index + 1) * grid_size_h col_y = graph_height / 2.0 - len(col_nodes) / 2.0 * grid_size for row_index, node in enumerate(col_nodes): node.setPosition(float2(col_x, col_y + row_index * grid_size))
def alignSDNodes(aSDNodes, aAlignDirection=AlignmentDirection.Horizontal, aSDNodeSpace=graphgrid.GraphGrid.sGetFirstLevelSize()): """ Align the specified SDNodes :param aSDNodes: A list of SDNode objects :param aAlignDirection: The alignment direction :param aSDNodeSpace: The space between nodes :return: None """ class NodeInfo: def __init__(self, aSDNode, aPosition): self.mSDNode = aSDNode self.mPosition = aPosition if not aSDNodes or len(aSDNodes) < 2: return # Collect node info # Find top most Node nodeInfoList = [] for sdNode in aSDNodes: nodePos = sdNode.getPosition() nodeInfoList.append(NodeInfo(sdNode, nodePos)) if aAlignDirection == AlignmentDirection.Horizontal: dirComponentIndex = 0 # X else: dirComponentIndex = 1 # Y oppositeDirComponentIndex = 1 - dirComponentIndex # Sort along the opposite axis nodeInfoList = sorted( nodeInfoList, key=lambda nodeInfo: nodeInfo.mPosition[oppositeDirComponentIndex]) # Get the mean value of X vMin = nodeInfoList[0].mPosition[oppositeDirComponentIndex] vMax = vMin i = 1 while i < len(nodeInfoList): v = nodeInfoList[i].mPosition[oppositeDirComponentIndex] if v < vMin: vMin = v elif v > vMax: vMax = v i = i + 1 vPos = (vMin + vMax) / 2.0 # Change positions # Sort along the opposite axis nodeInfoList = sorted( nodeInfoList, key=lambda nodeInfo: nodeInfo.mPosition[dirComponentIndex]) reverseIteration = False graphDirectionLeftToRight = True # TODO: expose as argument if aAlignDirection == AlignmentDirection.Horizontal: if graphDirectionLeftToRight: reverseIteration = True nodeCount = len(nodeInfoList) if reverseIteration: nodeInfoStartIndex = nodeCount - 1 nodeInfoLastIndex = 0 nodeInfoIndexIncrement = -1 directionFactor = -1 else: nodeInfoStartIndex = 0 nodeInfoLastIndex = nodeCount - 1 nodeInfoIndexIncrement = 1 directionFactor = 1 nodeInfoIndex = nodeInfoStartIndex while nodeInfoIndex != (nodeInfoLastIndex + nodeInfoIndexIncrement): if aAlignDirection == AlignmentDirection.Horizontal: newPosition = [nodeInfoList[nodeInfoIndex].mPosition[0], vPos] else: newPosition = [vPos, nodeInfoList[nodeInfoIndex].mPosition[1]] nodeInfoList[nodeInfoIndex].mSDNode.setPosition( float2(newPosition[0], newPosition[1])) nodeInfoIndex = nodeInfoIndex + nodeInfoIndexIncrement return True
def runTest(self): context = sd.getContext() srcPackageFileName = '2_sbs_graphs.sbs' sdPackage = tools.loadSDPackage(context, srcPackageFileName) self.assertTrue(sdPackage, 'Fail to load package') filePath = sdPackage.getFilePath() self.assertEqual(os.path.split(filePath)[1], srcPackageFileName, 'Fail to load package') sdResourceArray = sdPackage.getChildrenResources(True) self.assertTrue(sdResourceArray) # self.assertTrue(len(sbsGraphArray) == 2) sdGraphIndex = -1 tab = '\t' for sdResource in sdResourceArray: sdResourceIdentifier = sdResource.getIdentifier() # Check if the resource is a SDGraph if not issubclass(type(sdResource), sdgraph.SDGraph): continue sdGraphIndex = sdGraphIndex + 1 sdNodeArray = sdResource.getNodes() self.assertTrue(sdNodeArray, 'Fail to get Nodes from SD Graph') sdNodeArraySize = len(sdNodeArray) if sdGraphIndex == 0: self.assertEqual(sdResourceIdentifier, 'myGraph1', 'Graph identifier comparison failed') self.assertEqual(sdNodeArraySize, 7, 'Invalid Node count') elif sdGraphIndex == 1: self.assertEqual(sdResourceIdentifier, 'mySubGraph2', 'Graph identifier comparison failed') self.assertEqual(sdNodeArraySize, 5, 'Invalid Node count') # put nodes horizontally for sdNode in sdNodeArray: pos = sdNode.getPosition() self.assertTrue(pos, 'Fail to get node Position') # Check node position modification newPosX = 1234 newPosY = -654 sdNode.setPosition(float2(newPosX, newPosY)) pos = sdNode.getPosition() self.assertTrue(pos, 'Fail to get node Position') self.assertEqual(pos.x, newPosX, 'Node Position X has not been set correctly') self.assertEqual(pos.y, newPosY, 'Node Position Y has not been set correctly') nodeDefinition = sdNode.getDefinition() inputProperties = nodeDefinition.getProperties(sdproperty.SDPropertyCategory.Input) logging.debug(tab + 'Node: ') for sdProperty in inputProperties: name = sdProperty.getId() sdType = sdProperty.getType() category = sdProperty.getCategory() logging.debug(tab*2 + '"%s" : "%s" (%s)' % (name, sdType.getId(), str(category))) self.assertTrue(name, 'Empty property name') # self.assertTrue(sdType, 'Empty property sdType for "' + name +'"') outputProperties = nodeDefinition.getProperties(sdproperty.SDPropertyCategory.Output) logging.debug(tab + 'Node: ') for sdProperty in outputProperties: name = sdProperty.getId() sdType = sdProperty.getType() category = sdProperty.getCategory() logging.debug(tab*2 + '"%s" : "%s" (%s)' % (name, sdType.getId(), str(category))) self.assertTrue(name, 'Empty property name') # self.assertTrue(sdType, 'Empty property sdType for "' + name +'"') # Save package to new file dstFileAbsPath = os.path.join(tools.getTestOutputDir(__file__), 'output.sbs') context.getSDApplication().getPackageMgr().savePackageAs(sdPackage, dstFileAbsPath)
def set_new_node_position(self, node: sd.api.SDNode): node.setPosition(float2(self.node_pos_x, self.node_pos_y)) self.node_pos_y += grid_size if self.node_pos_y >= grid_size * max_nodes_in_row: self.node_pos_x += grid_size self.node_pos_y = 0
def __init__(self, initiator, angle_change, forward_dist, thickness, rules): self.state = initiator self.angle_change = angle_change self.turtle_state = TurtleState(0.0, float2(0.5, 0.5), forward_dist, thickness) self.turtle_states = [] self.rules = [self.__parse_rule(rule) for rule in rules]
def addNode(item): ctx, app, uiMgr = getQt() cGridSize = GraphGrid.sGetFirstLevelSize() try: graph = uiMgr.getCurrentGraph() except: print("ERROR: No graph active") return if item["type"] == "NODE": node = graph.newNode(item['src']) else: url = item['src'] pkgMgr = app.getPackageMgr() pkg = pkgMgr.loadUserPackage(item["file"]) resource = pkg.findResourceFromUrl(url.split("?")[0]) print(item["file"], resource, url.split("?")[0]) node = graph.newInstanceNode(resource) #pkgMgr.unloadUserPackage(pkg) for prop in item['props']: value = None if prop["type"] == 'int': value = SDValueInt.sNew(prop["value"]) elif prop["type"] == 'int2': value = SDValueInt2.sNew(int2(prop["value"][0], prop["value"][1])) elif prop["type"] == 'int3': value = SDValueInt3.sNew( int3(prop["value"][0], prop["value"][1], prop["value"][2])) elif prop["type"] == 'int4': value = SDValueInt4.sNew( int4(prop["value"][0], prop["value"][1], prop["value"][2], prop["value"][3])) elif prop["type"] == 'float': value = SDValueFloat.sNew(prop["value"]) elif prop["type"] == 'float2': value = SDValueFloat2.sNew( float2(prop["value"][0], prop["value"][1])) elif prop["type"] == 'float3': value = SDValueFloat3.sNew( float3(prop["value"][0], prop["value"][1], prop["value"][2])) elif prop["type"] == 'float4': value = SDValueFloat4.sNew( float4(prop["value"][0], prop["value"][1], prop["value"][2], prop["value"][3])) elif prop["type"] == 'bool': value = SDValueBool.sNew(prop["value"]) elif prop["type"] == 'enum': value = SDValueInt.sNew(prop["value"]) if value is not None: if prop["inheritance"] != -1: inheritance = SDPropertyInheritanceMethod.RelativeToInput if prop['inheritance'] == 1: inheritance = SDPropertyInheritanceMethod.RelativeToParent elif prop['inheritance'] == 2: inheritance = SDPropertyInheritanceMethod.Absolute node.setInputPropertyInheritanceMethodFromId( prop["id"], inheritance) node.setInputPropertyValueFromId(prop["id"], value) selection = uiMgr.getCurrentGraphSelection() if len(selection) > 0: origin = getOrigin(selection) node.setPosition(float2(origin[0] + cGridSize * 1.5, origin[1]))
def _moveNode(self, node, vector): origPos = node.getPosition() node.setPosition(float2(origPos[0] + vector[0], origPos[1] + vector[1]))