def init_state(self):
     """Queries Soho to initialize the attributes of the class"""
     state_parms = {
         "rop": soho.SohoParm("object:name", "string", key="rop"),
         "soho_outputmode": soho.SohoParm(
             "soho_outputmode", "integer", skipdefault=False, key="output_mode"
         ),
         "soho_diskfile": soho.SohoParm(
             "soho_diskfile", "string", skipdefault=False, key="disk_file"
         ),
         "hip": soho.SohoParm("$HIP", "string", key="hip"),
         "hipname": soho.SohoParm("$HIPNAME", "string", key="hipname"),
         "hipfile": soho.SohoParm("$HIPFILE", "string", key="hipfile"),
         "ver": soho.SohoParm(
             "state:houdiniversion", "string", ["9.0"], False, key="ver"
         ),
         "now": soho.SohoParm("state:time", "real", [0], False, key="now"),
         "fps": soho.SohoParm("state:fps", "real", [24], False, key="fps"),
         "pbrt_nanovdb_converter": soho.SohoParm(
             "pbrt_nanovdb_converter",
             "string",
             ["nanovdb_convert -z -f {vdb} {nanovdb}"],
             False,
             key="nanovdb_converter",
         ),
     }
     rop = soho.getOutputDriver()
     parms = soho.evaluate(state_parms, None, rop)
     for parm in parms:
         setattr(self, parm, parms[parm].Value[0])
     if not self.fps:
         self.fps = 24.0
     self.inv_fps = 1.0 / self.fps
     return
Exemple #2
0
 def init_state(self):
     """Queries Soho to initialize the attributes of the class"""
     state_parms = {
         "rop":
         soho.SohoParm("object:name", "string", key="rop"),
         "hip":
         soho.SohoParm("$HIP", "string", key="hip"),
         "hipname":
         soho.SohoParm("$HIPNAME", "string", key="hipname"),
         "hipfile":
         soho.SohoParm("$HIPFILE", "string", key="hipfile"),
         "ver":
         soho.SohoParm("state:houdiniversion",
                       "string", ["9.0"],
                       False,
                       key="ver"),
         "now":
         soho.SohoParm("state:time", "real", [0], False, key="now"),
         "fps":
         soho.SohoParm("state:fps", "real", [24], False, key="fps"),
     }
     rop = soho.getOutputDriver()
     parms = soho.evaluate(state_parms, None, rop)
     for parm in parms:
         setattr(self, parm, parms[parm].Value[0])
     if not self.fps:
         self.fps = 24.0
     self.inv_fps = 1.0 / self.fps
     return
Exemple #3
0
 def init_state(self):
     """Queries Soho to initialize the attributes of the class"""
     state_parms = {
         'rop':
         soho.SohoParm('object:name', 'string', key='rop'),
         'hip':
         soho.SohoParm('$HIP', 'string', key='hip'),
         'hipname':
         soho.SohoParm('$HIPNAME', 'string', key='hipname'),
         'hipfile':
         soho.SohoParm('$HIPFILE', 'string', key='hipfile'),
         'ver':
         soho.SohoParm('state:houdiniversion',
                       'string', ["9.0"],
                       False,
                       key='ver'),
         'now':
         soho.SohoParm('state:time', 'real', [0], False, key='now'),
         'fps':
         soho.SohoParm('state:fps', 'real', [24], False, key='fps'),
     }
     rop = soho.getOutputDriver()
     parms = soho.evaluate(state_parms, None, rop)
     for parm in parms:
         setattr(self, parm, parms[parm].Value[0])
     if not self.fps:
         self.fps = 24.0
     self.inv_fps = 1.0 / self.fps
     return
Exemple #4
0
def phantom(obj, now, value):
    if soho.getOutputDriver().getData('pcrender'):
        value[:] = [0]
        return True
    if obj.evalInt('light_contribprimary', now, value):
        if value[0]:
            value[0] = 0
            return True
    return False
