Arnold is a major feature release adding Intel®'s Open Image Denoise, better denoising quality overall, important scalability improvements on GPU, and better performance and interactivity. We also introduce important API changes, such as the ability to render several scenes within the same process, and shaders now supporting multiple outputs.

System Requirements 

  • Windows 10 or later, with the Visual Studio 2019 redistributable.
  • Linux with at least glibc 2.17 and libstdc++ 4.8.5 (gcc 4.8.5). This is equivalent to RHEL/CentOS 7.
  • macOS 10.13 or later.
  • CPUs need to support the SSE4.1 instruction set. Apple Mac models with M series chip are supported under Rosetta 2 mode.
  • GPU rendering works on Windows and Linux only and requires an NVIDIA GPU of the Ampere, Turing, Volta, Pascal, or Maxwell architecture. We recommend using the 470.74 or higher drivers on Linux and 472.12 (Quadro), 472.12 (GeForce), or higher on Windows. See Getting Started with Arnold GPU for more information.
  • Optix™ denoiser requires an NVidia GPU with CUDA™ Compute Capability 5.0 and above.


  • Open Image Denoise imager: Intel®'s Open Image Denoise (OIDN) is a fast, AI-accelerated denoiser that runs on CPU that has been integrated into Arnold as the imager_denoiser_oidn imager as an additional denoising option. (ARNOLD-8677).

    OIDN denoiser. Rollover image to view without denoising.
    Sampling settings: camera (AA): 3, diffuse: 2, specular: 2, transmission: 2.

  • Higher quality AI denoising: The OptiX and OIDN denoisers now use the newly introduced denoise_albedo_noisy AOV as the albedo feature AOV provided to the denoiser. This adds specular reflections and refractions to the albedo, which can improve denoiser quality. Below are comparisons between undenoised and Optix denoised with the old and new albedo AOV (ARNOLD-10812).

    Undenoised (left), Optix diffuse albedo (center), Optix diffuse+specular albedo (right).

  • LUT based tone mapping: imager_tonemap now supports a lut mode to apply LUT files in all the formats supported by OCIOv2 (cube, look, 3dl, clf among others). imager_tonemap.lut_filename specifies the file to load. Note that some LUTs assume a non-linear color space. To help with this, it is possible to specify a working color space in imager_tonemap.lut_working_color_space to convert to the specified space, apply the lut, and convert to linear or rendering color space again (ARNOLD-11084).

  • Automatic selection of box filtering with OIDN and OptiX denoisers: The OptiX and OIDN denoisers do not perform well with CPU rendering filters that span across multiple pixels. Arnold on CPU will now automatically force a box filter on outputs with filters with known issues when either of the denoisers are used (ARNOLD-10812).

  • Imager_color_curves: A new imager to control brightness and color curves has been added. Separate curves can be authored for each R, G, or B component, along with the main curve to control the overall luminance response. Curve interpolation and working color space can also be set as needed (ARNOLD-11161).

    RGB colors edited in real-time using imager_color_curves

  • imager_tonemap.mix: imager_tonemap now has an additional mix parameter. 0 preserves the input untouched and 1 applies the full node effect (ARNOLD-11172).

  • Ignore imagers option: The global option ignore_imagers has been added to allow users to disable imager post-processing in a scene. This can be useful for debugging and can also be enabled via kick with the -ii flag. (ARNOLD-10720).

  • Improved support for imagers shared by multiple drivers: All imagers, including the denoisers, can now be shared by drivers with different AOV inputs (ARNOLD-11087).

  • Improved imagers refresh rate in IPR: Fullframe imagers will now be updated during rendering so that the imager chain result can be previewed before the entire image has been rendered. This replaces the previous behavior where in some cases we would have to delay the result until after the full frame had finished (ARNOLD-11203).

  • Improved filter performance in progressive rendering: The performance of several filters, including the Triangle, Sinc, Blackman-Harris, Catmull-Rom, and Mitnet filters have been improved when rendering in progressive mode. In some cases, we have seen a 48% improvement in performance and a 20x improvement in memory usage (ARNOLD-10651).

  • Added support for multiple parallel render sessions on CPU: Any Arnold universe can now be rendered using its own render session (only one render session per universe). Those render sessions can be executed in any order, even in parallel.

    The existing API (AiBegin) creates a default universe and render session, which can be used or ignored. Additional universes can be created and destroyed as usual with their API, but there is a new API that allows creating/destroying and using render sessions:

    AtUniverse* universe = AiUniverse();
    AtRenderSession* rs = AiRenderSession(universe);
    . . .
  • Multiple outputs for shaders: Arnold now supports having multiple outputs for shader nodes. Shader outputs can be linked to inputs of other shader nodes in a .ass file or programmatically via the AiNodeLinkOutput() function by optionally specifying which output is desired when linking. When no output is specified, the node's default output parameter will be chosen, preserving Arnold's existing behavior.

    Standard OSL language rules apply when specifying multiple OSL shader outputs. An example OSL shader with three color outputs could look like the following snippet and each output could be connected separately :

    shader test_shader (output color result = color(1, 1, 1),
                        output color good   = color(0, 0, 1),
                        output color bad    = color(1, 0, 0))
    { ... }
  • Visible lights now transparent: The visible lights are now transparent, which matches the behavior of indirectly seen lights. This also has the benefit of allowing black parts of textured lights to be masked away. This is a look-breaking change to fix previously incorrect visible light behavior (ARNOLD-9070).

    Visible lights transparency now matches the reflection
  • kick ascii render mode: kick -ascii allows rendering directly into the terminal. This requires a 24-bit terminal with UTF-8 support. The windows terminal, most Linux terminals, and iTerm support this; Apple's Terminal does not. This will change the resolution of the render to fit within the console, so any images written to disk will likely be very small. Because it is so low res, telling kick to use a small bucket size is recommended, for instance by passing -bs 16 to kick. This can be useful for checking if a render on a remote machine is working (ARNOLD-11146).

  • Render in ACEScg by default: Arnold will now use an OCIO color manager by default. This color manager will use the default OCIO configuration file. Arnold will render in the ACEScg color space by default.  (ARNOLD-11246):

    • The rendering color space in Arnold 6 and older is scene-linear Rec.709-sRGB, it is possible to override the default OCIO color manager to revert back to the previous default color space. For example, you must pass the following argument to kick :
    -set ai_default_color_manager_ocio.color_space_linear "scene-linear Rec.709-sRGB"
    • Arnold assumes tx files are in the rendering space, it is recommended to regenerate tx files when changing the rendering color space
  • Standard OCIO configuration:  Arnold now ships with a standard OCIO configuration exposing common color spaces used for rendering, such as ACEScg and scene-linear Rec.709-sRGB as well as the ACES 1.0 SDR-video ACES output transform for standard dynamic range videoThis configuration is compatible with the default Maya 2022 OCIO configuration. (ARNOLD-11333):

  • Multi-part EXR: The EXR driver can now render AOVs as separate images (parts) in a multi-part EXR file (merged AOVs, in contrast, renders AOVs as layers in a single-part EXR).
    Multi-part works with either scanline or tiled EXRs and is enabled with the driver_exr.multipart boolean parameter.

    • Noice does not work with multi-part EXRs.
  • Write AOVs to multiple formats: It is now possible to output a single AOV in multiple different formats, for example, the following output string will now output the correct result (ARNOLD-11079).

    outputs 2 1 STRING "RGBA FLOAT filter testrender" "RGBA RGB filter testrender2"
  • OSL UDIMs: OSL now uses the same code as Arnold's image node for resolving texture tags, such as UDIMs. This can make OSL texture lookups faster and increase the types of texture tags that can be used from OSL. (ARNOLD-9276).

  • SSS setnames with randomwalk: The sss_setname feature that allows subsurface effects to spread between distinct objects is now supported in the randomwalk mode on CPU (ARNOLD-8140).

    Rollover images to view with sss_setname
  • Use Existing TX: When options.texture_use_existing_tx is set to true, which is the default, Arnold will attempt to use the .tx version of a texture when available. The .tx file must be located in the same directory as the requested source texture and have the same name with the exception of the file extension. For instance, if "foo/bar/floor.png" is requested and "foo/bar/floor.tx" exists then "floor.tx" will be used. Arnold will ignore any requested colorspace conversions when the .tx file is used since we assume the .tx will have the colorspace transform baked in (ARNOLD-4107).

  • Support for MaterialX v1.38: Arnold extends its MaterialX support to v1.38. As a part of this upgrade, looks and materials exported from Arnold will now be expressed as a combination of Nodes and Inputs departing from the previous standard of ShaderRefs and Params. Arnold will still be able to render MaterialX documents exported with earlier versions of Arnold however this may cause a look-breaking change.

  • Cryptomatte 1.1.2: Cryptomatte has been updated to version 1.1.2 (ARNOLD-11270).

