Ejemplo n.º 1
0
def export():
	"""Main export function."""

	is_last = False

	try:
		T = timer('FrameExport')

		ps = soho.evaluate({
			'now':		SohoParm('state:time',			'real', [0],  False, key='now'),
			'fps':		SohoParm('state:fps',			'real', [24],  False, key='fps'),
			'hver':		SohoParm('state:houdiniversion',	'string', [''],  False, key='hver'),
			'objpath':	SohoParm('objpath',		'string',	[''], False),
			'abcoutput':	SohoParm('abcoutput',		'string',	[''], False),
			'camera':	SohoParm('camera',		'string',	[None], False),
			'trange':	SohoParm('trange',		'int',		[0], False),
			'f':		SohoParm('f',			'int',		None, False)
		})
		
		now = ps['now'].Value[0]
		fps = ps['fps'].Value[0]
		hver = ps['hver'].Value[0]
		camera = ps['camera'].Value[0]

		dbg("now=%.3f fps=%.3f" % (now, fps))

		if not soho.initialize(now, camera):
			soho.error("couldn't initialize soho (make sure camera is set)")
			abc_cleanup()
			return

		# NOTE: this is prone to float inaccuracies
		frame = now*fps + 1.0

		objpath   = ps['objpath'].Value[0]
		abc_file  = ps['abcoutput'].Value[0]
		trange    = ps['trange'].Value[0]
		f         = ps['f'].Value

		is_first  = frame < f[0]+0.5 # working around float funniness
		is_last   = frame > f[1]-0.5

		if trange==0:
			is_first= is_last= True

		dbg("is_first=%d is_last=%d" % (is_first, is_last))
		dbg("now=%.3f fps=%.3f -> %f" % (now, fps, frame))

		dbg("objpath=%s camera=%s abcoutput=%s trange=%d f=%s" % \
			(objpath, camera, abc_file, trange, str(f)))

		T.lap('init')

		# collect hierarchy to be exported
		# (read from scene directly, ie. not containing instances, etc.)
		# results in array [ (parentname, objname) [, ...]  ] -- (full pathnames)
		#
		#dbg("COLLECTING ARCHY:")
		archy = collect_archy(objpath)
		archy_objs = [ n[1] for n in archy ]
		#dbg("DONE.")


		# collect geometry to be exported and their render SOPS
		# (including point- and other instances, etc)
		# (NOTE: the entire scene is to be searched, unfortunately)
		#
		soho.addObjects(now, '*', '*', '', do_culling=False)
		soho.lockObjects(now)

		soho_objs = {} # {objname: soho_obj}
		soho_only = {} # soho-only objects (can't be accessed directly with hdk)

		obj_list = []
		sop_dict = {} # {objname: sopname}
		objs = soho.objectList('objlist:instance')

		#dbg("COLLECT soho instance/sop pairs ------------------")
		for obj in objs:
			n = obj.getName() # full pathname
			obj_list.append(n)
			soho_objs[n] = obj
			path = obj.getDefaultedString('object:soppath', now, [None])[0]
			#dbg(" -- %s (sop:%s)" % (n, str(path)) )
			if path and path!="":
				sop_dict[n] = path

		T.lap('collect-objs')

		if False:
			dbg( '-' * 40 )
			dbg("sop_dict: %s" % str(sop_dict))

		# extend hierarchy with per-point instances
		#
		p1 = re.compile(":[^:]+:")
		for obj in obj_list:
			if re.search(p1, obj):
				m = obj.split(":")
				p = m[-2] # parent: 2nd from right
				if p in archy_objs:
					archy.append( ( p, obj, "%s__%s" % (m[-2], m[-1]) )  )
					soho_only[obj]=p
					#dbg(" -+- %s %s" % (p, obj))


		# fill rest of the archy array
		# elem: (parentpath, objpath, exportname, soppath)
		#
		archy2 = []
		for a in archy:
			N = list(a)
			if len(N)<3: N.append(N[1]) # N = [ N[0], N[1], N[1] ]
			if N[1] in sop_dict:
				N = [ N[0], N[1], N[2], sop_dict[N[1]] ]
			else:
				# empty xform (no sop)
				N = [ N[0], N[1], N[1], None ]
			
			N[2] = re.search("[^/]+$", N[2]).group(0)
			archy2.append(N)
		archy = archy2

		if False:
			dbg( '-' * 40 )
			dbg("COLLECTED ARCHY:")
			for a in archy:
				dbg("- %s: " % (a[1], ))

		dbg("COLLECTED ARCHY: %d elems" % len(archy))

		T.lap('got-archy')

		# we now have a list of all objects to be exported
		# (parentname, objname, exportname, soppath)
		#
		archy_objs = [ n[1] for n in archy ]
		skip_frame = False

		now_out = now+(1.0/fps)

		# check for user abort
		#
		if False: # TODO: check for user abort!
			skip_frame = True
			is_last = True
			warn("user abort")


		# first frame: init all internal stuff
		#
		if is_first:
			dbg("\n\n\n")
			dbg("IS_FIRST--INIT")
			G.archy = archy[:]
			G.archy_objs = archy_objs[:]

			s = abc_init(abc_file, tstep=1.0/fps, tstart=now_out)
			if s:
				# build objects for oarchive
				#
				for E in archy:
					objname = E[1]
					parent  = E[0]
					outname = E[2]
					soppath = E[3]
					if parent is None: parent="-"
					if soppath is None: soppath="-"

					# TODO: if instance, objname should be the base obj name
					obj_src = objname
					if objname in soho_only:
						obj_src = soho_only[objname]

					#dbg("-- new xform\n\toutname= %s\n\tobj    = %s\n\tparent = %s\n\tsop    = %s" % (outname, objname, parent, soppath))

					hou.hscript('%s newobject "%s" "%s" "%s" "%s" "%s"' % \
						(CCMD, objname, obj_src, parent, outname, soppath))

					# set object flags (static, etc.)
					#
					if objname in soho_objs:
						ps = soho_objs[objname].evaluate({
							'abc_staticgeo': SohoParm('abc_staticgeo', 'int', [0], False)
						}, now)

						if ps['abc_staticgeo'].Value[0]!=0:
							hou.hscript('%s objset "%s" static' % (CCMD, objname))

			else:
				warn("couldn't output to file %s--aborting" % abc_file)
				skip_frame = True
				is_last = True

		T.lap('frame-first')


		# frame export: collect xforms, geoms, and export them
		#
		if archy_objs==G.archy_objs  and  not skip_frame:

			dbg("\n")
			dbg(" -- EXPORTING frame %.1f" % frame)

			for E in archy:
				#dbg("\n-")
				#dbg("- OBJ: %s" % str(E))
				objname = E[1]
				soppath = E[3]
				#dbg("- OBJ: %s" % E[1])

				# get xform matrix (TODO: get pretransform too!)
				#
				xform = ''

				# TODO: use this only for instances!
				#if objname in soho_objs:
				if objname in soho_only:
					# get matrix from soho
					#dbg(" --- (mtx from soho)")
					xform = []
					soho_objs[objname].evalFloat('space:local', now, xform)
					xform = hou.Matrix4(xform)
					xform = ' '.join([ str(n) for n in xform.asTuple() ])

				# perform sample write
				# (c++ code decides if geom is to be written)
				#
				if True:
					hou.hscript('%s writesample %f "%s" %s' % \
						(CCMD, now_out, objname, xform))

		else:
			#soho.error("couldn't export frame %.1f--no. of objects changed" % frame)
			warn("couldn't export frame %.1f--no. of objects changed" % frame)


		T.lap('frame-export')

	except:
		dbg("INTERRUPTED BY EXCEPTION")
		is_last=True


	# last frame: cleanup all internal stuff,
	# finish export
	#
	if is_last:
		dbg("\n\n\n")
		dbg("IS_LAST--FINISHING...")
		abc_cleanup()

	T.lap('frame-last')

	T.stats()