Exemple #5
0
def setMattePhantomOverrides(now, matte_objects, phantom_objects):
    _Settings.MatteOverrides = {}
    _Settings.PhantomOverrides = {}
    rop = soho.getOutputDriver()
    if matte_objects:
        for obj in rop.objectList('objlist:instance', now, matte_objects):
            _Settings.MatteOverrides[obj.getName()] = True
    if phantom_objects:
        for obj in rop.objectList('objlist:instance', now, phantom_objects):
            _Settings.PhantomOverrides[obj.getName()] = True
Exemple #6
0
def surface_shader(obj, now, value):
    if obj.evalShader('shop_surfacepath', now, value):
        if value[0]:
            return True

    plist = obj.evaluate(lshaderParms, now)
    ltype = plist['light_type'].Value[0]
    light_texture = plist['light_texture'].Value[0]
    singlesided = plist['singlesided'].Value[0]
    reverse = plist['reverse'].Value[0]
    normalizearea = plist['normalizearea'].Value[0]
    edgeenable = plist['edgeenable'].Value[0]
    edgewidth = plist['edgewidth'].Value[0]
    edgerolloff = plist['edgerolloff'].Value[0]

    if not isarealighttype(ltype):
        value[:] = ['opdef:/Shop/v_constant']
        return True

    light_color = get_color(plist)

    shader = 'opdef:/Shop/v_arealight'

    # Only output the light color for if it's not a point cloud render
    if not soho.getOutputDriver().getData('pcrender'):
        shader += ' lightcolor %g %g %g' % \
                    ( light_color[0], light_color[1], light_color[2] )
        shader += envString(plist)

    shader += ' normalizearea %d' % normalizearea

    if light_texture != '':
        shader += ' texmap "%s"' % light_texture

    if singlesided:
        shader += ' singlesided 1 reverse %d' % reverse

    if edgeenable:
        shader += ' doedge 1 edgewidth %g edgerolloff %g' % \
                    (edgewidth, edgerolloff)

    value[:] = [shader]
    return True
Exemple #7
0
def outputMPlayFormatOptions(wrangler, cam, now):
    plist = cam.wrangle(wrangler, _iplay_specific, now)
    rendermode = plist['rendermode'].Value[0]
    framemode = plist['framemode'].Value[0]
    trange = plist['trange'].Value[0]
    curframe = hou.timeToFrame(now)
    if trange:
        frange = cam.wrangleInt(wrangler, 'f', now, [curframe, curframe])
        if len(frange) < 2:
            frange = [curframe, curframe]
    else:
        frange = [curframe, curframe]

    # There are 4 combinations of rendermode and framemode
    #   rendermode/framemode |  append    |  match
    #   ---------------------+------------+-----------
    #         new            | new-append | new-frame
    #       current          |   append   |  replace
    #  However, we only perform "new" render mode if we the render
    #  frame is at the beginning of the frame range
    if abs(curframe - frange[0]) < 0.01:
        rendermode = 'current'
    if rendermode == 'new':
        if framemode == 'append':
            rendermode = 'new-append'
        else:
            rendermode = 'new-frame'
    else:
        if framemode == 'append':
            rendermode = 'append'
        else:
            rendermode = 'replace'
    cmd_declare('plane', 'string', 'IPlay.rendermode', [rendermode])
    frange = '%d %d' % (int(frange[0]), int(frange[1]))
    cmd_declare('plane', 'string', 'IPlay.framerange', [frange])
    cmd_declare('plane', 'float', 'IPlay.currentframe', [curframe])
    rendersource = soho.getDefaultedString('lv_rendersource',
                                           [soho.getOutputDriver().getName()])
    cmd_declare('plane', 'string', 'IPlay.rendersource', rendersource)
Exemple #8
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', (), {
        'Msg': 0,
        'Info': 1,
        'Progress': 2,
        'Warning': 3,
        'Error': 4,
        'Debug': 5
    })

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

        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.
    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 Port: %s" % port)
        printDebug("Driver: %s" % ropPath)
        printDebug("Camera: %s" % camera)
        printDebug("Now: %.3f" % now)

        _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:
            if _vfh_ipr.setTime(now):
                # Have to handle "time" event manually here.
                exportObjects("objlist:dirtyinstance")
                exportObjects("objlist:dirtylight")

            # Update view.
            exportView(ropPath, camera, sohoCam, now)
