#usda 1.0
(
    "WARNING: THIS FILE IS GENERATED BY usdGenSchema.  DO NOT EDIT."
)

class "RenderSettingsBase" (
    doc = """Abstract base class that defines render settings that
    can be specified on either a RenderSettings prim or a RenderProduct 
    prim."""
)
{
    uniform token aspectRatioConformPolicy = "expandAperture" (
        allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
        doc = '''Indicates the policy to use to resolve an aspect
        ratio mismatch between the camera aperture and image settings.

        This policy allows a standard render setting to do something
        reasonable given varying camera inputs.

        The camera aperture aspect ratio is determined by the
        aperture atributes on the UsdGeomCamera.

        The image aspect ratio is determined by the resolution and
        pixelAspectRatio attributes in the render settings.

        - "expandAperture": if necessary, expand the aperture to
          fit the image, exposing additional scene content
        - "cropAperture": if necessary, crop the aperture to fit
          the image, cropping scene content
        - "adjustApertureWidth": if necessary, adjust aperture width
          to make its aspect ratio match the image
        - "adjustApertureHeight": if necessary, adjust aperture height
          to make its aspect ratio match the image
        - "adjustPixelAspectRatio": compute pixelAspectRatio to
          make the image exactly cover the aperture; disregards
          existing attribute value of pixelAspectRatio
        '''
    )
    rel camera (
        doc = """The _camera_ relationship specifies the primary
        camera to use in a render.  It must target a UsdGeomCamera."""
    )
    uniform float4 dataWindowNDC = (0, 0, 1, 1) (
        doc = """dataWindowNDC specifies the axis-aligned rectangular
        region in the adjusted aperture window within which the renderer
        should produce data.

        It is specified as (xmin, ymin, xmax, ymax) in normalized
        device coordinates, where the range 0 to 1 corresponds to the
        aperture.  (0,0) corresponds to the bottom-left
        corner and (1,1) corresponds to the upper-right corner.

        Specifying a window outside the unit square will produce
        overscan data. Specifying a window that does not cover the unit
        square will produce a cropped render.

        A pixel is included in the rendered result if the pixel
        center is contained by the data window.  This is consistent
        with standard rules used by polygon rasterization engines.
        \\ref UsdRenderRasterization

        The data window is expressed in NDC so that cropping and
        overscan may be resolution independent.  In interactive
        workflows, incremental cropping and resolution adjustment
        may be intermixed to isolate and examine parts of the scene.
        In compositing workflows, overscan may be used to support
        image post-processing kernels, and reduced-resolution proxy
        renders may be used for faster iteration.

        The dataWindow:ndc coordinate system references the
        aperture after any adjustments required by
        aspectRatioConformPolicy.
        """
    )
    uniform bool disableMotionBlur = 0 (
        doc = """Disable all motion blur by setting the shutter interval
        of the targeted camera to [0,0] - that is, take only one sample,
        namely at the current time code."""
    )
    uniform bool instantaneousShutter = 0 (
        doc = """Deprecated - use disableMotionBlur instead. Override
        the targeted _camera_'s _shutterClose_ to be equal to the
        value of its _shutterOpen_, to produce a zero-width shutter
        interval.  This gives us a convenient way to disable motion
        blur."""
    )
    uniform float pixelAspectRatio = 1 (
        doc = """The aspect ratio (width/height) of image pixels..
        The default ratio 1.0 indicates square pixels."""
    )
    uniform int2 resolution = (2048, 1080) (
        doc = """The image pixel resolution, corresponding to the
        camera's screen window."""
    )
}