Ejemplo n.º 2
0
def main():
    import sys
    import hou

    import soho
    import sohoglue
    import SOHOcommon

    import sys
    import ctypes
    if hasattr(sys, 'setdlopenflags'):
        sys.setdlopenflags(sys.getdlopenflags() | ctypes.RTLD_GLOBAL)

    import _vfh_ipr

    from soho import SohoParm

    LogLevel = type('Enum', (), {
        'Info': 0,
        'Progress': 1,
        'Warning': 2,
        'Error': 3,
        'Debug': 4,
    })

    def logMessage(level, fmt, *args):
        _vfh_ipr.logMessage(level, fmt % args)

    def printDebug(fmt, *args):
        logMessage(LogLevel.Debug, fmt, *args)

    def dumpObjects(listName):
        printDebug("Checking \"%s\"" % listName)
        for obj in soho.objectList(listName):
            printDebug("   %s", obj.getName())

    def exportObjects(listName):
        for obj in soho.objectList(listName):
            _vfh_ipr.exportOpNode(opNode=obj.getName())

    def deleteObjects(listName):
        for obj in soho.objectList(listName):
            _vfh_ipr.deleteOpNode(opNode=obj.getName())

    def getViewParams(camera, sohoCam, t):
        camParms = {
            'space:world': SohoParm('space:world', 'real', [], False),
            'focal': SohoParm('focal', 'real', [0.050], False),
            'aperture': SohoParm('aperture', 'real', [0.0414214], False),
            'orthowidth': SohoParm('orthowidth', 'real', [2], False),
            'near': SohoParm('near', 'real', [0.001], False),
            'far': SohoParm('far', 'real', [1000], False),
            'res': SohoParm('res', 'int', [640, 480], False),
            'projection': SohoParm('projection', 'string', ["perspective"],
                                   False),
            'cropl': SohoParm('cropl', 'real', [-1], False),
            'cropr': SohoParm('cropr', 'real', [-1], False),
            'cropb': SohoParm('cropb', 'real', [-1], False),
            'cropt': SohoParm('cropt', 'real', [-1], False),
            'camera': SohoParm('camera', 'string', ['/obj/cam1'], False),
        }

        camParmsEval = sohoCam.evaluate(camParms, t)
        if not camParmsEval:
            return {}

        viewParams = {}
        for key in camParmsEval:
            viewParams[key] = camParmsEval[key].Value[0]

        viewParams['transform'] = camParmsEval['space:world'].Value
        viewParams['ortho'] = 1 if camParmsEval['projection'].Value[0] in {
            'ortho'
        } else 0
        viewParams['res'] = camParmsEval['res'].Value

        cropX = viewParams['res'][0] * viewParams['cropl']
        cropY = viewParams['res'][1] * (1.0 - viewParams['cropt'])
        cropW = viewParams['res'][0] * (viewParams['cropr'] -
                                        viewParams['cropl'])
        cropH = viewParams['res'][1] * (viewParams['cropt'] -
                                        viewParams['cropb'])

        printDebug("  Res: %s" % viewParams['res'])
        printDebug("  Crop: %i-%i %i x %i" % (cropX, cropY, cropW, cropH))
        printDebug("  Camera: %s" % camera)

        return viewParams

    def exportView(rop, camera, sohoCam, t):
        printDebug("exportView()")

        _vfh_ipr.exportView(viewParams=getViewParams(camera, sohoCam, t))

    mode = soho.getDefaultedString('state:previewmode', ['default'])[0]

    # Evaluate an intrinsic parameter (see HDK_SOHO_API::evaluate())
    # The 'state:time' parameter evaluates the time from the ROP.
    now = soho.getDefaultedFloat('state:time', [0.0])[0]

    # Evaluate the 'camera' parameter as a string.
    # If the 'camera' parameter doesn't exist, use ['/obj/cam1'].
    # SOHO always returns lists of values.
    camera = soho.getDefaultedString('camera', ['/obj/cam1'])[0]

    # MPlay / Render View port.
    host = soho.getDefaultedString("vm_image_mplay_sockethost", [0])[0]
    port = soho.getDefaultedInt("vm_image_mplay_socketport", [0])[0]

    # ROP node.
    ropPath = soho.getOutputDriver().getName()
    ropNode = hou.node(ropPath)

    printDebug("Initialize SOHO...")

    # Initialize SOHO with the camera.
    # XXX: This doesn't work for me, but it should according to the documentation...
    #   soho.initialize(now, camera)
    if not sohoglue.initialize(now, camera, None):
        soho.error("Unable to initialize rendering module with given camera")

    # Now, add objects to our scene
    soho.addObjects(now, "*", "*", "*", True)

    # Before we can evaluate the scene from SOHO, we need to lock the object lists.
    soho.lockObjects(now)

    for sohoCam in soho.objectList('objlist:camera'):
        break
    else:
        soho.error("Unable to find viewing camera for render")

    sohoOverride = soho.getDefaultedString('soho_overridefile', ['Unknown'])[0]

    printDebug("Processing Mode: \"%s\"" % mode)

    if mode in {"generate"}:
        # generate: Generation phase of IPR rendering
        # In generate mode, SOHO will keep the pipe (soho_pipecmd)
        # command open between invocations of the soho_program.
        #   objlist:all
        #   objlist:camera
        #   objlist:light
        #   objlist:instance
        #   objlist:fog
        #   objlist:space
        #   objlist:mat
        #
        printDebug("IPR Host: %s:%s" % (host, port))
        printDebug("Driver: %s" % ropPath)
        printDebug("Camera: %s" % camera)
        printDebug("Now: %.3f" % now)

        for obj in soho.objectList('objlist:instance'):
            # Register SOP as IPR dependency.
            obj.getDefaultedString('object:soppath', now, [''])

            # Register SHOP as IPR dependency.
            # TODO: Investigave this. Use OP_Node::addOpInterest() for now.
            # shader = []
            # shader_type   = []
            # shader_handle = []
            # obj.evalShaderAndType("shop_materialpath", now, shader, shader_type, shader_handle)

        _vfh_ipr.init(rop=ropPath,
                      port=port,
                      now=now,
                      viewParams=getViewParams(camera, sohoCam, now))

    elif mode in {"update"}:
        # update: Send updated changes from previous generation
        #
        # In this rendering mode, the special object list parameters:
        #   objlist:dirtyinstance
        #   objlist:dirtylight
        #   objlist:dirtyspace
        #   objlist:dirtyfog
        # will contain the list of all objects modified since the last render
        # (whether a generate or update).
        #
        # As well, the parameters:
        #   objlist:deletedinstance
        #   objlist:deletedlight
        #   objlist:deletedspace
        #   objlist:deletedfog
        # will list all objects which have been deleted from the scene.
        #
        if not _vfh_ipr.isRopValid():
            _vfh_ipr.init(rop=ropPath,
                          port=port,
                          now=now,
                          viewParams=getViewParams(camera, sohoCam, now))
        else:
            # Have to handle "time" event manually here.
            _vfh_ipr.setTime(now)

            for obj in soho.objectList('objlist:dirtyinstance'):
                obj.getDefaultedString('object:soppath', now, [''])

            exportObjects("objlist:dirtyinstance")
            exportObjects("objlist:dirtylight")

            exportView(ropPath, camera, sohoCam, now)
