Milestone 4.0

Enhancements

  • Provide displacement derivatives: Estimates for the dPdx, dPdy, dudx, dudy, dvdx and dvdy shader globals are now being provided to the displacement shader for each vertex where it is evaluated. With this information the displacement shader now performs filtered texture map lookups, potentially reducing the amount of texture file I/O, sometimes by 10-20x depending on the size of the tessellated polygons: the bigger the polygons, the less texture will be loaded. This enhancement can change the rendered image but if so desired it can be toggled via the newenable_displacement_derivs render option. (#1313)
  • Smooth tangents for subdivision surfaces: Subdivision meshes are now capable of generating "limit" dPdu & dPdv derivatives which allow for anisotropic shaders to have a smoother appearance. Previously, these derivatives were constant per triangle, which resulted in a faceted appearance. The generation of smooth derivatives can be enabled per mesh via the new subdiv_smooth_derivs parameter. Please note that this capability requires storing roughly 100 extra bytes of data per vertex per keyframe so we are disabling it by default. (trac#2339)
  • Multi-threaded DSO procedural loading: DSO-based procedural nodes can now be processed in parallel, meaning that different threads can work on expanding different procedurals. Previously, there was a global lock around procedural expansion which only allowed one procedural to be expanded at a time. The new, multi-threaded code can provide significant speedups in scenes whose load time is dominated by many CPU-bound procedurals. Note that this does not yet apply to .ass-based procedurals/standins, which we plan to multi-thread in a future release. (#2108)
  • Automatic AOV blending through semi-transparent surfaces: Via the enable_aov_composition render option, it is now possible for AI_TYPE_RGB AOVs registered with the AI_AOV_BLEND_OPACITY blending mode to automatically compose through semi-opaque surfaces rendered using auto-transparency. Due to the potentially drastic changes to AOVs that this change can cause as well as the associated performance hit, AOV composition is turned off by default. Performance will be improved in a future release. (#2455)
  • Export composable AOVs from standard, lambert and hair shaders: Taking advantage of the new AOV composition functionality, AOVs with opacity-blending capability have been added to these built-in shaders. In particular, the hair shader now has direct_diffuse,direct_specular and indirect_diffuse AOVs. (#2455, #2606, #2610)
  • Reduced peak memory usage for ray accels: The peak memory usage while building the ray tracing acceleration data structures has been significantly reduced, often by half. This can help when rendering large objects such as multi-million polygon/hair/particle objects. Note that this peak is usually not reported by the Arnold statistics, but it can still be noticed by faster build times when previous versions ran out of physical memory. This has yet to be applied to deformation blur. (#1547, #2523)
  • Reduced memory usage for importance tables: The memory used for importance tables in the skydome_light and in texture-mapped quad_light nodes has been reduced to around 33% of the original by using RGBE encoding. This can have an effect in scenes with many textured area lights. (#2534)
  • Reduced memory usage for points primitive: The disk and sphere modes of the points primitive now always use 33% less memory. If the radii are all the same, they use 50% less memory. (trac#2301)
  • Faster points primitive in quad mode: The quad mode of the points primitive now renders about 15% faster thanks to various ray intersection optimizations. (#2495, #2607)
  • Faster motion blurred matrices: The underlying matrix math has been vectorized, resulting in a few percent faster rendering time for scenes which have objects with motion blurred matrices. (#2570)
  • Faster trigonometric/trascendental math: The trigonometric/trascendental math functions used inside the renderer (sin, cos, atan, exp etc) have been replaced with either fast, approximate versions, or with 4-way parallel versions. This results in 1.1x - 1.5x speedups for simple scenes. The speedups won't be as big for complex production scenes. (#2495, #2556, #2557, #2588)
  • Faster pixel filters: The Gaussian, Blackman-Harris, Cook and Sinc filters have been optimized for speed. This can result in ~2x speedups in simple scenes with lots of empty pixels or when using a high number of AOVs and AA samples. (#2553, #2558, #2560, #2561, #2564)
  • Faster texture lookups in image node: The texture lookups in the image shader have been optimized by using the handle-based lookup API introduced in this release. This can provide significant speedups when rendering textures with long filenames with many threads. For benchmarking purposes, the lookups can be switched to use the old, less efficient lookups by disabling the new parameter cache_texture_handles. (#1546)
  • base85 encoding of large float arrays: The default encoding for float arrays in .ass files has been changed to base85, which is more efficient in both file size and read/write time over the previous base64 encoding. Older scenes written with base64 encoding or with no binary encoding at all can still be read normally. (#2444)
  • Energy preserving SSS: The normalization factor for the cubic BSSRDF in AiSSSPointCloudLookup() was incorrect by a factor of 4/(10/pi), or ~1.2566. We have now corrected this bug, which makes the SSS effect a bit darker but truly energy conserving. This can be verified by rendering a 100% white SSS sphere illuminated by a flat white sky, which will now be invisible as expected. Users who upgrade to this release in the middle of a show, and find that the SSS component in their materials is noticeably darker, should simply multiply Ksss by the constant 1.2566. If your show uses custom shaders, this can be easily fixed in the shader code instead of fixing all the materials: (#2535)
    AtColor sss = AiSSSPointCloudLookupCubic() * 1.2566;
    
  • Added reference_time: The old sss_time option has been renamed to reference_time so that it can be used for two different things. On one hand, the SSS pointclouds will be computed at precisely this time (which is what sss_time was used for). On the other hand, when disabling motion blur with the ignore_motion_blur option, the time specified by reference_time will be used instead of the shutter open time. This fixes the problem where a scene was setup with "centered" motion blur (for example: shutter=[-0.25,+0.25]) and enabling ignore_motion_blurwould produce a scene rendered at time=-0.25 instead of time=0, which had an unexpected impact on motion vector passes. The default value of 0 will be what the user wants in 99% of cases. (#2447)
  • Implicit AOV type conversion from POINT2 to POINT/VECTOR: A POINT2 AOV can now be stored in an image of POINT or VECTOR type. The Z component will be set to zero. (#2448)
  • Removed various unused options: The unbounded parameter in geometry nodes, the packet_* global options, and the solid_angle parameter of the quad_light node have all been removed. These were legacy or experimental parameters that offered absolutely no value to the user and were taking unnecessary storage as well as causing confusion. (#2529, #2562, #2567)
  • Ignore options in .ass procedurals: To avoid non-deterministic results in deferred loading of .ass files via procedural nodes, any options nodes that may have been inadvertently left inside .ass files intended for deferred loading (e.g. standins) are now filtered out and ignored. (#2519)
  • Log file enhancements:
    • modern CPUs that were reported as "GenuineIntel" or even "Unknown Intel" are now properly reported thanks to improved CPU identification code (#2545)
    • .ass parsing warning/error messages have now the form "[ass] line <n>: <error string>" (#2483)
    • .ass line numbers are now reported more accurately (they used be off by +-1 line) (#2486)
    • orphan node blocks in .ass files are now explicitely reported (#2472)
    • read/written bytes/nodes when parsing .ass files (#2488)
    • better warning messages when parsing unknown parameters (#2487)
    • added new warning for misplaced parameter values (#2487)
    • the active camera is now reported (#2498)
    • the version of the RLM licensing library is now reported (#2475)
  • Upgraded RLM to 9.2BL2: We have upgraded the external library controlling the licensing subsystem from version 7.0BL4 to 9.2BL2, increasing the stability and opening the door to future enhancements. (#2411)
  • Upgraded OIIO to 0.10.4: There have been numerous bugfixes and performance improvements since the last OIIO version we shipped with Arnold (which was 0.10.0) including: (trac#2374)
    • Improved robustness of texture lookups with very small derivatives. In some cases, this leads to a 2-3x speedup.
    • Various threading performance improvements, including fixing a dramatic slowdown when autotile is enabled.
    • Various precision-related bug fixes for PNG, ICO and Targa files.
    • maketx: fixes to sinc, blackman-harris filters.
    • maketx: --hash is deprecated, the SHA-1 hash is always computed; the hash takes into account upstream image changes, such as resizing.
    • maketx: the --filter command line argument only takes the filter name, the width is now automatically computed.
  • No need to set Arnold path for Python bindings: Users of the Python bindings are no longer required to manually set the {DYLD|LD}_LIBRARY_PATH environment variable, as the Arnold path is now determined automatically. (#2578)

API additions

  • Alternate, faster texture mapping API: In addition to the existing filename-based texture lookup, we have added a handle-based texture lookup. This new API has much better threading scalability in particular when hyper-threading is enabled. We have seen ~1.2x speedups in texture/autobump heavy scenes, but in simple scenes with very long filenames the speedup was closer to 2x. The texture handle is typically created in the shader's node_initialize (or better, in node_update if the texture needs to change in IPR) and released in node_finish. The built-inimage shader has been modified to use texture handles by default. (#1546)
    struct AtTextureHandle;
    
    AI_API AtTextureHandle* AiTextureHandleCreate(const char* filename);
    AI_API AtRGBA           AiTextureHandleAccess(const AtShaderGlobals* sg, AtTextureHandle* handle, const AtTextureParams* params, bool* success = NULL);
    AI_API void             AiTextureHandleDestroy(AtTextureHandle* handle);
    
  • AiTextureAccess() returns a success value: An optional argument has been added to the end of the argument list which allows client applications to check for errors during texture lookups. This change is backwards-compatible. Existing client code will continue to compile and operate with no behavioural changes. The new signature is: (#2461)
    AI_API AtRGBA AiTextureAccess(const AtShaderGlobals* sg, const char* filename, const AtTextureParams* params, bool* success = NULL);
    
  • Added filter width controls to AtTextureParams: The new parameters width_s and width_t in the AtTextureParams struct can be used to control the filter width, or blurriness, of the texture lookups. The default value is 1.0, which means no additional blurring. This removes the need for the temporary AiTextureAccessResized() symbol introduced earlier. (#2458)
       float   width_s;    /**< amount of widening of look-ups on the S axis */ 
       float   width_t;    /**< amount of widening of look-ups on the T axis */ 
    
  • Added missing AiUDataGetMatrix(): This API was missing for no good reason. The matrix type is now fully supported in constant, uniform and varying user data. (#2464, #2473, #2528, #2530)
  • AiNodeEntryInstall() / AiNodeEntryUninstall(): These functions replace the previously misnamed AiNodeInstall() / AiNodeUninstall(), which have been moved to the ai_deprecated.h header file. (#2068)
  • Added new APIs to access AtNode fields that were previously public: Because AtNode is now an opaque type, we are introducing new API functions to access the missing information: (#2057)
    AI_API const AtNodeEntry*  AiNodeGetNodeEntry(const AtNode* node);
    AI_API AtParamValue*       AiNodeGetParams(const AtNode* node);
    AI_API void*               AiNodeGetLocalData(const AtNode* node);
    AI_API void                AiNodeSetLocalData(AtNode* node, void* data);
    
  • Added node filtering in AiASSLoad(): The AiASSLoad() function can now load specific types of nodes, just like in AiASSWrite(). Also, default values have been added for some parameters so that client code that uses the old function signatures still compiles. The new signatures are: (#1926)
    AI_API int AiASSWrite(const char* filename, int mask = AI_NODE_ALL, bool open_procs = FALSE);
    AI_API int AiASSLoad (const char* filename, int mask = AI_NODE_ALL);
    
  • Added API for registration and iteration of AOVs: Custom AOVs can now be registered via the AiAOVRegister() function: (#1947)
    AI_API bool AiAOVRegister(const char* name, int type, int blend_mode = AI_AOV_BLEND_NONE);
    
    When registered, these AOVs get added to the global list of AOVs, which already contains the list of built-in AOVs. This list can be iterated with the following API:
    AI_API AtAOVIterator*    AiUniverseGetAOVIterator();
    AI_API void              AiAOVIteratorDestroy(AtAOVIterator* iter);
    AI_API const AtAOVEntry* AiAOVIteratorGetNext(AtAOVIterator* iter);
    AI_API bool              AiAOVIteratorFinished(const AtAOVIterator* iter);
    
  • Added new shader linking API functions: New functions have been added, and some existing ones modified, to provide support for separate component linking and array element linking. (#2052, #2053)
    AI_API bool    AiNodeLink(AtNode* src,  const char* input, AtNode* target);
    AI_API bool    AiNodeLinkOutput(AtNode* src,  const char* output, AtNode* target, const char* input);
    AI_API bool    AiNodeUnlink(AtNode* node, const char* input);
    AI_API bool    AiNodeIsLinked(const AtNode* node, const char* input);
    AI_API AtNode* AiNodeGetLink(const AtNode* node, const char* input, int* comp = NULL);
    
  • Added Gaussian BSSRDF support: Besides the already existing SSS cubic diffusion profile, a new gaussian difussion profile is now supported. This allows shader writers to experiment with different strategies for mixing gaussians. (#2532)
    AI_API AtColor AiSSSPointCloudLookupGaussian(const AtShaderGlobals* sg, const AtColor& variance);
    
  • Added point cloud sample API: Methods to iterate over the SSS pointcloud samples generated by Arnold have been provided. (#2208)
    struct AtPointCloudSample {
       AtPoint  pref_position;
       AtPoint  world_position;
       AtVector normal;
       AtUInt32 face;
       AtPoint2 uv;
       float    area;
    };
    struct AtPointCloudIterator;
    AI_API AtUInt32              AiPointCloudGetSampleCount(const AtShaderGlobals* sg);
    AI_API AtPointCloudIterator* AiPointCloudIteratorCreate(const AtShaderGlobals* sg);
    AI_API void                  AiPointCloudIteratorDestroy(AtPointCloudIterator* iter);
    AI_API AtPointCloudSample    AiPointCloudIteratorGetNext(AtPointCloudIterator* iter);
    AI_API bool                  AiPointCloudIteratorFinished(const AtPointCloudIterator* iter);
    
  • Added method to evaluate irradiance at SSS point samples: A new function has been added to be able to measure the irradiance at the point samples provided by the new point cloud sample API. (trac#2350)
    AI_API AtRGB AiSSSEvaluateIrradiance(const AtShaderGlobals* sg, float u, float v, AtUInt32 face, const AtPoint* p, AtUInt32 index);
    
  • Added default render mode in AiRender(): The mode argument in the AiRender() API call now has a default value of AI_RENDER_MODE_CAMERA. It is now legit to call AiRender() without an explicit argument, which is much shorter to type. (#2613)
  • Added new AiArrayInterpolateXxx functions: These new functions in the array API can be used to evaluate the value of an array element at a given time. (#2521)
    AI_API AtPoint   AiArrayInterpolatePnt(const AtArray* array, float time, AtUInt32 idx);
    AI_API AtVector  AiArrayInterpolateVec(const AtArray* array, float time, AtUInt32 idx);
    AI_API float     AiArrayInterpolateFlt(const AtArray* array, float time, AtUInt32 idx);
    AI_API void      AiArrayInterpolateMtx(const AtArray* array, float time, AtUInt32 idx, AtMatrix result);
    

Incompatible changes

  • Moved decay_type to each of the lights: The decay_type parameter of the light_decay filter has been moved to those light source nodes where it makes sense to have decay: point_light, spot_light, quad_light, disk_light and cylinder_light. This makes it no longer necessary to create a light filter node and attach it to the filters parameter of the light if all you needed to change is the decay type. (#2457)
  • Changed default light decay to quadratic: Previous default was constant, so existing scenes may need this value to be explicitly changed in order to render correctly. (#2509)
  • Removed linear and cubic light decay types: These two legacy decay types don't make sense in a physically-based system. The only two supported decay types are now quadratic and constant. Note that certain critical features of the renderer such as MIS only work with quadraticdecay. (#2459)
  • Removed decay_clamp and decay_radius from light_decay filter: In an effort to simplify the system, we are removing these rarely used parameters. In particular, the decay_clamp parameter is of little help now that the lights all have multiple importance sampling (MIS) support. (#2340)
  • Changed default specular BRDF in standard shader to cook_torrance: The previous default for standard.specular_brdf was stretched_phong, which is an older BRDF suffering from energy loss at grazing angles. Scenes with shaders that didn't explicitly set specular_brdf may now render different. (#2548)
  • Fixed const-correctness in several API functions: We are taking the opportunity to enforce const-correctness in a few places like AiMakeRay(), AiCameraGetLocalData (), AiNodeGet*(), AiNodeGetLink(), AiNodeClone(), AiArrayConvert(), DriverSupportsPixelType(),AiDriverGetLocalData(), FilterOutputType(), AiFilterGetLocalData(), AiM4*, AiAOVGet*(), AiShaderEvalParam*(), AiMetaDataIteratorFinished(). (#1882, #2238)
  • Hide AtNode implementation: The contents of the AtNode struct are now hidden from the public API. Some new API functions have been added to provide access to hidden data (e.g. AiNodeGetNodeEntry (), see the API additions section). (#2057)
  • AiNodeLink() and AiNodeUnlink() now return a success value: The new signatures are: (#2485)
    AI_API bool AiNodeLink(AtNode* src, const char* param, AtNode* dest); 
    AI_API bool AiNodeUnlink(AtNode* node, const char* param); 
    
  • Added comp argument to AiNodeGetLink(): This new parameter is used to return the output component selected in the source node. If no particular component was selected, -1 is returned meaning "the whole output"; if a single component was selected, then a value in 0..3 is returned. This parameter has a default value of NULL which means that the return value is not requested. Other than requiring a recompile, existing client code will be unaffected by this change. (#2052)
    AI_API AtNode* AiNodeGetLink(const AtNode* node, const char* input, int* comp = NULL);
    
  • Added tid argument to camera_create_ray: The persp_camera node was sometimes crashing when using UV remapping because the camera_create_ray method wasn't thread-safe. This has been fixed by explicitly passing the thread ID as an argument. (#2499)
  • Changed Cubic BSSRDF signature: (#2532) Since a new Gaussian BSSRDF was added, the old lookup API AiSSSPointCloudLookup() has been removed and renamed to:
    AI_API AtColor AiSSSPointCloudLookupCubic(const AtShaderGlobals* sg, const AtColor& radius);
    
  • Changed AiRender() return type from unsigned int to int: Because one of the return values of this function was -1 (AI_ERROR) it doesn't make sense to return unsigned int. (#2482)
  • Modified math for noise.amplitude: The output of the shader now converges to a value of 0.0 when the amplitude goes to 0.0 (it previously converged to 0.5). (#2489)
  • Renamed AiParameterXXX API to AiParameterXxx: This was done for consistency with the AiNodeGetXxx() functions. (#2470)
  • Removed mis parameter from all lights: For optimal results, multiple importance sampling should always be enabled, so the per-light mis parameter has been removed. We have added a ignore_mis global setting to ignore MIS for all lights for debugging/benchmarking purposes. (#2510)
  • Removed AiNodeInstall() and AiNodeUninstall(): Use AiNodeEntryInstall() and AiNodeEntryUninstall() instead. (#2068)
  • Removed sss_time: Use reference_time instead, see the Enhancements section above. (#2447)
  • Removed AtFloat and AtDouble from the public API: These were silly types. Use float and double instead. Note that the renderer works with single-precision floats internally, and in previous releases we have already removed unnecessary uses of double-precision in the public API. (#2467, #2468)
  • Removed AtVoid from the public API: Use void instead. (#2466)
  • Removed AtChar from the public API: Use char instead. (#2504)
  • Removed AtBoolean from the public API: AtBoolean is now deprecated, and all uses of it in the public API have been removed. You should use bool instead. Similarly, the TRUE and FALSE macros have been deprecated in favor of the more standard true and false. (#2507)
  • Removed AtInt and AtUInt from the public API: Use int and unsigned int instead. (#2506)
  • Removed AtLong and AtULong from the public API: These types had a different byte size in different platforms and therefore caused subtle bugs. You should use the AtUInt32 or AtUInt64 types instead, depending on what size you need. (#2469)
  • Removed AiTextureAccessResized(): Use the new AtTextureParams fields width_s and width_t instead. (#2458)
  • Removed legacy BRDFs: Some of our oldest BRDFs that don't work well in a modern physically-based system have been removed: (#2232)
    • AiTorranceSparrowBRDF()
    • AiBlinnPhongBRDF()
    • AiPhongBRDF()
    • AiModifiedPhongBRDF()
    • AiLafortuneLobeBRDF()
    • AiModifiedPhongIntegrate()
    • AiLafortuneLobeIntegrate()
    • AiLafortuneLobeGetDir()
  • Removed make_local_copy parameter from AiArrayConvert: This parameter is now effectively hardcoded to true. AtArray always owns its data memory (it allocates and deallocates the memory itself). The corresponding boolean in the AtArray structure has also been removed. (#2501)
  • Removed AiShaderGlobalsCalculateNormal() and AiShaderGlobalsGetBumpStates(): These functions have been deprecated for quite some time. Use AiShaderGlobalsEvaluateBump() instead. (#2282)
  • Removed diffuse AOV from lambert shader: The lambert shader no longer exports the diffuse AOV and instead follows the example of the standard shader and exports the composable direct_diffuse and indirect_diffuse AOVs. (trac#2610)
  • Corrected parameter types in the AtArray API: Some parameter types have been changed to better reflect the actual type of the data being passed. The number of elements is now limited to AtUInt32, and the number of motion keys to AtByte. The type parameter is now an AtByte. In any case, the total number of items (number of elements times number of keys) is limited to 232. (#2514)
  • Changed return type of AtBRDFEvalBrdfFunc to AtColor: The return type of AtBRDFEvalBrdfFunc functions used for MIS sampling via the AiEvaluateLightSample() API function has been changed from float to AtColor. As a result, the previous method of using chromatic BRDFs with MIS by setting the ARNOLD_CHROMATIC_BRDF environment variable is now obsolete and has been removed. (#2229)
  • Renamed dOdx and dOdy in AtShaderGlobals: Both the naming and the comments for those data members in AtShaderGlobals were very confusing. They implied that these fields hold the derivatives of the ray origin, but actually it's the derivatives of the surface position being shaded. They are now renamed to dPdx and dPy. (#2552)
  • Added parameters to AiRadiance() and AiIrradiance(): These functions now receive a thread ID and a point ID, which allows them to be used in multi-threaded code. The new API looks like this: (#2156)
    AI_API AtColor AiIrradiance(const AtPoint* p, const AtVector* n, AtByte tid, AtUInt32 pid);
    AI_API AtColor AiRadiance(const AtPoint* p, const AtVector* dir, const AtVector* n, AtNode* obj, AtUInt32 face, float u, float v, AtNode* shader, AtByte tid, AtUInt32 pid);
    
  • Removed AiRadianceSG() and AiIrradianceSG(): These functions are obsolete, as the fixes have been incorporated into AiRadiance and AiIrradiance. (#2156)
  • Replaced macros with inline functions in the API: All the existing macros in the public API have been replaced by inlined functions, to allow for better error checking and help with performance by avoiding redundant evaluation of expressions. While most of these changes are transparent to the user, there have been some incompatible changes that affect client code: (#2518, #2617)
    • In general, for functions with more than one parameter, the use of a single type might force some client code to add an explicit type cast. For example, if there was a call like MAX(1, 2.0f), you will now have to manually resolve the type ambiguity, by using either MAX(1, 2) for integers, or MAX(1.0f, 2.0f) for floats. These changes might seem annoying at first, but they will give you better control over your code, and the compiler will be able to do better optimization.
    • SWAP() now receives 2 parameters instead of 3 (you no longer have to pass a temporary variable). Note that we provide SWAP() for legacy reasons only, and std::swap could be used instead.
    • AiFaceViewer() now takes 2 parameters: the shaderglobals struct pointer, and the normal vector to calculate. Previously, the macro was sneakily passing sg.

Bug fixes

 

 

TicketSummaryComponentOwnerPriorityVersionCreated
#1610exception crash when reading textures from non-existing drivesoiioangelcritical3.0.52 years
#2350improve irradiance baking for SSS pointclouds from a shaderarnoldalancritical3.35 months
#2455AOV blending through semi-opaque surfaces w/auto-transparencyarnoldalancritical3.33 months
#2473'AiUDataGet*()' doesn't work with 'constant' user data in linux/darwinarnoldoscarcritical3.32 months
#2574Flickering with "blue_noise_Pref" SSS sample distributionarnoldoscarcritical3.34 weeks
#2378Inconsistency when referencing non-existent shadersarnoldoscarmajor3.34 months
#2424PNG associateAlpha + gamma lost all precisionoiiothiagomajor3.33 months
#2440precision problem in point_light's light_tracearnoldoscarmajor3.33 months
#2446Math typo when computing tangents in subdiv codearnoldoscarmajor3.33 months
#2449AiTextureGet*() doesn't take ignore_textures into accountarnoldoscarmajor3.33 months
#2463fix documentation errors in world/camera/screen matrix APIarnoldmarcosmajor3.32 months
#2465Node names containing spaces should be wrapped in quotes when written to .assarnoldangelmajor3.32 months
#2474light samples sometimes traveling through solid objectsarnoldalanmajor3.32 months
#2477Procedural error when either 'min' or 'max' is not especifiedarnoldangelmajor3.32 months
#2486Wrong reported lines in '.ass' parsing warnings/errorsarnoldoscarmajor3.32 months
#2487fix double warning when parsing unknown parameters in .ass filesarnoldoscarmajor3.32 months
#2489Bug in the amplitude parameter of the built-in noise shaderarnoldangelmajor3.32 months
#2492poor multi-threading performance when autotile is enabledoiioramonmajor3.32 months
#2493Better '.ass' parsing for mismatched number of expected valuesarnoldoscarmajor3.32 months
#2494crash with forward references in light_grouparnoldoscarmajor3.32 months
#2497Crash when connecting 'volume_scattering' to light's 'volume_density'arnoldoscarmajor3.38 weeks
#2499persp_camera UV distortion not thread safearnoldoscarmajor3.38 weeks
#2513shadowing options are not overriden in instancesarnoldoscarmajor3.37 weeks
#2522hair diffuse cache brighter than expected (not energy conserving)arnoldmarcosmajor3.37 weeks
#2525hair diffuse cache not affected by the light's affect_diffuse parameterarnoldmarcosmajor3.37 weeks
#2526hair shader is hardcoded to 1 bounce when using the diffuse cachearnoldmarcosmajor3.37 weeks
#2528Support varying matrix user dataarnoldoscarmajor3.37 weeks
#2535Cubic BSSRDF normalization is incorrectarnoldmarcosmajor3.36 weeks
#2544motion-blurred subdivision surface not correctly computing limit normals at boundariesarnoldalanmajor3.36 weeks
#2554kick -af is missing support for blackman_harris filterkickmarcosmajor3.35 weeks
#2566crash/hang with consecutive SIGINT/SIGTERMarnoldoscarmajor3.35 weeks
#2575cylinder and disk lights conspiring to kill each other offarnoldoscarmajor3.34 weeks
#2579crash with subdivision and motion-blurarnoldmarcosmajor3.34 weeks
#2584erroneous composition of alpha value of atmosphere shadersarnoldalanmajor3.33 weeks
#2597Cloning of nodes inside procedurals is not workingarnoldangelmajor3.313 days
#2598pykick is broken after `AiASSLoad()` changeskickoscarmajor3.313 days
#2601Replace use of non-standard _declspec with __declspecarnoldangelmajor3.312 days
#2600points are not recording indices memory in statsarnoldthiagominor3.313 days
  • No labels