Exemple #9
0
def header(now, propdefs):
    global PipeStream, TmpSharedStorage, TmpLocalStorage
    global ExternalSessionId, ExternalSharedSessionId
    global SequenceNumber, SequenceLength
    global InlineGeoDefault

    LSDhooks.call('pre_header', now)

    rop = soho.getOutputDriver()
    plist = rop.evaluate(headerParms, now)
    hver = plist["hver"].Value[0]
    cmd_comment("LSD created by Houdini Version: %s" % hver)
    cmd_comment("Generation Time: %s" % time.strftime("%b %d, %Y at %H:%M:%S"))
    soho_program = plist.get('soho_program', None)
    target = LSDsettings.theVersion
    hip = plist.get('hip', None)
    hipname = plist.get('hipname', None)
    ropname = plist.get('ropname', None)
    tmpsharedstorage = plist.get('tmpsharedstorage', None)
    tmplocalstorage = plist.get('tmplocalstorage', None)
    houdinipid = plist['houdinipid'].Value[0]
    pipepid = plist['pipepid'].Value[0]
    pipestream = plist.get('pipestream', None)
    seqnumber = plist.get('seqnumber', None)
    seqlength = plist.get('seqlength', None)
    if seqnumber:
        # The sequence number is the one-based number in the frame sequence
        # being rendered.
        SequenceNumber = seqnumber.Value[0]
    if seqlength:
        # Number of frames in the sequence being rendered
        SequenceLength = seqlength.Value[0]
    if soho_program:
        cmd_comment("    Soho Script: %s" %
                    fullFilePath(soho_program.Value[0]))
    if target:
        cmd_comment("  Render Target: %s" % target)
    defs = LSDsettings.SettingDefs
    if len(defs):
        cmd_comment("    Render Defs: %s" % defs[0])
        for i in range(1, len(defs)):
            cmd_comment("               : %s" % defs[i])
    if hip and hipname:
        cmd_comment("       HIP File: %s/%s, $T=%g, $FPS=%g" %
                    (hip.Value[0], hipname.Value[0], now, FPS))
    if ropname:
        cmd_comment("  Output driver: %s" % ropname.Value[0])

    cmd_version(hver)
    if propdefs:
        # Output property defaults before we output any other settings
        cmd_defaults(propdefs)

    # Renderer frame graph configuation
    cmd_config("$LAVA_HOME/conf/default.py")

    cmd_comment(None)
    cmd_declare('global', 'float', 'global:fps', [FPS])

    # TODO: do we really need this !?
    #cmd_hscript('fps %g; tcur %g' % (FPS, now))

    verbose = plist.get('lv_verbose', None)
    if verbose:
        cmd_property('renderer', 'verbose', verbose.Value)

    cmd_comment(None)

    if not pipestream:
        cmd_comment('Unable to determine whether writing to a pipe')
        PipeStream = True
    else:
        PipeStream = (pipestream.Value[0] != 0)

    if hip:
        hipvar = hip.Value[0]
    else:
        hipvar = ""
    hipvar = rop.getDefaultedString('lv_hippath', now, [hipvar])[0]
    # Setting the HIP variable in a conditional so users can override
    # the HIP variable in the .ifd file.
    cmd_setenv('HIP', '$HIP_OVERRIDE')
    cmd_if('"$HIP" == ""')
    cmd_setenv('HIP', hipvar)
    cmd_endif()

    def isValidTempDir(path):
        # Make sure we can either create the sub-directories of the path, or
        # that the path itself is writeable.
        if os.path.isdir(path):
            return os.access(path, os.W_OK)
        head, tail = os.path.split(path)
        return isValidTempDir(head) if head else False

    if not tmpsharedstorage:
        # We still need to create a storage path, so put it in the HIP
        # directory.  This is where assets will be saved for the LSD.
        tmpsharedstorage = hou.expandString("$HIP/ifds/storage")
    else:
        tmpsharedstorage = tmpsharedstorage.Value[0]
    if not isValidTempDir(tmpsharedstorage):
        soho.warning(
            "Path specified by lv_tmpsharedstorage is read-only.  %s" %
            ("this may cause issues with non-inline geometry"))
        tmpsharedstorage = hou.expandString("$HOUDINI_TEMP_DIR/ifds/storage")

    if not tmplocalstorage:
        # We still need to create a storage path, so put it in the
        # HOUDINI_TEMP_DIR directory.  This is where assets will be saved for
        # the LSD.
        tmplocalstorage = hou.expandString("$HOUDINI_TEMP_DIR/ifds/storage")
    else:
        tmplocalstorage = tmplocalstorage.Value[0]

    # Set the external storage variable set into a conditional so if the
    # variable is set before mantra is run, that value will be used instead.
    cmd_if('"$_TMP_SHARED_STORAGE" == ""')
    cmd_setenv('_TMP_SHARED_STORAGE', tmpsharedstorage)
    cmd_endif()
    cmd_if('"$_TMP_LOCAL_STORAGE" == ""')
    cmd_setenv('_TMP_LOCAL_STORAGE', tmplocalstorage)
    cmd_endif()
    TmpSharedStorage = tmpsharedstorage  # Stash for later
    TmpLocalStorage = tmplocalstorage  # Stash for later

    frame = now * FPS + 1
    frame_frac = int((frame % 1) * 100)
    if PipeStream:
        ExternalSessionId = '%d_%s.%d_%03d' % (pipepid, hipname.Value[0],
                                               int(frame), frame_frac)
        ExternalSharedSessionId = '%d_%s_shared' % (houdinipid,
                                                    hipname.Value[0])
    else:
        ExternalSessionId = '%s.%d_%03d' % (hipname.Value[0], int(frame),
                                            frame_frac)
        ExternalSharedSessionId = '%s_shared' % (hipname.Value[0])

    if os.getenv('MANTRA_DEBUG_INLINE_STORAGE'):
        # Normally, we want to rely on the lv_inlinestorage parameter (which
        # defaults to False).  For convenience we can set this variable to
        # override the setting.  Note that this may impact performance since
        # Houdini and mantra are able to multi-thread saving/loading
        # geometry.  This should be used for debugging only.
        InlineGeoDefault = [1]

    LSDhooks.call('post_header', now)