Ejemplo n.º 3
0
def soho_render():
    control_parms = {
        # The time at which the scene is being rendered
        "now": SohoParm("state:time", "real", [0], False, key="now"),
        "camera": SohoParm("camera", "string", ["/obj/cam1"], False),
    }

    parms = soho.evaluate(control_parms)

    now = parms["now"].Value[0]
    camera = parms["camera"].Value[0]

    options = {}
    if not soho.initialize(now, camera, options):
        soho.error("Unable to initialize rendering module with given camera")

    object_selection = {
        # Candidate object selection
        "vobject": SohoParm("vobject", "string", ["*"], False),
        "alights": SohoParm("alights", "string", ["*"], False),
        "forceobject": SohoParm("forceobject", "string", [""], False),
        "forcelights": SohoParm("forcelights", "string", [""], False),
        "excludeobject": SohoParm("excludeobject", "string", [""], False),
        "excludelights": SohoParm("excludelights", "string", [""], False),
        "sololight": SohoParm("sololight", "string", [""], False),
    }

    for cam in soho.objectList("objlist:camera"):
        break
    else:
        soho.error("Unable to find viewing camera for render")

    objparms = cam.evaluate(object_selection, now)

    stdobject = objparms["vobject"].Value[0]
    stdlights = objparms["alights"].Value[0]
    forceobject = objparms["forceobject"].Value[0]
    forcelights = objparms["forcelights"].Value[0]
    excludeobject = objparms["excludeobject"].Value[0]
    excludelights = objparms["excludelights"].Value[0]
    sololight = objparms["sololight"].Value[0]
    forcelightsparm = "forcelights"

    if sololight:
        stdlights = excludelights = ""
        forcelights = sololight
        forcelightsparm = "sololight"

    # First, we add objects based on their display flags or dimmer values
    soho.addObjects(
        now,
        stdobject,
        stdlights,
        "",
        True,
        geo_parm="vobject",
        light_parm="alights",
        fog_parm="",
    )
    soho.addObjects(
        now,
        forceobject,
        forcelights,
        "",
        False,
        geo_parm="forceobject",
        light_parm=forcelightsparm,
        fog_parm="",
    )
    soho.removeObjects(
        now,
        excludeobject,
        excludelights,
        "",
        geo_parm="excludeobject",
        light_parm="excludelights",
        fog_parm="",
    )

    # Lock off the objects we've selected
    soho.lockObjects(now)

    with hou.undos.disabler(), scene_state:
        if "SOHO_PBRT_DEV" in os.environ:  # pragma: no coverage
            import cProfile

            pr = cProfile.Profile()
            pr.enable()
            try:
                PBRTscene.render(cam, now)
            finally:
                pr.disable()
                pr.dump_stats("hou-prbt.stats")
        else:
            PBRTscene.render(cam, now)
    return