GPU Enhancements

  • Reduced VRAM use for polymeshes: The amount of VRAM used by polymeshes is significantly lower in this version. Scenes with heavy subdivision will use around 33% less GPU memory for geometry (ARNOLD-8524).

  • Reduced VRAM use for GPU volumes: In 6.2.1 we started to use NVIDIA's NanoVDB system for rendering OpenVDB volumes on GPU, which greatly reduced the GPU memory required for OpenVDB volumes. In 7.0, compression of NanoVDB volumes has been further improved, so that we see roughly a further 50-60% reduction in GPU memory in typical volumetric scenes. GPU volumes now consume less VRAM than the equivalent CPU volumes consume RAM (note, the red line shows the RAM usage in a separate CPU render). (ARNOLD-11229)
  • Matte support: Support for matte has been added to the GPU integrator. This means the matte closure, matte shader, and matte shape flag are all now supported (ARNOLD-7924).

USD Enhancements

  • USD 21.08: The procedural included in the core SDK is now built using USD 21.08.
  • UsdImaging adapters: Arnold-USD now includes a set of UsdImaging adapters for Arnold specific schemas, that allows direct use of procedurals and Arnold shapes in Hydra. (usd#185 usd#741)
  • Deep rendering: The render delegate now supports rendering of deep AOVs via DelegateRenderProducts. (usd#650)
  • Multiple frames in a single file: The USD writer is now able to append multiple frames to a single USD file. (usd#777)
  • Hydra scene delegate: Arnold-USD now includes an experimental scene delegate for Hydra. (usd#764)
  • Progressive disabled when using Husk: Progressive rendering is now disabled when rendering via husk. (usd#755)
  • Procedural Path Mapping: The procedural now supports Arnold Path Mapping when loading USD files. (usd#818)
  • Custom PrimID Hydra Buffer: The render delegate now uses a dedicated primId AOV to support selections in Hydra viewports. This improves support for render-time procedurals and leaves the built-in id parameter unchanged on shapes. (usd#812)
  • DoubleSided in the Render Delegate: The render delegate now supports the built-in doubleSided parameter on USD primitives and correctly supports overrides via Arnold-specific primvars. (usd#805)
  • Motion Blur using Velocity and Acceleration: The render delegate now extrapolates point positions if velocity or acceleration primvars exist and there are no multiple samples for the position. (usd#673)
  • Light Linking: The procedural now supports light linking. (usd#787)
  • Fast camera updates: The render delegate now handles camera-only updates more efficiently, improving the first time to pixel. (usd#869)
  • Standard Surface Fallback: The render delegate now uses a standard surface as a fallback, when no materials are assigned to a prim. (usd#861)
  • String array parameters: String array primvars are now converted to built-in parameters. (usd#808)
  • Multiple hydra sessions: The render delegate now uses the multiple render session API. (usd#783)

API Additions

  • Multiple render sessions: with the new support for multiple render sessions, there are many API additions (old API is deprecated and uses the default render session):

    // Log settings
    AI_API void AiMsgSetLogFileFlags(const AtRenderSession* rs, int flags);
    AI_API void AiMsgSetConsoleFlags(const AtRenderSession* rs, int flags);
    AI_API int  AiMsgGetLogFileFlags(const AtRenderSession* rs);
    AI_API int  AiMsgGetConsoleFlags(const AtRenderSession* rs);
    // Device selection
    AI_API int AiDeviceSelect(AtRenderSession* render_session, AtDeviceType device_type, const AtArray* device_ids);
    AI_API int AiDeviceAutoSelect(AtRenderSession* render_session);
    AI_API AtDeviceType AiDeviceGetSelectedType(const AtRenderSession* render_session);
    AI_API const AtArray* AiDeviceGetSelectedIds(const AtRenderSession* render_session, AtDeviceType device_type);
    // Rendering
    AI_API AtRenderSession* AiRenderSession(AtUniverse* universe, AtSessionMode mode = AI_SESSION_BATCH);
    AI_API AtUniverse* AiRenderSessionGetUniverse(const AtRenderSession* render_session);
    AI_API void AiRenderSessionDestroy(AtRenderSession* render_session);
    AI_API AtSessionMode AiGetSessionMode(const AtRenderSession* render_session);
    AI_API void AiRenderAddInteractiveOutput(AtRenderSession* render_session, uint32_t output_index);
    AI_API bool AiRenderIsInteractiveOutput(AtRenderSession* render_session, uint32_t output_index);
    AI_API bool AiRenderRemoveInteractiveOutput(AtRenderSession* render_session, uint32_t output_index);
    AI_API void AiRenderRemoveAllInteractiveOutputs(AtRenderSession* render_session);
    AI_API bool AiRenderSetHintBool(AtRenderSession* render_session, AtString hint, bool value);
    AI_API bool AiRenderSetHintInt(AtRenderSession* render_session, AtString hint, int32_t value);
    AI_API bool AiRenderSetHintFlt(AtRenderSession* render_session, AtString hint, float value);
    AI_API bool AiRenderSetHintStr(AtRenderSession* render_session, AtString hint, AtString value);
    AI_API bool AiRenderSetHintArray(AtRenderSession* render_session, AtString hint, AtArray *value);
    AI_API bool AiRenderGetHintBool(const AtRenderSession* render_session, AtString hint, bool& value);
    AI_API bool AiRenderGetHintInt(const AtRenderSession* render_session, AtString hint, int32_t& value);
    AI_API bool AiRenderGetHintFlt(const AtRenderSession* render_session, AtString hint, float& value);
    AI_API bool AiRenderGetHintStr(const AtRenderSession* render_session, AtString hint, AtString& value);
    AI_API bool AiRenderGetHintArray(const AtRenderSession* render_session, AtString hint, const AtArray*& value);
    AI_API AtRenderErrorCode AiRenderBegin(AtRenderSession* render_session, AtRenderMode mode = AI_RENDER_MODE_CAMERA, AtRenderUpdateCallback update_callback = NULL, void* callback_private_data = NULL);
    AI_API AtRenderErrorCode AiRenderEnd(AtRenderSession* render_session);
    AI_API AtRenderStatus AiRenderGetStatus(const AtRenderSession* render_session);
    AI_API void AiRenderInterrupt(AtRenderSession* render_session, AtBlockingCall blocking = AI_NON_BLOCKING);
    AI_API void AiRenderAbort(AtRenderSession* render_session, AtBlockingCall blocking = AI_NON_BLOCKING);
    AI_API void AiRenderResume(AtRenderSession* render_session);
    AI_API void AiRenderRestart(AtRenderSession* render_session);
    AI_API bool AiRenderIsAnyActive();

  • Multiple outputs: the AiNodeLinkOutput() function now allows the caller to optionally select not only a component of the output but also specify which non-default shader output is desired when linking (ie, non-default output "output_B", default output component "r", or non-default output component "output_B.z"). When left unspecified, the default output will be chosen with its full type. OSL shaders' default output can be linked to either specifically or not, whilst C shaders' default output are nameless and thus can't be specified explicitly.

    C shaders can now declare an additional set of output parameters in their node_parameters method using the following set of API functions:

    #define AiOutputByte(n)            AiNodeOutputByte   (params,n);
    #define AiOutputInt(n)             AiNodeOutputInt    (params,n);
    #define AiOutputUInt(n)            AiNodeOutputUInt   (params,n);
    #define AiOutputBool(n)            AiNodeOutputBool   (params,n);
    #define AiOutputFlt(n)             AiNodeOutputFlt    (params,n);
    #define AiOutputRGB(n)             AiNodeOutputRGB    (params,n);
    #define AiOutputRGBA(n)            AiNodeOutputRGBA   (params,n);
    #define AiOutputVec(n)             AiNodeOutputVec    (params,n);
    #define AiOutputVec2(n)            AiNodeOutputVec2   (params,n);
    #define AiOutputStr(n)             AiNodeOutputStr    (params,n);
    #define AiOutputPtr(n)             AiNodeOutputPtr    (params,n);
    #define AiOutputNode(n)            AiNodeOutputNode   (params,n);
    #define AiOutputArray(n,t)         AiNodeOutputArray  (params,n,t);
    #define AiOutputMtx(n)             AiNodeOutputMtx    (params,n);
    #define AiOutputEnum(n,t)          AiNodeOutputEnum   (params,n,t);
    #define AiOutputClosure(n)         AiNodeOutputClosure(params,n);

    C shaders that do have multiple outputs are now informed of which output is required of them during shader evaluation via the AiShaderGlobalsGetSelectedOutput() function:

    AI_API AI_DEVICE int32_t   AiShaderGlobalsGetSelectedOutput(const AtShaderGlobals* sg);

    This function will return a value of -1 when the default/traditional shader node output is requested, which will always be the case in shaders that do not expose multiple output parameters, and return a value greater than or equal to 0 when one of the non-default output parameters is requested. Using this API, a C shader exposing multiple output values could look something like this:

       AiOutputRGB("green"); // first output is indexed as 0
       AiOutputFlt("pi"); // second output is indexed as 1
       const int output_index = AiShaderGlobalsGetSelectedOutput(sg);
       switch (output_index)
          case 0: sg->out.RGB() = AI_RGB_GREEN; return;
          case 1: sg->out.FLT() = AI_PI; return;
          case -1: sg->out. ...; return; // token default value indicating legacy output behavior, shader must return a value of the same type as the node's default output_type in this case
          default: AiMsgError("unreachable shader code, should not be here");

    OSL shaders on the other hand will not only expose a nameless default output selected from the shader's output parameters as before, but also the full set of named output parameters using conventional OSL output parameter declaration.

    Node output parameters of both C and OSL shaders can be inspected through the node entry API using the following functions:

    AI_API AI_PURE int                 AiNodeEntryGetNumOutputs     (const AtNodeEntry* nentry);
    AI_API AI_PURE const AtParamEntry* AiNodeEntryGetOutput         (const AtNodeEntry* nentry, int i);
    AI_API AI_PURE const AtParamEntry* AiNodeEntryLookUpOutput      (const AtNodeEntry* nentry, const AtString param);

    The index of the linked output parameter and output component of both C and OSL shaders can be inspected through the node API using the following function:

    AI_API AtNode* AiNodeGetLinkOutput(const AtNode* node, const char* input, int& output_param, int& output_comp);
  • Supported extension metadata: all file path parameters can be queried for metadata of type extensions to retrieve supported format extensions. (ARNOLD-11159)

  • Linear Color Space Test: the new `AiColorManagerColorSpaceIsLinear` can be used to efficiently check if a given color space is linear. Color Managers can optionally implement color_manager_color_space_is_linear, otherwise, the default implementation will be used. (ARNOLD-6706)

    AI_API bool AiColorManagerColorSpaceIsLinear(AtNode *node, AtString cs);
  • Python bindings for AtParamValueMapIterator API: those were missing from a previous release:

    def AiParamValueMapIteratorDestroy(iterator)
    def AiParamValueMapIteratorGetNext(iterator) -> AtParamValueMapEntry
    def AiParamValueMapIteratorFinished(iterator) -> bool
  • Python bindings for AiMakeTx API: a new parameter has been added so that it can be applied on different universes (as usual, None is a shortcut for the default universe):

    def AiMakeTx(file, flags, universe = None)

Incompatible Changes

  • Removed denoise_optix_filter: With the introduction of the imager_denoiser_optix node, the old denoise_optix_filter code path has become redundant and therefore removed. (ARNOLD-11204)
  • imager_denoiser_optix clamp disabled by default:  The default of the imager_denoiser_optix's clamp parameter has now been set to disabled. (ARNOLD-11187)
  • Support for MaterialX v1.38 : There's a look-breaking change that affects certain materialX documents. If your document contains a connection to a MaterialX nodeGraph without explicitly specifying the output of the nodegraph the node is connecting to, we used to be returning a NULL meaning so the connection was not applied. In this version, if this scenario exists we return the first output to the nodegraph.
  • Multiple render sessions: For the API updated as described above, the old API was maintained as deprecated and is implicitly using the default universe/render session. This will work fine when using the default universe and render session, but any code expected to work on an arbitrary universe/render session will have to be updated with the new API passing an explicit universe or render session.
  • options.pin_threads: pin_threads has been removed from the options node. Threads are now never pinned. (ARNOLD-11073)
  • AiOutputIteratorGetNext: AiOutputIteratorGetNext switched from taking a const char** output_name to the more efficient AtString* output_name. (ARNOLD-11357)
  • Removed source code info from API functions: AiMalloc_func(), AiFree_func(), AiRealloc_func(), AiArrayGet*Func(), and AiArraySet*Func() all took source code info (filename and line number). These functions have been removed and their previous macros (AiMalloc(), AiFree(), AiRealloc(), AiArrayGet*(), and AiArraySet()) which were setting the source code info are now proper functions. If you were using the macros you should not need to modify any code. (ARNOLD-5785, ARNOLD-10754).
  • options.scene_units_in_meters: The scene_units_in_meters option and metadata have been renamed to meters_per_unit, putting them more in line with their equivalents in the USD standard. Note that these values now have an inverse interpretation to what they had before, so implementations must now provide values such that: new_scene_units_value = 1 / old_scene_units_value (ARNOLD-11176)
  • Renamed AiUniverseIsActive to AiArnoldIsActive: The AiUniverseIsActive API function is now renamed to AiArnoldIsActive (ARNOLD-11120)
  • Autodesk Network Licensing version: Arnold 7 switches to ARNOL_2022 licensing. 
    • Single-user subscriptions will work with Arnold 7. The plugin installers automatically register the new version. If you do not use a plugin, then after you download Arnold, open the Arnold License Manager and click Register.
    • Existing network licenses will not work with Arnold 7. Log on to your Autodesk account to generate your new ARNOL_2022 licenses.

Bug Fixes

  • ARNOLD-3573 - Incorrect log color in Windows consoles when using multiple threads
  • ARNOLD-11625 - Empty backtrace when using printBackTrace() outside a crash on Windows
  • ARNOLD-11230 - Low transmission_depth values causes dielectrics to be too dark
  • ARNOLD-11421 - Progressive render IPR can get stuck at final AA level
  • ARNOLD-11178 - Unexpected normal smoothing behavior
  • ARNOLD-11228 - Using ray/shader switches to lower transmission depth causes dielectrics to be too dark
  • ARNOLD-11562 - [Alembic] UV data in curves not interpolated correctly when overriding curve.basis
  • ARNOLD-11361 - [Alembic] user data on curves is interpolated incorrectly
  • ARNOLD-8934 - [GPU] Arnold "Render Section to Texture" crashes Maya
  • ARNOLD-11687 - [GPU] 8-bit RGBA sRGB textures render incorrectly in ACEScg
  • ARNOLD-10996 - [GPU] Crash or artifacts when multiple image nodes point to the same texture
  • ARNOLD-11515 - [GPU] Crash when destroying procedurals interactively using 470 Nvidia drivers
  • ARNOLD-11621 - [GPU] Discrepancy with SSS closures in OSL
  • ARNOLD-11241 - [GPU] Missing alpha channel in RGBA-typed LPE AOVs
  • ARNOLD-11466 - [GPU] denoise_albedo is black on SSS
  • ARNOLD-11444 - [Imagers] Crash after an imager_denoiser_optix error
  • ARNOLD-11087 - [Imagers] Incorrect result when multiple drivers with different AOVs share a single imager
  • ARNOLD-11071 - [MaterialX] Crash when multiple objects share the same material
  • ARNOLD-11089 - [OCIO] OCIOColorManagerGetKnownChromaticities() not working with OCIO environment variable
  • ARNOLD-11538 - [OCIO] Random crashes when using the color API from multiple threads
  • ARNOLD-8521 - [OSL] UDIM textures through OSL do not have their color transform applied
  • ARNOLD-9190 - [Noice] Crash when using a small data window
  • usd#751 Render delegate crashes when changing material terminals interactively
  • usd#797 Warning messages when HdArnoldRenderPass is deleted
  • usd#847 Procedural should check the camera of the proper universe for motion blur settings
  • usd#858 Can't hide/unhide lights in Hydra
  • usd#853 Missing indices for facevarying primvars in Hydra abort renders
  • usd#871 Enforce writing multiple frames when no default is authored
  • usd#802 B-spline curves not using radius in procedural
  • usd#798 SdfMetadata clashing with another NdrDiscovery plugin
  • usd#816 The procedural does not use "driver:parameters:aov:name"
  • usd#880 Scenes using pre-21.02 light parameters are not rendering correctly
  • usd#884 Render delegate shouldn't call AiBegin/AiEnd if Arnold is already active
  • usd#843 Disabling render purposes does not hide geometries in Hydra
  • usd#887 Int parameters are not converted to unsigned int shader parameters in the render delegate

  • No labels
Privacy settings / Do not sell my personal information / Privacy/Cookies