Exemple #10
0
def render():
    """Evaluate and package the HDA parameters and submit a job to HQueue.""" 
    # Build a dictionary of base parameters and add the HQueue Render-specific
    # ones.
    parms = hqrop.getBaseParameters()
    
    use_cloud = (hou.ch("hq_use_cloud1")
        if hou.parm("hq_use_cloud1") is not None else 0)
    num_cloud_machines = (hou.ch("hq_num_cloud_machines")
        if hou.parm("hq_num_cloud_machines") is not None else 0)
    machine_type = (hou.ch("hq_cloud_machine_type")
        if hou.parm("hq_cloud_machine_type") is not None else "")
    use_output_driver = bool(use_cloud) or parms["hip_action"] != "use_ifd"

    # validate the machine type
    if machine_type not in ['c1.medium', 'c1.xlarge',
                            'm1.small', 'm1.large', 'm1.xlarge']:
        machine_type = 'c1.xlarge'

    
    parms.update({
        "assign_ifdgen_to" : hou.parm("hq_assign_ifdgen_to").evalAsString(),
        "ifdgen_clients": hou.ch("hq_ifdgen_clients").strip(),
        "ifdgen_client_groups" : hou.ch("hq_ifdgen_client_groups").strip(),
        "batch_all_frames": hou.ch("hq_batch_all_frames"),
        "frames_per_job": hou.ch("hq_framesperjob"),
        "render_frame_order": hou.parm("hq_render_frame_order").evalAsString(),
        "make_ifds": hou.ch("hq_makeifds"),
        "max_hosts_per_job": hou.ch("hq_max_hosts"),
        "min_hosts_per_job": hou.ch("hq_min_hosts"),
        "is_CPU_number_set": bool(hou.ch("hq_is_CPU_number_set")),
        "CPUs_to_use": hou.ch("hq_CPUs_to_use"),
        "output_ifd": hou.parm("hq_outputifd").unexpandedString().strip(),
        "use_output_driver" : use_output_driver,
        "use_cloud": use_cloud,
        "num_cloud_machines": num_cloud_machines,
        "cloud_machine_type" : machine_type,
        "use_render_tracker" : hou.ch("hq_use_render_tracker"),
        "delete_ifds": hou.ch("hq_delete_ifds"),
        "render_single_tile": bool(hou.ch("hq_render_single_tile")),
    })

    if use_output_driver:
        # Convert output_driver path to an absolute path.
        parms["output_driver"] = hou.ch("hq_driver").strip()
        rop_node = hou.pwd().node(parms["output_driver"])
        if rop_node:
            parms["output_driver"] = rop_node.path()

        parms["ifd_path"] = hou.parm("hq_outputifd").unexpandedString().strip()
        output_driver = hqrop.getOutputDriver(hou.pwd())

        # Turn "off" Mantra-specific parameters if there is an output driver
        # and it is not a Mantra ROP.
        if output_driver and output_driver.type().name() != "ifd":
            parms["make_ifds"] = False
            parms["min_hosts_per_job"] = 1
            parms["max_hosts_per_job"] = 1
    else:
        parms.update({
            "ifd_path" : hou.parm("hq_input_ifd").unexpandedString().strip(),
            "start_frame" : hou.ch("hq_frame_range_1"),
            "end_frame" : hou.ch("hq_frame_range_2"),
            "frame_skip" : hou.ch("hq_frame_range_3"),
            # If we are not using an output driver we are using IFDs and so
            # we won't be making them
            "make_ifds" : False,
        })

        if parms["frame_skip"] <= 0:
            parms["frame_skip"] = 1
 
    # We stop if we cannot establish a connection with the server
    if (not parms["use_cloud"]
        and not hqrop.doesHQServerExists(parms["hq_server"])):
        return None

    if "ifd_path" in parms and not parms["use_cloud"]:
        expand_frame_variables = False
        parms["ifd_path"] = hqrop.substituteWithHQROOT(
            parms["hq_server"], parms["ifd_path"], expand_frame_variables)

    # Validate parameter values.
    if (not hqrop.checkBaseParameters(parms) or
            not _checkRenderParameters(parms)):
        return
    if use_output_driver and parms["hip_action"] == "use_current_hip":
        if not hqrop.checkOutputDriver(parms["output_driver"]):
            return
        if hqrop.checkForRecursiveChain(hou.pwd()):
            hqrop.displayError(("Cannot submit HQueue job because"
                                " %s is in the input chain of %s.") 
                                % (hou.pwd().path(), parms["output_driver"]))
            return

    # If we're not supposed to run this job on the cloud, submit the job.
    # Otherwise, we'll display the file dependency dialog.
    if parms["use_cloud"]:
        # We don't want to keep the interrupt dialog open, so we exit this soho
        # script so the dialog closes and schedule an event to run the code to
        # display the dialog.
        import soho
        rop_node = hou.node(soho.getOutputDriver().getName())
        cloud.selectProjectParmsForCloudRender(
            rop_node, parms["num_cloud_machines"], parms["cloud_machine_type"])
        return

    # Automatically save changes to the .hip file,
    # or at least warn the user about unsaved changes.
    should_continue = hqrop.warnOrAutoSaveHipFile(parms)
    if not should_continue:
        return

    hqrop.submitJob(parms, _byu_troubleshoot_hq)