Ejemplo n.º 4
0
    'vobject'     : SohoParm('vobject', 'string',       ['*'], False),
    'alights'     : SohoParm('alights', 'string',       ['*'], False),
    'vfog'        : SohoParm('vfog',    'string',       ['*'], False),

    'forceobject' : SohoParm('forceobject',     'string',       [''], False),
    'forcelights' : SohoParm('forcelights',     'string',       [''], False),
    'forcefog'    : SohoParm('forcefog',        'string',       [''], False),

    'excludeobject' : SohoParm('excludeobject', 'string',       [''], False),
    'excludelights' : SohoParm('excludelights', 'string',       [''], False),
    'excludefog'    : SohoParm('excludefog',    'string',       [''], False),

    'sololight'     : SohoParm('sololight',     'string',       [''], False),
}

for cam in soho.objectList('objlist:camera'):
    break
else:
    soho.error("Unable to find viewing camera for render")
    
objparms = cam.evaluate(objectSelection, now)

stdobject = objparms['vobject'].Value[0]
stdlights = objparms['alights'].Value[0]
stdfog = objparms['vfog'].Value[0]
forceobject = objparms['forceobject'].Value[0]
forcelights = objparms['forcelights'].Value[0]
forcefog = objparms['forcefog'].Value[0]
excludeobject = objparms['excludeobject'].Value[0]
excludelights = objparms['excludelights'].Value[0]
excludefog = objparms['excludefog'].Value[0]
Ejemplo n.º 5
0
Archivo: LSD.py Proyecto: cinepost/Lava
    'vobject': SohoParm('vobject', 'string', ['*'], False),
    'alights': SohoParm('alights', 'string', ['*'], False),
    'vfog': SohoParm('vfog', 'string', ['*'], False),
    'forceobject': SohoParm('forceobject', 'string', [''], False),
    'forcelights': SohoParm('forcelights', 'string', [''], False),
    'forcefog': SohoParm('forcefog', 'string', [''], False),
    'excludeobject': SohoParm('excludeobject', 'string', [''], False),
    'excludelights': SohoParm('excludelights', 'string', [''], False),
    'excludefog': SohoParm('excludefog', 'string', [''], False),
    'matte_objects': SohoParm('matte_objects', 'string', [''], False),
    'phantom_objects': SohoParm('phantom_objects', 'string', [''], False),
    'sololight': SohoParm('sololight', 'string', [''], False),
    'lv_cameralist': SohoParm('lv_cameralist', 'string', [''], False),
}

