def getPresetDesc(path):
fileContents = ""
with open(ks.getCoreClient().DFG.host.getPresetImportPathname(path), 'r') as presetFile:
fileContents = presetFile.read()
fileContents = "".join(fileContents.split('\n'))
fileContents = "".join(fileContents.split('\r'))
fileContents = " ".join(fileContents.split('\t'))
return json.loads(fileContents)
def getPresetDesc(path):
fileContents = ""
with open(
ks.getCoreClient().DFG.host.getPresetImportPathname(path),
'r') as presetFile:
fileContents = presetFile.read()
fileContents = "".join(fileContents.split('\n'))
fileContents = "".join(fileContents.split('\r'))
fileContents = " ".join(fileContents.split('\t'))
return json.loads(fileContents)
def computeCurrentPortValue(self, node, port):
client = ks.getCoreClient()
tempPort = self.getOrCreateArgument("temp", portType="Out")
self.connectArg(node, port, tempPort)
errors = json.loads(self.__dfgBinding.getErrors(True))
if errors and len(errors) > 0:
raise Exception(str(errors))
self.__dfgBinding.execute()
value = self.__dfgBinding.getArgValue(tempPort)
self.removeArgument(tempPort)
return value
def __init__(self):
super(GraphManager, self).__init__()
client = ks.getCoreClient()
ks.loadExtension('KrakenForCanvas')
self.__dfgHost = client.getDFGHost()
self.__dfgBinding = self.__dfgHost.createBindingToNewGraph()
self.__dfgExec = self.__dfgBinding.getExec()
self.__dfgArgs = {}
self.__dfgNodes = {}
self.__dfgNodeAndPortMap = {}
self.__dfgConnections = {}
self.__dfgGroups = {}
self.__dfgGroupNames = []
self.__dfgCurrentGroup = None
def computeCurrentPortValue(self, node, port):
client = ks.getCoreClient()
tempPort = self.getOrCreateArgument("temp", portType="Out")
self.connectArg(node, port, tempPort)
errors = json.loads(self.__dfgBinding.getErrors(True))
if errors and len(errors) > 0:
raise Exception(str(errors))
self.__dfgBinding.execute()
value = self.__dfgBinding.getArgValue(tempPort)
self.removeArgument(tempPort)
return value
def __init__(self):
super(GraphManager, self).__init__()
client = ks.getCoreClient()
ks.loadExtension('KrakenForCanvas')
self.__dfgHost = client.getDFGHost()
self.__dfgBinding = self.__dfgHost.createBindingToNewGraph()
self.__dfgExec = self.__dfgBinding.getExec()
self.__dfgArgs = {}
self.__dfgNodes = {}
self.__dfgNodeAndPortMap = {}
self.__dfgConnections = {}
self.__dfgGroups = {}
self.__dfgGroupNames = []
self.__dfgCurrentGroup = None
def getOrCreateArgument(self, name, dataType=None, defaultValue=None, portType="In"):
if self.__dfgArgs.has_key(name):
return self.__dfgArgs[name]
client = ks.getCoreClient()
dfgPortType = client.DFG.PortTypes.In
if portType.lower() == 'out':
dfgPortType = client.DFG.PortTypes.Out
elif portType.lower() == 'io':
dfgPortType = client.DFG.PortTypes.IO
self.__dfgArgs[name] = self.__dfgExec.addExecPort(name, dfgPortType)
if dataType:
self.__dfgBinding.setArgValue(self.__dfgArgs[name], ks.rtVal(dataType, defaultValue))
return self.__dfgArgs[name]
def collectResultPorts(self, arg, cls, dataType = 'Xfo'):
drivers = []
driversHit = {}
pairs = self.getDCCSceneItemPairs()
for pair in pairs:
driver = pair['src']
if driversHit.has_key(driver.getPath()):
continue
if not isinstance(driver, cls):
continue
drivers.append(driver)
driversHit[driver.getPath()] = driver
if len(drivers) == 0:
return None
client = ks.getCoreClient()
collectNode = self.rigGraph.createFunctionNode('collectors', title='collect'+arg.capitalize())
subExec = self.rigGraph.getSubExec(collectNode)
resultPort = subExec.addExecPort('result', client.DFG.PortTypes.Out)
subExec.setExecPortTypeSpec(resultPort, '%s[String]' % dataType)
driverMap = {}
code = []
for driver in drivers:
driverName = str(driver.getName())
driverPort = subExec.addExecPort(driverName, client.DFG.PortTypes.In)
driverMap[driver.getPath()] = driverPort
(node, port) = self.rigGraph.getNodeAndPortSI(driver, asInput=False)
resolvedType = self.rigGraph.getNodePortResolvedType(node, port)
if resolvedType:
subExec.setExecPortTypeSpec(driverPort, resolvedType)
code += [' %s["%s"] = %s;' % (resultPort, driver.getPath(), driverPort)]
subExec.setCode('dfgEntry {\n%s}\n' % '\n'.join(code))
for driver in drivers:
(node, port) = self.rigGraph.getNodeAndPortSI(driver, asInput=False)
self.rigGraph.connectNodes(node, port, collectNode, driverMap[driver.getPath()])
self.rigGraph.connectArg(collectNode, 'result', arg)
def getOrCreateArgument(self,
name,
dataType=None,
defaultValue=None,
portType="In"):
if self.__dfgArgs.has_key(name):
return self.__dfgArgs[name]
client = ks.getCoreClient()
dfgPortType = client.DFG.PortTypes.In
if portType.lower() == 'out':
dfgPortType = client.DFG.PortTypes.Out
elif portType.lower() == 'io':
dfgPortType = client.DFG.PortTypes.IO
self.__dfgArgs[name] = self.__dfgExec.addExecPort(name, dfgPortType)
if dataType:
self.__dfgBinding.setArgValue(self.__dfgArgs[name],
ks.rtVal(dataType, defaultValue))
return self.__dfgArgs[name]
def __init__(self, name, canvasPresetPath):
super(CanvasOperator, self).__init__(name)
self.canvasPresetPath = canvasPresetPath
host = ks.getCoreClient().DFG.host
self.binding = host.createBindingToPreset(self.canvasPresetPath)
self.node = self.binding.getExec()
portTypeMap = {
0: 'In',
1: 'IO',
2: 'Out'
}
# ownerOutPortData = {
# 'name': None,
# 'typeSpec': None,
# 'execPortType': None
# }
# Initialize the inputs and outputs based on the given args.
for i in xrange(self.node.getExecPortCount()):
portName = self.node.getExecPortName(i)
portConnectionType = portTypeMap[self.node.getExecPortType(i)]
rtVal = self.binding.getArgValue(portName)
portDataType = rtVal.getTypeName().getSimpleType()
if portConnectionType == 'In':
if portDataType.endswith('[]'):
self.inputs[portName] = []
else:
self.inputs[portName] = None
else:
if portDataType.endswith('[]'):
self.outputs[portName] = []
else:
self.outputs[portName] = None
def evaluate(self):
"""invokes the Canvas node causing the output values to be computed.
Returns:
bool: True if successful.
"""
def getRTVal(obj):
if isinstance(obj, Object3D):
return obj.xfo.getRTVal().toMat44('Mat44')
elif isinstance(obj, Attribute):
return obj.getRTVal()
portVals = []
for port in self.graphDesc['ports']:
portName = port['name']
portConnectionType = port['execPortType']
portDataType = port['typeSpec']
if portDataType == '$TYPE$':
return
if portDataType == 'EvalContext':
portVals.append(ks.constructRTVal(portDataType))
continue
if portName == 'time':
portVals.append(ks.constructRTVal(portDataType))
continue
if portName == 'frame':
portVals.append(ks.constructRTVal(portDataType))
continue
if portConnectionType == 'In':
if str(portDataType).endswith('[]'):
rtValArray = ks.rtVal(portDataType[:-2]+'Array')
rtValArray.resize(len(self.inputs[portName]))
for j in xrange(len(self.inputs[portName])):
rtValArray[j] = getRTVal(self.inputs[portName][j])
portVals.append(rtValArray)
else:
portVals.append(getRTVal(self.inputs[portName]))
else:
if str(portDataType).endswith('[]'):
rtValArray = ks.rtVal(portDataType[:-2]+'Array')
rtValArray.resize(len(self.outputs[portName]))
for j in xrange(len(self.outputs[portName])):
rtValArray[j] = getRTVal(self.outputs[portName][j])
portVals.append(rtValArray)
else:
portVals.append(getRTVal(self.outputs[portName]))
host = ks.getCoreClient().DFG.host
binding = host.createBindingToPreset(self.canvasPresetPath, portVals)
binding.execute()
# Now put the computed values out to the connected output objects.
def setRTVal(obj, rtval):
if isinstance(obj, Object3D):
obj.xfo.setFromMat44(Mat44(rtval))
elif isinstance(obj, Attribute):
obj.setValue(rtval)
for port in self.graphDesc['ports']:
portName = port['name']
portConnectionType = port['execPortType']
portDataType = '$TYPE$'
if portConnectionType != 'In':
outVal = binding.getArgValue(portName)
if portDataType.endswith('[]'):
for j in xrange(len(outVal)):
setRTVal(self.outputs[portName][j], outVal[j])
else:
setRTVal(self.outputs[portName], outVal)
return True
def buildKLOperator(self, kOperator):
"""Builds Splice Operators on the components.
Args:
kOperator (Object): Kraken operator that represents a Splice operator.
Return:
bool: True if successful.
"""
# create the node
self.report('KLOp '+kOperator.getPath())
self.setCurrentGroupSI(kOperator)
solverTypeName = kOperator.getSolverTypeName()
path = kOperator.getPath()
client = ks.getCoreClient()
constructNode = self.rigGraph.createFunctionNodeSI(kOperator, solverTypeName+'Constructor')
subExec = self.rigGraph.getSubExec(constructNode)
solverPort = subExec.addExecPort("solver", client.DFG.PortTypes.Out)
subExec.setExecPortTypeSpec(solverPort, solverTypeName)
subExec.setCode('dfgEntry { solver = %s(); }' % solverTypeName)
varNode = self.rigGraph.createVariableNodeSI(kOperator, 'solver', solverTypeName, extension=kOperator.getExtension())
self.rigGraph.connectNodes(constructNode, 'solver', varNode, "value")
node = self.rigGraph.createFunctionNodeSI(kOperator, solverTypeName)
self._registerSceneItemPair(kOperator, node)
# set dependencies
self.rigGraph.addExtDep(kOperator.getExtension())
subExec = self.rigGraph.getSubExec(node)
solverPort = subExec.addExecPort("solver", client.DFG.PortTypes.IO)
subExec.setExecPortTypeSpec(solverPort, solverTypeName)
self.rigGraph.connectNodes(varNode, 'value', node, solverPort)
argPorts = {}
arraySizes = {}
args = kOperator.getSolverArgs()
for i in xrange(len(args)):
arg = args[i]
argName = arg.name.getSimpleType()
argDataType = arg.dataType.getSimpleType()
argConnectionType = arg.connectionType.getSimpleType()
argPort = None
if argConnectionType == 'In':
argPort = subExec.addExecPort(argName, client.DFG.PortTypes.In)
else:
argPort = subExec.addExecPort(argName, client.DFG.PortTypes.Out)
argPorts[argName] = argPort
subExec.setExecPortTypeSpec(argPort, argDataType)
if argDataType == 'EvalContext':
continue
if argName == 'time' and argConnectionType == 'In':
self.arg.connectArg("time", node, argPort)
continue
if argName == 'frame'and argConnectionType == 'In':
self.arg.connectArg("frame", node, argPort)
continue
# Get the argument's input from the DCC
if argConnectionType == 'In':
connectedObjects = kOperator.getInput(argName)
elif argConnectionType in ['IO', 'Out']:
connectedObjects = kOperator.getOutput(argName)
self.connectCanvasOperatorPort(kOperator, node, argPort, argDataType, argConnectionType, connectedObjects, arraySizes)
opSourceCode = kOperator.generateSourceCode(arraySizes=arraySizes)
funcExec = self.rigGraph.getSubExec(node)
funcExec.setCode(opSourceCode)
return False
def _postBuild(self):
"""Post-Build commands.
Return:
bool: True if successful.
"""
client = ks.getCoreClient()
self.rigGraph.setCurrentGroup(None)
if self.rigGraph.hasArgument('all'):
self.collectResultPorts('all', Object3D, 'Xfo')
if self.rigGraph.hasArgument('joints'):
self.collectResultPorts('joints', Joint, 'Xfo')
if self.hasOption('SetupDebugDrawing'):
client = ks.getCoreClient()
handleArg = self.rigGraph.getOrCreateArgument('handle', dataType='DrawingHandle', portType='Out')
# draw the lines
if self.__dfgLastLinesNode:
preset = "Fabric.Exts.InlineDrawing.DrawingHandle.EmptyDrawingHandle"
handleNode = self.rigGraph.createNodeFromPreset('drawing', preset, title='handle')
preset = "Fabric.Exts.InlineDrawing.DrawingHandle.DrawColoredLines"
drawNode = self.rigGraph.createNodeFromPreset('drawing', preset, title='drawLines')
preset = "Fabric.Core.Control.If"
ifNode = self.rigGraph.createNodeFromPreset('drawing', preset, title='if')
self.rigGraph.connectNodes(handleNode, 'handle', drawNode, "this")
self.rigGraph.connectNodes(ifNode, 'result', drawNode, "lines")
self.rigGraph.connectArg(drawNode, "this", handleArg)
(linesNode, linesPort) = self.__dfgLastLinesNode
self.rigGraph.connectNodes(linesNode, linesPort, ifNode, "if_true")
self.rigGraph.connectArg('debugDraw', ifNode, 'cond')
# perform layout based on reingold tilford
nodes = self.rigGraph.getAllNodeNames()
nodeConnections = self.rigGraph.getAllNodeConnections()
depth = {}
height = {}
for n in nodes:
depth[n] = 0
changed = True
while changed:
changed = False
# forward
for n in nodes:
connections = nodeConnections.get(n, [])
for c in connections:
if depth[c] <= depth[n]:
depth[c] = depth[n] + 1
changed = True
# backward
for n in nodes:
connections = nodeConnections.get(n, [])
minDiff = 0
for c in connections:
diff = depth[c] - depth[n]
if diff < minDiff or minDiff == 0:
minDiff = diff
if minDiff > 1:
depth[n] = depth[n] + minDiff - 1
rows = []
maxPortsPerRow = []
for n in depth:
while len(rows) <= depth[n]:
rows += [[]]
maxPortsPerRow += [0]
rows[depth[n]] += [n]
if self.rigGraph.getNumPorts(n) > maxPortsPerRow[depth[n]]:
maxPortsPerRow[depth[n]] = self.rigGraph.getNumPorts(n)
for j in range(len(rows)-1, -1, -1):
row = rows[j]
rowHeights = {}
for i in range(len(row)):
n = row[i]
if j == len(rows)-1:
height[n] = i
continue
connectedNodes = self.rigGraph.getNodeConnections(n)
offset = maxPortsPerRow[j+1]
height[n] = len(rows[j+1]) * + i
for connectedNode in connectedNodes:
h = height[connectedNode] * maxPortsPerRow[j+1]
h = h + self.rigGraph.getMinConnectionPortIndex(n, connectedNode)
if h < height[n]:
height[n] = h
h = height[n]
while rowHeights.has_key(h):
h = h + 1
height[n] = h
rowHeights[height[n]] = True
# normalize the heights
sortedHeights = sorted(rowHeights.keys())
if len(sortedHeights) > 0:
heightLookup = {}
for i in range(len(sortedHeights)):
heightLookup[sortedHeights[i]] = i
for i in range(len(row)):
n = row[i]
height[n] = heightLookup[height[n]]
for n in nodes:
x = float(depth[n]) * 300.0
y = float(height[n]) * 120.0
self.rigGraph.setNodeMetaData(n, 'uiGraphPos', json.dumps({"x": x, "y": y}))
self.rigGraph.setNodeMetaData(n, 'uiCollapsedState', "1")
if self.hasOption('CollapseComponents'):
self.rigGraph.implodeNodesByGroup()
if self.__outputFolder:
folder = os.path.join(self.__outputFolder, self.__rigTitle)
if not os.path.exists(folder):
os.makedirs(folder)
self.rigGraph.saveToFile(os.path.join(folder, 'Rig.canvas'))
self.controlGraph.saveToFile(os.path.join(folder, 'Control.canvas'))
self.attributeGraph.saveToFile(os.path.join(folder, 'Attribute.canvas'))
return True
def evaluate(self):
"""invokes the Canvas node causing the output values to be computed.
Returns:
bool: True if successful.
"""
def getRTVal(obj):
if isinstance(obj, Object3D):
return obj.xfo.getRTVal().toMat44('Mat44')
elif isinstance(obj, Attribute):
return obj.getRTVal()
portVals = []
for port in self.graphDesc['ports']:
portName = port['name']
portConnectionType = port['execPortType']
portDataType = port['typeSpec']
if portDataType == '$TYPE$':
return
if portDataType == 'EvalContext':
portVals.append(ks.constructRTVal(portDataType))
continue
if portName == 'time':
portVals.append(ks.constructRTVal(portDataType))
continue
if portName == 'frame':
portVals.append(ks.constructRTVal(portDataType))
continue
if portConnectionType == 'In':
if str(portDataType).endswith('[]'):
rtValArray = ks.rtVal(portDataType[:-2] + 'Array')
rtValArray.resize(len(self.inputs[portName]))
for j in xrange(len(self.inputs[portName])):
rtValArray[j] = getRTVal(self.inputs[portName][j])
portVals.append(rtValArray)
else:
portVals.append(getRTVal(self.inputs[portName]))
else:
if str(portDataType).endswith('[]'):
rtValArray = ks.rtVal(portDataType[:-2] + 'Array')
rtValArray.resize(len(self.outputs[portName]))
for j in xrange(len(self.outputs[portName])):
rtValArray[j] = getRTVal(self.outputs[portName][j])
portVals.append(rtValArray)
else:
portVals.append(getRTVal(self.outputs[portName]))
host = ks.getCoreClient().DFG.host
binding = host.createBindingToPreset(self.canvasPresetPath, portVals)
binding.execute()
# Now put the computed values out to the connected output objects.
def setRTVal(obj, rtval):
if isinstance(obj, Object3D):
obj.xfo.setFromMat44(Mat44(rtval))
elif isinstance(obj, Attribute):
obj.setValue(rtval)
for port in self.graphDesc['ports']:
portName = port['name']
portConnectionType = port['execPortType']
portDataType = '$TYPE$'
if portConnectionType != 'In':
outVal = binding.getArgValue(portName)
if portDataType.endswith('[]'):
for j in xrange(len(outVal)):
setRTVal(self.outputs[portName][j], outVal[j])
else:
setRTVal(self.outputs[portName], outVal)
return True