Exemple #11
0
parm = {'diskfile': SohoParm('soho_diskfile', 'string', ['*'], False)}
parmlist = soho.evaluate(parm)
filename = parmlist['soho_diskfile'].Value[0]

# We can't emit file to stdout, because appleseed.cli currently doesn't accept stdit
# with open(filename, 'w') as file:
# technically preambule is not part of project object:
date = datetime.strftime(datetime.today(), "%b %d, %Y at %H:%M:%S")
stat = '<!-- Generation time: %g seconds -->' % (time.time() - clockstart)
preambule = APSsettings.PREAMBULE.format(
    houdini_version=hou.applicationVersionString(),
    aps_version=APSsettings.__version__,
    date=date,
    renderer_version=APSsettings.__appleseed_version__,
    driver=soho.getOutputDriver().getName(),
    hipfile=hou.hipFile.name(),
    TIME=now,
    FPS=FPS,
)

if mode == "update":
    xform = []
    cam.evalFloat("space:world", now, xform)
    xform = hou.Matrix4(xform).transposed().asTuple()
    xform = " ".join(map(str, xform))
    print xform
else:
    # first line if stdin is (socket, mode) where 0=default, 1=ipr
    # I would love to have custom tag in appleseed.
    if mode != 'default':
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.
port = soho.getDefaultedInt("vm_image_mplay_socketport", [0])[0]

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