for cam in soho.objectList('objlist:camera'):
    break
else:
    soho.error("Unable to find viewing camera for render")

objparms = cam.evaluate(objectSelection, now)
stdobject = objparms['vobject'].Value[0]
stdlights = objparms['alights'].Value[0]
stdfog = objparms['vfog'].Value[0]
forceobject = objparms['forceobject'].Value[0]
forcelights = objparms['forcelights'].Value[0]
forcefog = objparms['forcefog'].Value[0]
excludeobject = objparms['excludeobject'].Value[0]
excludelights = objparms['excludelights'].Value[0]
excludefog = objparms['excludefog'].Value[0]
sololight = objparms['sololight'].Value[0]
Ejemplo n.º 6
0
	geo_parm='phantom_objects', light_parm='', fog_parm='')
soho.removeObjects(now, excludeobject, excludelights, excludefog,
    geo_parm='excludeobject', light_parm='excludelights', fog_parm='excludefog')

    
# Lock off the objects we've selected
soho.lockObjects(now)

IFDsettings.clearLists()
IFDsettings.load(now)
IFDgeo.reset()

if inheritedproperties:
    # Output object level properties which are defined on the output driver
    ray_comment('Object properties defined on output driver')
    IFDsettings.outputObject(soho.getOutputDriver(), now)