class RenderSettings "RenderSettings" (
    doc = """A UsdRenderSettings prim specifies global settings for
    a render process, including an enumeration of the RenderProducts
    that should result, and the UsdGeomImageable purposes that should
    be rendered.  \\ref UsdRenderHowSettingsAffectRendering"""
)
{
    uniform token aspectRatioConformPolicy = "expandAperture" (
        allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
        doc = '''Indicates the policy to use to resolve an aspect
        ratio mismatch between the camera aperture and image settings.

        This policy allows a standard render setting to do something
        reasonable given varying camera inputs.

        The camera aperture aspect ratio is determined by the
        aperture atributes on the UsdGeomCamera.

        The image aspect ratio is determined by the resolution and
        pixelAspectRatio attributes in the render settings.

        - "expandAperture": if necessary, expand the aperture to
          fit the image, exposing additional scene content
        - "cropAperture": if necessary, crop the aperture to fit
          the image, cropping scene content
        - "adjustApertureWidth": if necessary, adjust aperture width
          to make its aspect ratio match the image
        - "adjustApertureHeight": if necessary, adjust aperture height
          to make its aspect ratio match the image
        - "adjustPixelAspectRatio": compute pixelAspectRatio to
          make the image exactly cover the aperture; disregards
          existing attribute value of pixelAspectRatio
        '''
    )
    rel camera (
        doc = """The _camera_ relationship specifies the primary
        camera to use in a render.  It must target a UsdGeomCamera."""
    )
    uniform float4 dataWindowNDC = (0, 0, 1, 1) (
        doc = """dataWindowNDC specifies the axis-aligned rectangular
        region in the adjusted aperture window within which the renderer
        should produce data.

        It is specified as (xmin, ymin, xmax, ymax) in normalized
        device coordinates, where the range 0 to 1 corresponds to the
        aperture.  (0,0) corresponds to the bottom-left
        corner and (1,1) corresponds to the upper-right corner.

        Specifying a window outside the unit square will produce
        overscan data. Specifying a window that does not cover the unit
        square will produce a cropped render.

        A pixel is included in the rendered result if the pixel
        center is contained by the data window.  This is consistent
        with standard rules used by polygon rasterization engines.
        \\ref UsdRenderRasterization

        The data window is expressed in NDC so that cropping and
        overscan may be resolution independent.  In interactive
        workflows, incremental cropping and resolution adjustment
        may be intermixed to isolate and examine parts of the scene.
        In compositing workflows, overscan may be used to support
        image post-processing kernels, and reduced-resolution proxy
        renders may be used for faster iteration.

        The dataWindow:ndc coordinate system references the
        aperture after any adjustments required by
        aspectRatioConformPolicy.
        """
    )
    uniform bool disableMotionBlur = 0 (
        doc = """Disable all motion blur by setting the shutter interval
        of the targeted camera to [0,0] - that is, take only one sample,
        namely at the current time code."""
    )
    uniform token[] includedPurposes = ["default", "render"] (
        doc = """The list of UsdGeomImageable _purpose_ values that
        should be included in the render.  Note this cannot be
        specified per-RenderProduct because it is a statement of
        which geometry is present."""
    )
    uniform bool instantaneousShutter = 0 (
        doc = """Deprecated - use disableMotionBlur instead. Override
        the targeted _camera_'s _shutterClose_ to be equal to the
        value of its _shutterOpen_, to produce a zero-width shutter
        interval.  This gives us a convenient way to disable motion
        blur."""
    )
    uniform token[] materialBindingPurposes = ["full", ""] (
        allowedTokens = ["full", "preview", ""]
        doc = '''Ordered list of material purposes to consider when
        resolving material bindings in the scene.  The empty string
        indicates the "allPurpose" binding.'''
    )
    uniform float pixelAspectRatio = 1 (
        doc = """The aspect ratio (width/height) of image pixels..
        The default ratio 1.0 indicates square pixels."""
    )
    rel products (
        doc = """The set of RenderProducts the render should produce.
        This relationship should target UsdRenderProduct prims.
        If no _products_ are specified, an application should produce
        an rgb image according to the RenderSettings configuration,
        to a default display or image name."""
    )
    uniform token renderingColorSpace (
        doc = """Describes a renderer's working (linear) colorSpace where all
        the renderer/shader math is expected to happen. When no
        renderingColorSpace is provided, renderer should use its own default."""
    )
    uniform int2 resolution = (2048, 1080) (
        doc = """The image pixel resolution, corresponding to the
        camera's screen window."""
    )
}

class RenderVar "RenderVar" (
    doc = """A UsdRenderVar describes a custom data variable for
    a render to produce.  The prim describes the source of the data, which
    can be a shader output or an LPE (Light Path Expression), and also
    allows encoding of (generally renderer-specific) parameters that
    configure the renderer for computing the variable.

    \\note The name of the RenderVar prim drives the name of the data 
    variable that the renderer will produce.
 
    \\note In the future, UsdRender may standardize RenderVar representation
    for well-known variables under the sourceType `intrinsic`,
    such as _r_, _g_, _b_, _a_, _z_, or _id_.
    """
)
{
    uniform token dataType = "color3f" (
        doc = "The type of this channel, as a USD attribute type."
    )
    uniform string sourceName = "" (
        doc = """The renderer should look for an output of this name
        as the computed value for the RenderVar."""
    )
    uniform token sourceType = "raw" (
        allowedTokens = ["raw", "primvar", "lpe", "intrinsic"]
        doc = '''Indicates the type of the source.

        - "raw": The name should be passed directly to the
          renderer.  This is the default behavior.
        - "primvar":  This source represents the name of a primvar.
          Some renderers may use this to ensure that the primvar
          is provided; other renderers may require that a suitable
          material network be provided, in which case this is simply
          an advisory setting.
        - "lpe":  Specifies a Light Path Expression in the
          [OSL Light Path Expressions language](https://github.com/imageworks/OpenShadingLanguage/wiki/OSL-Light-Path-Expressions) as the source for
          this RenderVar.  Some renderers may use extensions to
          that syntax, which will necessarily be non-portable.
        - "intrinsic":  This setting is currently unimplemented,
          but represents a future namespace for UsdRender to provide
          portable baseline RenderVars, such as camera depth, that
          may have varying implementations for each renderer.
        '''
    )
}

