def parseInterpolate(self, string):
tokens = None
try:
tokens = self.engine.parseString(string)
tokens = tokens.asList()
except ParseException as e:
log.error('Failed to parse scene : {0}', e)
log.error(string)
tokens = tokens[1]
entries = list()
entry = list()
for token in tokens:
if token in ['(', ')']:
if entry:
entries.append(entry)
frame = None
entry = list()
elif frame is None:
frame = token
entry = [frame, list()]
else:
entry[1].append(token)
return entries
def func2():
log.info('func 2')
log.debug('raise in func 2')
try:
func_err()
except Exception:
log.error('ERROR IN FUNC 2', trace=True)
def preRun(self, context):
log.debug2("{0} archiveNode.preRun ...", self.id)
path = self.field('path')
ret = True
if not path:
return False
for token in path.heap(context):
archive = token.value
if not (archive and os.path.exists(archive)):
log.error('Cannot access archive file {0}', archive)
else:
ctx = context.push(self, token)
log.debug2("->" * 20, tags=['stream'])
log.debug2("ARCHIVE SPAWN {0}", ctx, tags=['stream'])
scene = VRScene()
ctx.set('vrscene', scene)
ctx.set('archive', archive)
ret &= self.run(ctx)
ret &= super(archiveNode, self).preRun(context)
log.debug2("... {0} archiveNode.preRun: {1}", self.id, ret)
return ret
def generateVRScene(self, context, vrs):
field = self.field('path')
if (not field) or field.linked:
return True
with NamedTemporaryFile(delete=False, suffix='.vrscene') as temp:
path = temp.name
log.debug2("GENERATE SCENE {0}".format(path))
base = os.path.dirname(path)
if not os.path.exists(base):
os.makedirs(base)
# vrs = self._outScenes[context]
vrs.save(path)
if not os.path.exists(path):
log.error("Failed to generate scene {0}", path)
return False
context.set('vrscene', vrs)
log.debug2("Scene DONE !")
token = Token(path, source=self, index=1, size=1)
field.push(context, token)
return True
def main(engine):
default_nodal = os.path.join(os.getenv("KIT_PATH"), "nodal", "pytest.nod")
nodal = sys.argv[3] if len(sys.argv) > 3 else default_nodal
if not os.path.exists(nodal):
log.error("Cannot access nodal file : {0}", nodal)
sys.exit(1)
def run(self, context):
# log.debug3("{0} vrconcatNode.run ...", self.id)
ret = True
scene = context.get('vrscene')
if not scene:
log.error("Cannot concatenate, context has no scene defined !")
ret = False
else:
'''
if context not in self._outScenes:
print "add scene to outs"
self._outScenes[context] = VRScene()
if context not in self._outPlugins:
print "init plugins dict"
self._outPlugins[context] = dict()
vrs = self._outScenes[context]
'''
vrs = VRScene()
for field in self.getInputs():
if not field.linked:
continue
'''
if field.id not in self._outPlugins[context]:
self._outPlugins[context][field.id] = None
'''
heap = field.heap(context)
if not heap:
print "{0} has no heap".format(field.id)
continue
while heap:
token = heap.pop(0)
if token.isEmpty():
continue
plugin = token.value
msg = "add {0} {1} to vrscene ({2} {3} / {4} - {5})"
msg = msg.format(plugin.getName(), plugin.getType(),
field.fieldId, token.index, token.size,
context.hash)
log.debug2(msg, tags=['run'])
vrs.add(token.value, scene.renderer)
ret = self.generateVRScene(context, vrs)
# log.debug3("{0} vrconcatNode.run: {1}", self.id, ret)
return ret
def parseNested(self, string):
tokens = None
try:
tokens = self.nested.parseString(string)
tokens = tokens.asList()
except ParseException as e:
log.error('Failed to parse scene : {0}', e)
return tokens
def copyPlug(self, p):
r = self.renderer
name = p.getName()
cls = p.getType()
if not hasattr(r.classes, cls):
log.error('Failed to retrieve base class {0}', cls)
return
plug = self.find(name)
if plug is None:
plug = getattr(r.classes, cls)(name)
self.copyProps(p, plug)
self.unqueue(plug)
def preRun(self, context):
log.debug2("... {0} flistNode.preRun", self.id)
folder = self.field('folder')
ret = True
if not folder:
return False
for token in folder.heap(context):
path = token.value
if not os.path.exists(path):
log.error('Cannot access path {0}', path)
else:
ret &= self.run(context.push(token))
ret &= super(flistNode, self).preRun(context)
log.debug2("... {0} flistNode.preRun: {1}", self.id, ret)
return ret
def preRun(self, context):
log.debug2("{0} vrenderNode.preRun ...", self.id)
path = self.field('path')
ret = True
if not path:
return False
for token in path.heap(context):
scene = token.value
if not (scene and os.path.exists(scene)):
log.error('Cannot access vrscene file {0}', scene)
else:
self._scenes.append(scene)
ret &= self.run(context)
ret &= super(vrenderNode, self).preRun(context)
log.debug2("... {0} vrenderNode.preRun: {1}", self.id, ret)
return ret
import os
from cgev.common import log
try:
from .sdk import sdk
except ImportError as e:
log.error("Failed to import vray module : {0}", e)
from cgev.common.core import Inspect
from cgev.common.system import shell
from cgev.common.system import EXEC_MODE
class Scene(object):
def __init__(self, path=None):
object.__init__(self)
sdk.enableFrameBuffer(False)
self.renderer = sdk.VRayRenderer(renderMode='production')
self._path = None
self._queue = list()
self._anims = list()
self._lqueue = list()
if path:
self.load(path)
def __del__(self):
self.release()
import fnmatch
import random
from cgev.common import log
from cgev.common.graph import Token
try:
import vray
except ImportError:
log.error("Cannot import vray python module.")
from cgev.common.graph import Node
class scatterNode(Node):
def preRun(self, context):
if not hasattr(self, "grid"):
self.grid = list()
return self.run(context)
def runCleanup(self):
self.grid = list()
super(scatterNode, self).runCleanup()
def run(self, context):
plug1 = self.field("in1")
plug2 = self.field("in2")
out = self.field("out")
grid = self.field("grid")
scale = self.field("scale")
def callErr():
log.error('error message with trace {0} {trace}', 13, trace='hoho')
try:
raiseErr('yoooo')
except RuntimeError as e:
log.error('traced error message {0} {err}', 666, err=e, trace=True)
def callOk():
log.error('simple error message {0} {name}', 42, name="plop")
import fnmatch
from cgev.common import log
try:
import vray
except ImportError:
log.error('Cannot import vray python module.')
from cgev.common.graph import Node
class vroverNode(Node):
def preRun(self, context):
return self.run(context)
def run(self, context):
plug = self.field('in')
out = self.field('out')
filter = self.field('filter').value
if not (plug and out and filter):
return False
for token in plug.heap(context):
plugin = token.value
if fnmatch.fnmatch(plugin.getName(), filter):
self.override(plugin)
out.push(context, token)
import glob
import random
from PySide import QtCore, QtGui
from cgev.common import log
from cgev.ui.graph import NODE_LOD
from cgev.ui.graph import NODE_LODS
try:
import vray
except Exception as e:
log.error("VRay SDK import error : {0}", e)
from cgev.ui.graph.node import Node
from cgev.vray import VRScene
from vrenderNode import vrenderNode
root = "C:/work/vray3sdk/scenes"
scenes = glob.glob(root + "/*.vrscene")
avoid = ["bad", "RT"]
for tok in avoid:
scenes = [s for s in scenes if tok not in s]
class vrenderUi(Node, vrenderNode):
def __init__(self, scene, parent, entry=None):
self.viewer = None