if decl_shops:
    IFDgeo.declareAllMaterials(now, decl_shops > 1)

#
# Output objects
#
IFDframe.outputObjects(now,
    soho.objectList('objlist:instance'),
    soho.objectList('objlist:light'),
    soho.objectList('objlist:space'),
    soho.objectList('objlist:fog'),
    -1, -1)
Ejemplo n.º 7
0
# Evaluate an intrinsic parameter (see HDK_SOHO_API::evaluate())
# The 'state:time' parameter evaluates the time from the ROP.
evaltime = soho.getDefaultedFloat('state:time', [0.0])[0]

# Initialize SOHO with the camera.
if not soho.initialize(evaltime, camera):
    soho.error('Unable to initialize rendering module with camera: %s' %
               repr(camera))

# Now, add objects to our scene
#   addObjects(time, geometry, light, fog, use_display_flags)
soho.addObjects(evaltime, "*", "*", "*", True)

# Before we can evaluate the scene from SOHO, we need to lock the object lists.
soho.lockObjects(evaltime)


# Now, traverse all the objects
def outputObjects(fp, prefix, list):
    fp.write('%s = {' % prefix)
    for obj in list:
        fp.write('"%s",' % obj.getName())
    fp.write('}\n')
    fp.flush()


fp = sys.stdout
outputObjects(fp, 'Geometry', soho.objectList('objlist:instance'))
outputObjects(fp, 'Light', soho.objectList('objlist:light'))
outputObjects(fp, 'Fog', soho.objectList('objlist:fog'))