class RenderProduct "RenderProduct" (
    doc = """A UsdRenderProduct describes an image or other
    file-like artifact produced by a render. A RenderProduct
    combines one or more RenderVars into a file or interactive
    buffer.  It also provides all the controls established in
    UsdRenderSettingsBase as optional overrides to whatever the
    owning UsdRenderSettings prim dictates.

    Specific renderers may support additional settings, such
    as a way to configure compression settings, filetype metadata,
    and so forth.  Such settings can be encoded using
    renderer-specific API schemas applied to the product prim.
    """
)
{
    uniform token aspectRatioConformPolicy = "expandAperture" (
        allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
        doc = '''Indicates the policy to use to resolve an aspect
        ratio mismatch between the camera aperture and image settings.

        This policy allows a standard render setting to do something
        reasonable given varying camera inputs.

        The camera aperture aspect ratio is determined by the
        aperture atributes on the UsdGeomCamera.

        The image aspect ratio is determined by the resolution and
        pixelAspectRatio attributes in the render settings.

        - "expandAperture": if necessary, expand the aperture to
          fit the image, exposing additional scene content
        - "cropAperture": if necessary, crop the aperture to fit
          the image, cropping scene content
        - "adjustApertureWidth": if necessary, adjust aperture width
          to make its aspect ratio match the image
        - "adjustApertureHeight": if necessary, adjust aperture height
          to make its aspect ratio match the image
        - "adjustPixelAspectRatio": compute pixelAspectRatio to
          make the image exactly cover the aperture; disregards
          existing attribute value of pixelAspectRatio
        '''
    )
    rel camera (
        doc = """The _camera_ relationship specifies the primary
        camera to use in a render.  It must target a UsdGeomCamera."""
    )
    uniform float4 dataWindowNDC = (0, 0, 1, 1) (
        doc = """dataWindowNDC specifies the axis-aligned rectangular
        region in the adjusted aperture window within which the renderer
        should produce data.

        It is specified as (xmin, ymin, xmax, ymax) in normalized
        device coordinates, where the range 0 to 1 corresponds to the
        aperture.  (0,0) corresponds to the bottom-left
        corner and (1,1) corresponds to the upper-right corner.

        Specifying a window outside the unit square will produce
        overscan data. Specifying a window that does not cover the unit
        square will produce a cropped render.

        A pixel is included in the rendered result if the pixel
        center is contained by the data window.  This is consistent
        with standard rules used by polygon rasterization engines.
        \\ref UsdRenderRasterization

        The data window is expressed in NDC so that cropping and
        overscan may be resolution independent.  In interactive
        workflows, incremental cropping and resolution adjustment
        may be intermixed to isolate and examine parts of the scene.
        In compositing workflows, overscan may be used to support
        image post-processing kernels, and reduced-resolution proxy
        renders may be used for faster iteration.

        The dataWindow:ndc coordinate system references the
        aperture after any adjustments required by
        aspectRatioConformPolicy.
        """
    )
    uniform bool disableMotionBlur = 0 (
        doc = """Disable all motion blur by setting the shutter interval
        of the targeted camera to [0,0] - that is, take only one sample,
        namely at the current time code."""
    )
    uniform bool instantaneousShutter = 0 (
        doc = """Deprecated - use disableMotionBlur instead. Override
        the targeted _camera_'s _shutterClose_ to be equal to the
        value of its _shutterOpen_, to produce a zero-width shutter
        interval.  This gives us a convenient way to disable motion
        blur."""
    )
    rel orderedVars (
        doc = """Specifies the RenderVars that should be consumed and
        combined into the final product.  If ordering is relevant to the
        output driver, then the ordering of targets in this relationship
        provides the order to use."""
    )
    uniform float pixelAspectRatio = 1 (
        doc = """The aspect ratio (width/height) of image pixels..
        The default ratio 1.0 indicates square pixels."""
    )
    token productName = "" (
        doc = """Specifies the name that the output/display driver
        should give the product.  This is provided as-authored to the
        driver, whose responsibility it is to situate the product on a
        filesystem or other storage, in the desired location."""
    )
    uniform token productType = "raster" (
        doc = '''The type of output to produce.
        The default, "raster", indicates a 2D image.

        \\note In the future, UsdRender may define additional product
        types.'''
    )
    uniform int2 resolution = (2048, 1080) (
        doc = """The image pixel resolution, corresponding to the
        camera's screen window."""
    )
}