# Use callbacks or SOHO
render_rt_update_mode = hou.evalParm("render_rt_update_mode")

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)
Exemple #13
0
def isphoton():
    return soho.getOutputDriver().getData("photonrender")
Exemple #14
0
def render():
    """Evaluate and package the HDA parameters and submit a job to HQueue."""
    # Build a dictionary of base parameters and add the HQueue Render-specific
    # ones.
    parms = hqrop.getBaseParameters()

    use_cloud = (hou.ch("hq_use_cloud1")
                 if hou.parm("hq_use_cloud1") is not None else 0)
    num_cloud_machines = (hou.ch("hq_num_cloud_machines") if
                          hou.parm("hq_num_cloud_machines") is not None else 0)
    machine_type = (hou.ch("hq_cloud_machine_type")
                    if hou.parm("hq_cloud_machine_type") is not None else "")
    use_output_driver = bool(use_cloud) or parms["hip_action"] != "use_ifd"

    # validate the machine type
    if machine_type not in [
            'c1.medium', 'c1.xlarge', 'm1.small', 'm1.large', 'm1.xlarge'
    ]:
        machine_type = 'c1.xlarge'

    parms.update({
        "assign_ifdgen_to":
        hou.parm("hq_assign_ifdgen_to").evalAsString(),
        "ifdgen_clients":
        hou.ch("hq_ifdgen_clients").strip(),
        "ifdgen_client_groups":
        hou.ch("hq_ifdgen_client_groups").strip(),
        "batch_all_frames":
        hou.ch("hq_batch_all_frames"),
        "frames_per_job":
        hou.ch("hq_framesperjob"),
        "render_frame_order":
        hou.parm("hq_render_frame_order").evalAsString(),
        "make_ifds":
        hou.ch("hq_makeifds"),
        "max_hosts_per_job":
        hou.ch("hq_max_hosts"),
        "min_hosts_per_job":
        hou.ch("hq_min_hosts"),
        "is_CPU_number_set":
        bool(hou.ch("hq_is_CPU_number_set")),
        "CPUs_to_use":
        hou.ch("hq_CPUs_to_use"),
        "output_ifd":
        hou.parm("hq_outputifd").unexpandedString().strip(),
        "use_output_driver":
        use_output_driver,
        "use_cloud":
        use_cloud,
        "num_cloud_machines":
        num_cloud_machines,
        "cloud_machine_type":
        machine_type,
        "use_render_tracker":
        hou.ch("hq_use_render_tracker"),
        "delete_ifds":
        hou.ch("hq_delete_ifds"),
        "render_single_tile":
        bool(hou.ch("hq_render_single_tile")),
    })

    if use_output_driver:
        # Convert output_driver path to an absolute path.
        parms["output_driver"] = hou.ch("hq_driver").strip()
        rop_node = hou.pwd().node(parms["output_driver"])
        if rop_node:
            parms["output_driver"] = rop_node.path()

        parms["ifd_path"] = hou.parm("hq_outputifd").unexpandedString().strip()
        output_driver = hqrop.getOutputDriver(hou.pwd())

        # Turn "off" Mantra-specific parameters if there is an output driver
        # and it is not a Mantra ROP.
        if output_driver and output_driver.type().name() != "ifd":
            parms["make_ifds"] = False
            parms["min_hosts_per_job"] = 1
            parms["max_hosts_per_job"] = 1
    else:
        parms.update({
            "ifd_path":
            hou.parm("hq_input_ifd").unexpandedString().strip(),
            "start_frame":
            hou.ch("hq_frame_range_1"),
            "end_frame":
            hou.ch("hq_frame_range_2"),
            "frame_skip":
            hou.ch("hq_frame_range_3"),
            # If we are not using an output driver we are using IFDs and so
            # we won't be making them
            "make_ifds":
            False,
        })

        if parms["frame_skip"] <= 0:
            parms["frame_skip"] = 1

    # We stop if we cannot establish a connection with the server
    if (not parms["use_cloud"]
            and not hqrop.doesHQServerExists(parms["hq_server"])):
        return None

    if "ifd_path" in parms and not parms["use_cloud"]:
        expand_frame_variables = False
        parms["ifd_path"] = hqrop.substituteWithHQROOT(parms["hq_server"],
                                                       parms["ifd_path"],
                                                       expand_frame_variables)

    # Validate parameter values.
    if (not hqrop.checkBaseParameters(parms)
            or not _checkRenderParameters(parms)):
        return
    if use_output_driver and parms["hip_action"] == "use_current_hip":
        if not hqrop.checkOutputDriver(parms["output_driver"]):
            return
        if hqrop.checkForRecursiveChain(hou.pwd()):
            hqrop.displayError(("Cannot submit HQueue job because"
                                " %s is in the input chain of %s.") %
                               (hou.pwd().path(), parms["output_driver"]))
            return

    # If we're not supposed to run this job on the cloud, submit the job.
    # Otherwise, we'll display the file dependency dialog.
    if parms["use_cloud"]:
        # We don't want to keep the interrupt dialog open, so we exit this soho
        # script so the dialog closes and schedule an event to run the code to
        # display the dialog.
        import soho
        rop_node = hou.node(soho.getOutputDriver().getName())
        cloud.selectProjectParmsForCloudRender(rop_node,
                                               parms["num_cloud_machines"],
                                               parms["cloud_machine_type"])
        return

    # Automatically save changes to the .hip file,
    # or at least warn the user about unsaved changes.
    should_continue = hqrop.warnOrAutoSaveHipFile(parms)
    if not should_continue:
        return

    hqrop.submitJob(parms, _byu_troubleshoot_hq)
Exemple #15
0
            cmd_loadotl(otls)

        #
        # Output OTL preferences set in Houdini
        otprefs = soho.getDefaultedString('state:otprefer', [])
        if soho.getDefaultedInt('lv_otlfullpath', [0])[0]:
            for i in range(1, len(otprefs), 2):
                otprefs[i] = hou.expandString(otprefs[i])
        if len(otprefs):
            cmd_comment("OTL preferences from the .hip file")
            cmd_otprefer(otprefs)

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

    isphoton = parmlist['engine'].Value[0] == 'photon' or \
               parmlist['engine'].Value[0] == 'viewphoton'

    #
    # If there's only one camera, output it here
    donecamera = False
    do_main = parmlist['main'].Value[0]
    if do_main and mode == "generate" and len(camera_list) == 1:
        sub_camera = camera_list[0]
        if sub_camera:
            if not LSDhooks.call('pre_mainimage', parmlist, objparms, now,
                                 sub_camera):
                cmd_comment('Main image from %s' % sub_camera.getName())
                LSDframe.renderCamera(sub_camera, now, forphoton=isphoton)
Exemple #16
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)