class RenderPass "RenderPass" (
    apiSchemas = ["CollectionAPI:renderVisibility"]
    customData = {
        token[] apiSchemaOverridePropertyNames = ["collection:renderVisibility:includeRoot"]
    }
    doc = """A RenderPass prim encapsulates the necessary information
    to generate multipass renders.  It houses properties for generating
    dependencies and the necessary commands to run to generate renders, as 
    well as visibility controls for the scene.  While RenderSettings
    describes the information needed to generate images from a single 
    invocation of a renderer, RenderPass describes the additional information
    needed to generate a time varying set of images.

    There are two consumers of RenderPass prims - a runtime executable that
    generates images from usdRender prims, and pipeline specific code that
    translates between usdRender prims and the pipeline's resource scheduling
    software.  We'll refer to the latter as 'job submission code'.

    \\anchor usdRender_renderVisibility
    The objects that are relevant to the render is specified via the 
    renderVisibility collection (UsdCollectionAPI) and can be accessed via 
    GetRenderVisibilityCollectionAPI(). This collection has includeRoot set to 
    true so that all objects participate in the render by default. To render 
    only a specific set of objects, there are two options. One is to modify the 
    collection paths to explicitly exclude objects that don't participate in 
    the render, assuming it is known; the other option is to set includeRoot to 
    false and explicitly include the desired objects. These are complementary 
    approaches that may each be preferable depending on the scenario.

    The name of the prim is used as the pass's name.
    """
)
{
    uniform bool collection:renderVisibility:includeRoot = 1
    uniform string[] command (
        doc = '''The command to run in order to generate
        renders for this pass.  The job submission code can use
        this to properly send tasks to the job scheduling software
        that will generate products.

        The command can contain variables that will be substituted
        appropriately during submission, as seen in the example below 
        with {fileName}.

        For example:
        command[0] = "prman"
        command[1] = "-progress"
        command[2] = "-pixelvariance"
        command[3] = "-0.15"
        command[4] = "{fileName}" # the fileName property will be substituted
        '''
    )
    uniform bool denoise:enable = 0 (
        doc = "When True, this Pass pass should be denoised."
    )
    rel denoise:pass (
        doc = """The The UsdRenderDenoisePass prim from which to 
        source denoise settings.
        """
    )
    uniform asset fileName (
        doc = """The asset that contains the rendering prims or other 
        information needed to render this pass.
        """
    )
    rel inputPasses (
        doc = """The set of other Passes that this Pass depends on
        in order to be constructed properly.  For example, a Pass A
        may generate a texture, which is then used as an input to
        Pass B.
 
        By default, usdRender makes some assumptions about the
        relationship between this prim and the prims listed in inputPasses.
        Namely, when per-frame tasks are generated from these pass prims,
        usdRender will assume a one-to-one relationship between tasks
        that share their frame number.  Consider a pass named 'composite'
        whose _inputPasses_ targets a Pass prim named 'beauty`.  
        By default, each frame for 'composite' will depend on the 
        same frame from 'beauty':
        beauty.1 -> composite.1
        beauty.2 -> composite.2
        etc

        The consumer of this RenderPass graph of inputs will need to resolve
        the transitive dependencies.
        """
    )
    uniform token passType (
        doc = """A string used to categorize differently structured 
        or executed types of passes within a customized pipeline.

        For example, when multiple DCC's (e.g. Houdini, Katana, Nuke) 
        each compute and contribute different Products to a final result, 
        it may be clearest and most flexible to create a separate 
        RenderPass for each.
        """
    )
    rel renderSource (
        doc = """The source prim to render from.  If _fileName_ is not present,
        the source is assumed to be a RenderSettings prim present in the current 
        Usd stage. If fileName is present, the source should be found in the
        file there. This relationship might target a string attribute on this 
        or another prim that identifies the appropriate object in the external 
        container.
 
        For example, for a Usd-backed pass, this would point to a RenderSettings
        prim.  Houdini passes would point to a Rop.  Nuke passes would point to 
        a write node.
        """
    )
}

class RenderDenoisePass "RenderDenoisePass" (
    doc = """A RenderDenoisePass generates renders via a denoising process.
    This may be the same renderer that a pipeline uses for UsdRender, 
    or may be a separate one.  Notably, a RenderDenoisePass requires
    another Pass to be present for it to operate.  The denoising process 
    itself is not generative, and requires images inputs to operate.
 
    As denoising integration varies so widely across pipelines, all
    implementation details are left to pipeline-specific prims
    that inherit from RenderDenoisePass.
    """
)
{
}

