|
| | ThreadKernelGlobalsCPU (const KernelGlobalsCPU &kernel_globals, OSLGlobals *osl_globals_memory, Profiler &cpu_profiler, const int thread_index) |
| | ThreadKernelGlobalsCPU (ThreadKernelGlobalsCPU &other)=delete |
| | ThreadKernelGlobalsCPU (ThreadKernelGlobalsCPU &&other) noexcept=default |
| ThreadKernelGlobalsCPU & | operator= (const ThreadKernelGlobalsCPU &other)=delete |
| ThreadKernelGlobalsCPU & | operator= (ThreadKernelGlobalsCPU &&other)=delete |
| void | start_profiling () |
| void | stop_profiling () |
| __forceinline uint32_t | __bsf (const uint32_t x) |
| __forceinline uint32_t | __bsr (const uint32_t x) |
| __forceinline uint32_t | __btc (const uint32_t x, const uint32_t bit) |
| __forceinline uint32_t | __bsf (const uint64_t x) |
| __forceinline uint32_t | __bsr (const uint64_t x) |
| __forceinline uint64_t | __btc (const uint64_t x, const uint32_t bit) |
| __forceinline uint32_t | bitscan (const uint32_t value) |
| __forceinline uint64_t | bitscan (const uint64_t value) |
| ccl_device_inline size_t | align_up (const size_t offset, const size_t alignment) |
| ccl_device_inline size_t | divide_up (const size_t x, const size_t y) |
| ccl_device_inline size_t | divide_up_by_shift (const size_t x, const size_t y) |
| ccl_device_inline size_t | round_up (const size_t x, const size_t multiple) |
| ccl_device_inline size_t | round_down (const size_t x, const size_t multiple) |
| ccl_device_inline bool | is_power_of_two (const size_t x) |
| ccl_device_inline void | print_float (const ccl_private char *label, const float a) |
| ccl_device_inline uchar2 | make_uchar2 (const uchar x, const uchar y) |
| ccl_device_inline uchar3 | make_uchar3 (const uchar x, const uchar y, uchar z) |
| ccl_device_inline uchar4 | make_uchar4 (const uchar x, const uchar y, uchar z, const uchar w) |
| ccl_device_inline bool | operator== (const uchar4 a, const uchar4 b) |
| ccl_device_inline int2 | make_int2 (const int x, const int y) |
| ccl_device_inline int2 | make_int2 (const int i) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN struct | ccl_try_align (16) int3 |
| ccl_device_inline int3 | make_int3 (const int x, const int y, int z) |
| ccl_device_inline int3 | make_int3 (const int i) |
| ccl_device_inline void | print_int3 (const ccl_private char *label, const int3 a) |
| ccl_device_inline packed_int3 | make_packed_int3 (const int x, const int y, int z) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN struct | ccl_try_align (16) int4 |
| ccl_device_inline int4 | make_int4 (const int x, const int y, int z, const int w) |
| ccl_device_inline int4 | make_int4 (const int i) |
| ccl_device_inline int4 | zero_int4 () |
| ccl_device_inline void | print_int4 (const ccl_private char *label, const int4 a) |
| struct | ccl_try_align (32) vint8 |
| ccl_device_inline vint8 | make_vint8 (const int a, const int b, int c, const int d, int e, const int f, int g, const int h) |
| ccl_device_inline vint8 | make_vint8 (const int i) |
| ccl_device_inline vint8 | make_vint8 (const int4 a, const int4 b) |
| ccl_device_inline uint2 | make_uint2 (const uint x, const uint y) |
| ccl_device_inline uint3 | make_uint3 (const uint x, const uint y, uint z) |
| ccl_device_inline packed_uint3 | make_packed_uint3 (const uint x, const uint y, uint z) |
| ccl_device_inline uint4 | make_uint4 (const uint x, const uint y, uint z, const uint w) |
| __forceinline float | float2::operator[] (int i) const |
| __forceinline float & | float2::operator[] (int i) |
| ccl_device_inline float2 | make_float2 (const float x, const float y) |
| ccl_device_inline float2 | make_float2 (const float f) |
| ccl_device_inline float2 | make_float2 (const int2 i) |
| ccl_device_inline int2 | make_int2 (const float2 f) |
| ccl_device_inline void | print_float2 (const ccl_private char *label, const float2 a) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN struct | ccl_try_align (16) float3 |
| ccl_device_inline float3 | make_float3 (const float x, const float y, float z) |
| ccl_device_inline float3 | make_float3 (const float f) |
| ccl_device_inline float3 | make_float3 (const float2 a) |
| ccl_device_inline float3 | make_float3 (const float2 a, const float b) |
| ccl_device_inline float3 | make_float3 (const int3 i) |
| ccl_device_inline float3 | make_float3 (const float3 a) |
| ccl_device_inline void | print_float3 (const ccl_private char *label, const float3 a) |
| ccl_device_inline float2 | make_float2 (const float3 a) |
| ccl_device_inline int4 | make_int4 (const float3 f) |
| ccl_device_inline int3 | make_int3 (const float3 f) |
| struct | ccl_try_align (16) float4 |
| ccl_device_inline float4 | make_float4 (const float x, const float y, float z, const float w) |
| ccl_device_inline float4 | make_float4 (const float f) |
| ccl_device_inline float4 | make_float4 (const float3 a, const float b) |
| ccl_device_inline float4 | make_float4 (const float3 a) |
| ccl_device_inline float4 | make_homogeneous (const float3 a) |
| ccl_device_inline float4 | make_float4 (const int4 i) |
| ccl_device_inline float3 | make_float3 (const float4 a) |
| ccl_device_inline int4 | make_int4 (const float4 f) |
| ccl_device_inline void | print_float4 (const ccl_private char *label, const float4 a) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN struct | ccl_try_align (32) vfloat8 |
| ccl_device_inline vfloat8 | make_vfloat8 (const float f) |
| ccl_device_inline vfloat8 | make_vfloat8 (const float a, const float b, float c, const float d, float e, const float f, float g, const float h) |
| ccl_device_inline vfloat8 | make_vfloat8 (const float4 a, const float4 b) |
| ccl_device_inline void | print_vfloat8 (const ccl_private char *label, const vfloat8 a) |
| ccl_device_inline vint8 | make_vint8 (const vfloat8 f) |
| ccl_device_inline int | abs (const int x) |
| ccl_device_inline int | max (const int a, const int b) |
| ccl_device_inline int | min (const int a, const int b) |
| ccl_device_inline uint32_t | max (const uint32_t a, const uint32_t b) |
| ccl_device_inline uint32_t | min (const uint32_t a, const uint32_t b) |
| ccl_device_inline uint64_t | max (const uint64_t a, const uint64_t b) |
| ccl_device_inline uint64_t | min (const uint64_t a, const uint64_t b) |
| template<class T> |
| ccl_device_inline std::enable_if_t< std::is_same_v< T, size_t >, T > | max (T a, T b) |
| template<class T> |
| ccl_device_inline std::enable_if_t< std::is_same_v< T, size_t >, T > | min (T a, T b) |
| ccl_device_inline float | max (const float a, const float b) |
| ccl_device_inline float | min (const float a, const float b) |
| ccl_device_inline double | max (const double a, const double b) |
| ccl_device_inline double | min (const double a, const double b) |
| template<typename T> |
| ccl_device_inline T | min4 (const T &a, const T &b, const T &c, const T &d) |
| template<typename T> |
| ccl_device_inline T | max4 (const T &a, const T &b, const T &c, const T &d) |
| ccl_device_inline float | min4 (const float a, const float b, float c, const float d) |
| ccl_device_inline float | max4 (const float a, const float b, float c, const float d) |
| template<typename T> |
| ccl_device_inline T | make_zero () |
| ccl_device_template_spec float | make_zero () |
| ccl_device_inline int | as_int (const uint i) |
| ccl_device_inline uint | as_uint (const int i) |
| ccl_device_inline uint | as_uint (const float f) |
| ccl_device_inline int | __float_as_int (const float f) |
| ccl_device_inline float | __int_as_float (const int i) |
| ccl_device_inline uint | __float_as_uint (const float f) |
| ccl_device_inline float | __uint_as_float (const uint i) |
| template<typename T> |
| ccl_device_inline uint | pointer_pack_to_uint_0 (T *ptr) |
| template<typename T> |
| ccl_device_inline uint | pointer_pack_to_uint_1 (T *ptr) |
| template<typename T> |
| ccl_device_inline T * | pointer_unpack_from_uint (const uint a, const uint b) |
| ccl_device_inline uint | uint16_pack_to_uint (const uint a, const uint b) |
| ccl_device_inline uint | uint16_unpack_from_uint_0 (const uint i) |
| ccl_device_inline uint | uint16_unpack_from_uint_1 (const uint i) |
| ccl_device_inline bool | isnan_safe (const float f) |
| ccl_device_inline bool | isfinite_safe (const float f) |
| ccl_device_inline float | ensure_finite (const float v) |
| ccl_device_inline int | clamp (const int a, const int mn, const int mx) |
| ccl_device_inline float | clamp (const float a, const float mn, const float mx) |
| ccl_device_inline float | smoothstep (const float edge0, const float edge1, const float x) |
| template<typename T1, typename T2> |
| ccl_device_inline T1 | mix (const T1 a, const T1 b, const T2 t) |
| template<typename T1, typename T2> |
| ccl_device_inline T1 | endvalue_preserving_mix (const T1 a, const T1 b, const T2 t) |
| ccl_device_inline float | saturatef (const float a) |
| ccl_device_inline int | float_to_int (const float f) |
| ccl_device_inline int | floor_to_int (const float f) |
| ccl_device_inline float | floorfrac (const float x, ccl_private int *i) |
| ccl_device_inline int | ceil_to_int (const float f) |
| ccl_device_inline float | fractf (const float x) |
| ccl_device_inline float | wrapf (const float value, const float max, const float min) |
| ccl_device_inline float | pingpongf (const float a, const float b) |
| ccl_device_inline float | smoothminf (const float a, const float b, float k) |
| ccl_device_inline float | signf (const float f) |
| ccl_device_inline float | nonzerof (const float f, const float eps) |
| ccl_device_inline float | compatible_atan2 (const float y, const float x) |
| ccl_device_inline float | compatible_signf (const float f) |
| ccl_device_inline float | smoothstepf (const float f) |
| ccl_device_inline int | mod (const int x, const int m) |
| ccl_device_inline float | interp (const float a, const float b, const float t) |
| ccl_device_inline float | inverse_lerp (const float a, const float b, const float x) |
| ccl_device_inline float | cubic_interp (const float a, const float b, float c, const float d, float x) |
| ccl_device_inline float | safe_sqrtf (const float f) |
| ccl_device_inline float | inversesqrtf (const float f) |
| ccl_device float | safe_asinf (const float a) |
| ccl_device float | safe_acosf (const float a) |
| ccl_device float | compatible_powf (const float x, const float y) |
| ccl_device float | safe_powf (const float a, const float b) |
| ccl_device float | safe_divide (const float a, const float b) |
| ccl_device float | safe_logf (const float a, const float b) |
| ccl_device float | safe_modulo (const float a, const float b) |
| ccl_device float | safe_floored_modulo (const float a, const float b) |
| ccl_device_inline float | sqr (const float a) |
| ccl_device_inline float | sin_from_cos (const float c) |
| ccl_device_inline float | cos_from_sin (const float s) |
| ccl_device_inline float | sin_sqr_to_one_minus_cos (const float s_sq) |
| ccl_device_inline float | one_minus_cos (const float angle) |
| ccl_device_inline int | power_of_2 (const int a) |
| ccl_device_inline float | pow20 (const float a) |
| ccl_device_inline float | pow22 (const float a) |
| ccl_device_inline float | beta (const float x, const float y) |
| ccl_device_inline float | xor_mask (const float x, const uint y) |
| ccl_device_inline float | or_mask (const float x, const uint y) |
| ccl_device float | bits_to_01 (const uint bits) |
| ccl_device_inline bool | is_zero (const float a) |
| ccl_device_inline uint | popcount (const uint x) |
| ccl_device_inline uint | popcount (const uint64_t x) |
| ccl_device_inline uint | count_leading_zeros (const uint x) |
| ccl_device_inline uint | count_trailing_zeros (const uint x) |
| ccl_device_inline uint | find_first_set (const uint x) |
| ccl_device_inline bool | compare_floats (const float a, const float b, float abs_diff, const int ulp_diff) |
| ccl_device_inline uint | next_power_of_two (const uint x) |
| ccl_device_inline uint | prev_power_of_two (const uint x) |
| ccl_device_inline uint32_t | reverse_integer_bits (uint32_t x) |
| ccl_device_inline bool | solve_quadratic (const float a, const float b, const float c, ccl_private float &x1, ccl_private float &x2) |
| template<typename T1, typename T2> |
| ccl_device_inline Interval< T1 > | operator/= (ccl_private Interval< T1 > &interval, const T2 f) |
| template<typename T> |
| ccl_device_inline Interval< T > | intervals_intersection (const ccl_private Interval< T > &first, const ccl_private Interval< T > &second) |
| template<typename T> |
| ccl_device_inline Extrema< T > | operator* (const Extrema< T > a, const T b) |
| template<typename T> |
| ccl_device_inline Extrema< T > | operator+ (const ccl_private Extrema< T > &a, const ccl_private Extrema< T > &b) |
| template<typename T> |
| ccl_device_inline Extrema< T > | operator+= (ccl_private Extrema< T > &a, const ccl_private Extrema< T > &b) |
| template<typename T> |
| ccl_device_inline Extrema< T > | merge (const ccl_private Extrema< T > &a, const ccl_private Extrema< T > &b) |
| template<typename T> |
| ccl_device_inline Extrema< T > | merge (const ccl_private Extrema< T > &a, const ccl_private T &v) |
| ccl_device_inline uchar | float_to_byte (const float val) |
| ccl_device_inline float | byte_to_float (const uchar val) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float4 | zero_float4 () |
| ccl_device_inline float4 | one_float4 () |
| ccl_device_template_spec float4 | make_zero () |
| ccl_device_inline int4 | cast (const float4 a) |
| ccl_device_inline float4 | operator- (const float4 &a) |
| ccl_device_inline float4 | operator* (const float4 a, const float4 b) |
| ccl_device_inline float4 | operator* (const float4 a, const float f) |
| ccl_device_inline float4 | operator* (float f, const float4 a) |
| ccl_device_inline float4 | operator/ (const float f, const float4 a) |
| ccl_device_inline float4 | operator/ (const float4 a, const float f) |
| ccl_device_inline float4 | operator/ (const float4 a, const float4 b) |
| ccl_device_inline float4 | operator+ (const float4 a, const float4 b) |
| ccl_device_inline float4 | operator+ (const float4 a, const float f) |
| ccl_device_inline float4 | operator- (const float4 a, const float4 b) |
| ccl_device_inline float4 | operator- (const float4 a, const float f) |
| ccl_device_inline float4 | operator+= (float4 &a, const float4 b) |
| ccl_device_inline float4 | operator-= (float4 &a, const float4 b) |
| ccl_device_inline float4 | operator*= (float4 &a, const float4 b) |
| ccl_device_inline float4 | operator*= (float4 &a, const float f) |
| ccl_device_inline float4 | operator/= (float4 &a, const float4 b) |
| ccl_device_inline float4 | operator/= (float4 &a, const float f) |
| ccl_device_inline int4 | operator< (const float4 a, const float4 b) |
| ccl_device_inline int4 | operator>= (const float4 a, const float4 b) |
| ccl_device_inline int4 | operator> (const float4 a, const float4 b) |
| ccl_device_inline int4 | operator<= (const float4 a, const float4 b) |
| ccl_device_inline bool | operator== (const float4 a, const float4 b) |
| ccl_device_inline float4 | operator^ (const float4 a, const float4 b) |
| ccl_device_inline float4 | min (const float4 a, const float4 b) |
| ccl_device_inline float4 | max (const float4 a, const float4 b) |
| ccl_device_inline float4 | clamp (const float4 a, const float4 mn, const float4 mx) |
| ccl_device_inline float4 | madd (const float4 a, const float4 b, const float4 c) |
| ccl_device_inline float4 | msub (const float4 a, const float4 b, const float4 c) |
| ccl_device_inline float | reduce_add (const float4 a) |
| ccl_device_inline float | reduce_min (const float4 a) |
| ccl_device_inline float | reduce_max (const float4 a) |
| ccl_device_inline float | dot (const float4 a, const float4 b) |
| ccl_device_inline float | len (const float4 a) |
| ccl_device_inline float | len_squared (const float4 a) |
| ccl_device_inline float4 | sqr (const float4 a) |
| ccl_device_inline float | distance (const float4 a, const float4 b) |
| ccl_device_inline float4 | sqrt (const float4 a) |
| ccl_device_inline float4 | cross (const float4 a, const float4 b) |
| ccl_device_inline bool | is_zero (const float4 a) |
| ccl_device_inline float | average (const float4 a) |
| ccl_device_inline float4 | normalize (const float4 a) |
| ccl_device_inline float4 | safe_normalize (const float4 a) |
| ccl_device_inline float4 | fabs (const float4 a) |
| ccl_device_inline float4 | fmod (const float4 a, const float b) |
| ccl_device_inline float4 | floor (const float4 a) |
| ccl_device_inline float4 | floorfrac (const float4 x, ccl_private int4 *i) |
| ccl_device_inline float4 | saturate (const float4 a) |
| ccl_device_inline float4 | exp (const float4 v) |
| ccl_device_inline float4 | log (const float4 v) |
| ccl_device_inline bool | isequal (const float4 a, const float4 b) |
| template<class MaskType> |
| ccl_device_inline float4 | select (const MaskType mask, const float4 a, const float4 b) |
| template<class MaskType> |
| ccl_device_inline float4 | mask (const MaskType mask, const float4 a) |
| ccl_device_inline float4 | load_float4 (const ccl_private float *v) |
| ccl_device_inline float4 | safe_divide (const float4 a, const float b) |
| ccl_device_inline float4 | safe_divide (const float4 a, const float4 b) |
| ccl_device_inline bool | isfinite_safe (const float4 v) |
| ccl_device_inline float4 | ensure_finite (const float4 v) |
| ccl_device_inline float4 | power (const float4 v, const float e) |
| ccl_device_inline float4 | interp (float4 a, float4 b, float t) |
| ccl_device_inline int4 | __float4_as_int4 (const float4 f) |
| ccl_device_inline float4 | __int4_as_float4 (const int4 i) |
| ccl_device_inline void | copy_v4_v4 (ccl_private float *r, const float4 val) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float3 | zero_float3 () |
| ccl_device_inline float3 | one_float3 () |
| ccl_device_template_spec float3 | make_zero () |
| ccl_device_inline float3 | reciprocal (const float3 a) |
| ccl_device_inline float3 | operator- (const float3 &a) |
| ccl_device_inline float3 | operator* (const float3 a, const float3 b) |
| ccl_device_inline float3 | operator* (const float3 a, const float f) |
| ccl_device_inline float3 | operator* (const float f, const float3 a) |
| ccl_device_inline float3 | operator/ (const float f, const float3 a) |
| ccl_device_inline float3 | operator/ (const float3 a, const float f) |
| ccl_device_inline float3 | operator/ (const float3 a, const float3 b) |
| ccl_device_inline float3 | operator+ (const float3 a, const float3 b) |
| ccl_device_inline float3 | operator+ (const float3 a, const float b) |
| ccl_device_inline float3 | operator+ (const float a, const float3 b) |
| ccl_device_inline float3 | operator- (const float3 a, const float3 b) |
| ccl_device_inline float3 | operator- (const float3 a, const float b) |
| ccl_device_inline float3 | operator- (const float a, const float3 b) |
| ccl_device_inline float3 | operator+= (float3 &a, const float3 b) |
| ccl_device_inline float3 | operator-= (float3 &a, const float3 b) |
| ccl_device_inline float3 | operator*= (float3 &a, const float3 b) |
| ccl_device_inline float3 | operator*= (float3 &a, const float f) |
| ccl_device_inline float3 | operator/= (float3 &a, const float3 b) |
| ccl_device_inline float3 | operator/= (float3 &a, const float f) |
| ccl_device_inline packed_float3 | operator*= (packed_float3 &a, const float3 b) |
| ccl_device_inline packed_float3 | operator*= (packed_float3 &a, const float f) |
| ccl_device_inline packed_float3 | operator/= (packed_float3 &a, const float3 b) |
| ccl_device_inline packed_float3 | operator/= (packed_float3 &a, const float f) |
| ccl_device_inline packed_float3 | operator+= (packed_float3 &a, const float3 b) |
| ccl_device_inline bool | operator== (const float3 a, const float3 b) |
| ccl_device_inline int3 | operator== (const float3 a, const float b) |
| ccl_device_inline bool | operator!= (const float3 a, const float3 b) |
| ccl_device_inline int3 | operator>= (const float3 a, const float3 b) |
| ccl_device_inline int3 | operator< (const float3 a, const float3 b) |
| ccl_device_inline float | dot (const float3 a, const float3 b) |
| ccl_device_inline int3 | operator> (const float3 a, const float3 b) |
| ccl_device_inline int3 | operator> (const float3 a, const float b) |
| ccl_device_inline float | dot_xy (const float3 a, const float3 b) |
| ccl_device_inline float | len (const float3 a) |
| ccl_device_inline float | reduce_min (const float3 a) |
| ccl_device_inline float | reduce_max (const float3 a) |
| ccl_device_inline float | len_squared (const float3 a) |
| ccl_device_inline float | distance (const float3 a, const float3 b) |
| ccl_device_inline float3 | cross (const float3 a, const float3 b) |
| ccl_device_inline float3 | normalize (const float3 a) |
| ccl_device_inline float3 | min (const float3 a, const float3 b) |
| ccl_device_inline float3 | max (const float3 a, const float3 b) |
| ccl_device_inline float3 | clamp (const float3 a, const float3 mn, const float3 mx) |
| ccl_device_inline float3 | fabs (const float3 a) |
| ccl_device_inline float3 | fmod (const float3 a, const float b) |
| ccl_device_inline float3 | fmod (const float3 a, const float3 b) |
| ccl_device_inline float3 | sqrt (const float3 a) |
| ccl_device_inline float3 | round (const float3 a) |
| ccl_device_inline float3 | floor (const float3 a) |
| ccl_device_inline float3 | ceil (const float3 a) |
| ccl_device_inline float3 | saturate (const float3 a) |
| ccl_device_inline float3 | exp (const float3 v) |
| ccl_device_inline float3 | log (const float3 v) |
| ccl_device_inline float3 | sin (const float3 v) |
| ccl_device_inline float3 | cos (const float3 v) |
| ccl_device_inline float3 | tan (const float3 v) |
| ccl_device_inline float3 | atan2 (const float3 y, const float3 x) |
| ccl_device_inline float3 | reflect (const float3 incident, const float3 unit_normal) |
| ccl_device_inline float3 | refract (const float3 incident, const float3 normal, const float eta) |
| ccl_device_inline float3 | faceforward (const float3 vector, const float3 incident, const float3 reference) |
| ccl_device_inline float3 | safe_sqrt (const float3 a) |
| ccl_device_inline float3 | project (const float3 v, const float3 v_proj) |
| ccl_device_inline float3 | normalize_len (const float3 a, ccl_private float *t) |
| ccl_device_inline float3 | safe_normalize (const float3 a) |
| ccl_device_inline float3 | safe_normalize_fallback (const float3 a, const float3 fallback) |
| ccl_device_inline float3 | safe_normalize_len (const float3 a, ccl_private float *t) |
| ccl_device_inline float3 | safe_divide (const float3 a, const float3 b) |
| ccl_device_inline float3 | safe_divide (const float3 a, const float b) |
| ccl_device_inline float3 | interp (const float3 a, const float3 b, const float t) |
| ccl_device_inline float3 | sqr (const float3 a) |
| ccl_device_inline bool | is_zero (const float3 a) |
| ccl_device_inline bool | any_zero (const float3 a) |
| ccl_device_inline float | reduce_add (const float3 a) |
| ccl_device_inline float | average (const float3 a) |
| ccl_device_inline bool | isequal (const float3 a, const float3 b) |
| template<class MaskType> |
| ccl_device_inline float3 | select (const MaskType mask, const float3 a, const float3 b) |
| template<class MaskType> |
| ccl_device_inline float3 | mask (const MaskType mask, const float3 a) |
| ccl_device_inline float3 | power (const float3 v, const float e) |
| ccl_device_inline float3 | safe_pow (const float3 a, const float3 b) |
| ccl_device_inline float3 | safe_log (const float3 v) |
| ccl_device_inline void | sincos (const float3 x, ccl_private float3 *sine, ccl_private float3 *cosine) |
| ccl_device_inline auto | component_wise_equal (const float3 a, const float3 b) |
| ccl_device_inline auto | component_is_zero (const float3 a) |
| ccl_device_inline float3 | safe_floored_fmod (const float3 a, const float3 b) |
| ccl_device_inline float3 | wrap (const float3 value, const float3 max, const float3 min) |
| ccl_device_inline float3 | safe_fmod (const float3 a, const float3 b) |
| ccl_device_inline float3 | compatible_sign (const float3 v) |
| ccl_device_inline bool | isfinite_safe (const float3 v) |
| ccl_device_inline float3 | ensure_finite (const float3 v) |
| ccl_device_inline float | triangle_area (const ccl_private float3 &v1, const ccl_private float3 &v2, const ccl_private float3 &v3) |
| ccl_device_inline void | make_orthonormals (const float3 N, ccl_private float3 *a, ccl_private float3 *b) |
| ccl_device_inline float3 | rotate_around_axis (const float3 p, const float3 axis, const float angle) |
| ccl_device_inline float | precise_angle (const float3 a, const float3 b) |
| ccl_device_inline float | tan_angle (const float3 a, const float3 b) |
| ccl_device_inline float2 | map_to_tube (const float3 co) |
| ccl_device_inline float2 | map_to_sphere (const float3 co) |
| ccl_device_inline void | copy_v3_v3 (ccl_private float *r, const float3 val) |
| ccl_device_inline uint3 | float3_as_uint3 (const float3 f) |
| ccl_device_inline float3 | uint3_as_float3 (const uint3 f) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline int4 | operator+ (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator+= (int4 &a, const int4 b) |
| ccl_device_inline int4 | operator- (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator-= (int4 &a, const int4 b) |
| ccl_device_inline int4 | operator* (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator>> (const int4 a, const int i) |
| ccl_device_inline int4 | operator<< (const int4 a, const int i) |
| ccl_device_inline int4 | operator< (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator< (const int4 a, const int b) |
| ccl_device_inline int4 | operator> (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator== (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator== (const int4 a, const int b) |
| ccl_device_inline int4 | operator>= (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator>= (const int4 a, const int b) |
| ccl_device_inline int4 | operator& (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator| (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator^ (const int4 a, const int4 b) |
| ccl_device_inline int4 | operator& (const int32_t a, const int4 b) |
| ccl_device_inline int4 | operator& (const int4 a, const int32_t b) |
| ccl_device_inline int4 | operator| (const int32_t a, const int4 b) |
| ccl_device_inline int4 | operator| (const int4 a, const int32_t b) |
| ccl_device_inline int4 | operator^ (const int32_t a, const int4 b) |
| ccl_device_inline int4 | operator^ (const int4 a, const int32_t b) |
| ccl_device_inline int4 & | operator&= (int4 &a, const int4 b) |
| ccl_device_inline int4 & | operator&= (int4 &a, const int32_t b) |
| ccl_device_inline int4 & | operator|= (int4 &a, const int4 b) |
| ccl_device_inline int4 & | operator|= (int4 &a, const int32_t b) |
| ccl_device_inline int4 & | operator^= (int4 &a, const int4 b) |
| ccl_device_inline int4 & | operator^= (int4 &a, const int32_t b) |
| ccl_device_inline int4 & | operator<<= (int4 &a, const int32_t b) |
| ccl_device_inline int4 & | operator>>= (int4 &a, const int32_t b) |
| ccl_device_inline int4 | srl (const int4 a, const int i) |
| ccl_device_inline int4 | min (const int4 a, const int4 b) |
| ccl_device_inline int4 | max (const int4 a, const int4 b) |
| ccl_device_inline int4 | clamp (const int4 a, const int4 mn, const int4 mx) |
| ccl_device_inline int4 | select (const int4 mask, const int4 a, const int4 b) |
| ccl_device_inline int4 | load_int4 (const int *v) |
| ccl_device_inline float4 | cast (const int4 a) |
| ccl_device_inline void | packed_normal_decode_simd (const int4 value, ccl_private float4 &nx, ccl_private float4 &ny, ccl_private float4 &nz) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float | madd (const float a, const float b, const float c) |
| ccl_device_inline float4 | madd4 (const float4 a, const float4 b, const float4 c) |
| ccl_device_inline int | fast_rint (const float x) |
| ccl_device float | fast_sinf (float x) |
| ccl_device float | fast_cosf (float x) |
| ccl_device void | fast_sincosf (float x, ccl_private float *sine, ccl_private float *cosine) |
| ccl_device float | fast_tanf (float x) |
| ccl_device float | fast_sinpif (const float x) |
| ccl_device_inline float | fast_cospif (const float x) |
| ccl_device float | fast_acosf (const float x) |
| ccl_device float | fast_asinf (const float x) |
| ccl_device float | fast_atanf (const float x) |
| ccl_device float | fast_atan2f (const float y, const float x) |
| ccl_device_inline float | vector_angle (const float3 a, const float3 b) |
| ccl_device_inline int | floor_log2f (const float x) |
| ccl_device float | fast_log2f (float x) |
| ccl_device_inline float | fast_logf (const float x) |
| ccl_device_inline float | fast_log10 (const float x) |
| ccl_device float | fast_logb (float x) |
| ccl_device float | fast_exp2f (float x) |
| ccl_device_inline float | fast_expf (const float x) |
| ccl_device float4 | fast_exp2f4 (float4 x) |
| ccl_device_inline float4 | fast_expf4 (const float4 x) |
| ccl_device_inline float | fast_exp10 (const float x) |
| ccl_device_inline float | fast_expm1f (float x) |
| ccl_device float | fast_sinhf (const float x) |
| ccl_device_inline float | fast_coshf (const float x) |
| ccl_device_inline float | fast_tanhf (const float x) |
| ccl_device float | fast_safe_powf (const float x, const float y) |
| ccl_device_inline float | fast_erff (const float x) |
| ccl_device_inline float | fast_erfcf (const float x) |
| ccl_device_inline float | fast_ierff (const float x) |
| ccl_device_inline float | fast_inv_cbrtf (const float x) |
| ccl_device RGBE | rgb_to_rgbe (float3 rgb) |
| ccl_device_inline float3 | rgbe_to_rgb (const RGBE rgbe) |
| ccl_device_inline dual2 | make_float2 (const dual3 a) |
| ccl_device_inline dual2 | make_float2 (const dual1 a, const dual1 b) |
| ccl_device_inline dual3 | make_float3 (const dual1 a, const dual1 b, const dual1 c) |
| template<class T> |
| ccl_device_inline dual3 | make_float3 (const ccl_private dual< T > &a) |
| ccl_device_inline dual4 | make_float4 (const dual1 a, const dual1 b, const dual1 c, const dual1 d) |
| ccl_device_inline dual4 | make_float4 (const dual3 a) |
| ccl_device_inline dual4 | make_homogeneous (const dual3 a) |
| ccl_device_inline void | print_dual1 (const ccl_private char *label, const dual1 a) |
| ccl_device_inline void | print_dual2 (const ccl_private char *label, const dual2 a) |
| ccl_device_inline void | print_dual3 (const ccl_private char *label, const dual3 a) |
| ccl_device_inline Quaternion | make_quaternion (const float w, const float x, const float y, const float z) |
| ccl_device_inline Quaternion | identity_quaternion () |
| ccl_device_inline float3x3 | make_float3x3 (const float3 x, const float3 y, const float3 z) |
| ccl_device_inline float3x3 | zero_float3x3 () |
| ccl_device_inline float3x3 | identity_float3x3 () |
| ccl_device_inline void | print_float3x3 (const ccl_private char *label, const float3x3 a) |
| ccl_device_forceinline uint8_t | quantize_spherical_harmonics (const float value) |
| ccl_device_forceinline float | unquantize_spherical_harmonics (const uint8_t value) |
| ccl_device_forceinline void | spherical_harmonics_rest_fill_zero (ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_forceinline void | spherical_harmonics_rest_set_coefficient (ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest, const int index, const float3 value) |
| ccl_device_forceinline float3 | spherical_harmonics_rest_get_coefficient (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest, const int index) |
| template<int L, int M> |
| ccl_device_inline float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_template_spec float3 | spherical_harmonics_get (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest) |
| ccl_device_inline float | fallback_half_to_float (const half h) |
| ccl_device_inline float4 | fallback_half4_to_float4 (const half4 h) |
| ccl_device_inline float3 | fallback_packed_half3_to_float3 (const packed_half3 h) |
| ccl_device_inline half | fallback_float_to_half (const float f) |
| ccl_device_inline half4 | fallback_float4_to_half4 (const float4 f) |
| ccl_device_inline packed_half3 | fallback_float3_to_packed_half3 (const float3 f) |
| ccl_device_inline float | half_to_float (half h) |
| ccl_device_inline half | float_to_half (const float f) |
| ccl_device_inline half4 | float4_to_half4 (const float4 f) |
| ccl_device_inline float4 | half4_to_float4 (const half4 h) |
| ccl_device_inline packed_half3 | float3_to_packed_half3 (const float3 f) |
| ccl_device_inline float3 | packed_half3_to_float3 (const packed_half3 h) |
| ccl_device_inline half | float_to_half_image (const float f) |
| ccl_device_inline float | half_to_float_image (half h) |
| ccl_device_inline float4 | half4_to_float4_image (const half4 h) |
| ccl_device_inline half | float_to_half_display (const float f) |
| ccl_device_inline half4 | float4_to_half4_display (const float4 f) |
| ccl_device_inline float | half_is_finite (const half h) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline bool | operator== (const int2 a, const int2 b) |
| ccl_device_inline int2 | operator+ (const int2 &a, const int2 &b) |
| ccl_device_inline int2 | operator+= (int2 &a, const int2 &b) |
| ccl_device_inline int2 | operator- (const int2 &a, const int2 &b) |
| ccl_device_inline int2 | operator* (const int2 &a, const int2 &b) |
| ccl_device_inline int2 | operator/ (const int2 &a, const int2 &b) |
| ccl_device_inline int2 | operator>> (const int2 a, const int i) |
| ccl_device_inline int2 | operator& (const int2 a, const int2 b) |
| ccl_device_inline int2 | operator^ (const int2 a, const int2 b) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline int3 | min (const int3 a, const int3 b) |
| ccl_device_inline int3 | max (const int3 a, const int3 b) |
| ccl_device_inline int3 | clamp (const int3 a, const int mn, const int mx) |
| ccl_device_inline int3 | clamp (const int3 a, int3 &mn, const int mx) |
| ccl_device_inline bool | operator== (const int3 a, const int3 b) |
| ccl_device_inline bool | operator!= (const int3 a, const int3 b) |
| ccl_device_inline bool | operator< (const int3 a, const int3 b) |
| ccl_device_inline int3 | operator+ (const int3 a, const int3 b) |
| ccl_device_inline int3 | operator- (const int3 a, const int3 b) |
| ccl_device_inline int3 | operator>> (const int3 a, const int i) |
| ccl_device_inline int3 | operator* (const int3 a, const int3 b) |
| ccl_device_inline int3 | operator^ (const int3 a, const int3 b) |
| ccl_device_inline int3 | operator& (const int3 a, const int3 b) |
| ccl_device_inline int3 | operator& (const int3 a, const int b) |
| ccl_device_inline bool | all (const int3 a) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline vint8 | operator+ (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator+= (vint8 &a, const vint8 b) |
| ccl_device_inline vint8 | operator- (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator-= (vint8 &a, const vint8 b) |
| ccl_device_inline vint8 | operator>> (const vint8 a, const int i) |
| ccl_device_inline vint8 | operator<< (const vint8 a, const int i) |
| ccl_device_inline vint8 | operator< (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator< (const vint8 a, const int b) |
| ccl_device_inline vint8 | operator== (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator== (const vint8 a, const int b) |
| ccl_device_inline vint8 | operator>= (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator>= (const vint8 a, const int b) |
| ccl_device_inline vint8 | operator& (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator| (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator^ (const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | operator& (const int32_t a, const vint8 b) |
| ccl_device_inline vint8 | operator& (const vint8 a, const int32_t b) |
| ccl_device_inline vint8 | operator| (const int32_t a, const vint8 b) |
| ccl_device_inline vint8 | operator| (const vint8 a, const int32_t b) |
| ccl_device_inline vint8 | operator^ (const int32_t a, const vint8 b) |
| ccl_device_inline vint8 | operator^ (const vint8 a, const int32_t b) |
| ccl_device_inline vint8 & | operator&= (vint8 &a, const vint8 b) |
| ccl_device_inline vint8 & | operator&= (vint8 &a, const int32_t b) |
| ccl_device_inline vint8 & | operator|= (vint8 &a, const vint8 b) |
| ccl_device_inline vint8 & | operator|= (vint8 &a, const int32_t b) |
| ccl_device_inline vint8 & | operator^= (vint8 &a, const vint8 b) |
| ccl_device_inline vint8 & | operator^= (vint8 &a, const int32_t b) |
| ccl_device_inline vint8 & | operator<<= (vint8 &a, const int32_t b) |
| ccl_device_inline vint8 & | operator>>= (vint8 &a, const int32_t b) |
| ccl_device_inline vint8 | min (vint8 a, vint8 b) |
| ccl_device_inline vint8 | max (vint8 a, vint8 b) |
| ccl_device_inline vint8 | clamp (const vint8 a, const vint8 mn, const vint8 mx) |
| ccl_device_inline vint8 | select (const vint8 mask, const vint8 a, const vint8 b) |
| ccl_device_inline vint8 | load_vint8 (const int *v) |
| ccl_device_inline vfloat8 | cast (const vint8 a) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float2 | zero_float2 () |
| ccl_device_inline float2 | one_float2 () |
| ccl_device_template_spec float2 | make_zero () |
| ccl_device_inline float2 | operator- (const float2 &a) |
| ccl_device_inline float2 | operator* (const float2 a, const float2 b) |
| ccl_device_inline float2 | operator* (const float2 a, const float f) |
| ccl_device_inline float2 | operator* (float f, const float2 a) |
| ccl_device_inline float2 | operator/ (float f, const float2 a) |
| ccl_device_inline float2 | operator/ (const float2 a, const float f) |
| ccl_device_inline float2 | operator/ (const float2 a, const float2 b) |
| ccl_device_inline float2 | operator+ (const float2 a, const float2 b) |
| ccl_device_inline float2 | operator+ (const float2 a, const float f) |
| ccl_device_inline float2 | operator- (const float2 a, const float2 b) |
| ccl_device_inline float2 | operator- (const float2 a, const float f) |
| ccl_device_inline float2 | operator+= (float2 &a, const float2 b) |
| ccl_device_inline float2 | operator*= (float2 &a, const float2 b) |
| ccl_device_inline float2 | operator*= (float2 &a, const float f) |
| ccl_device_inline float2 | operator/= (float2 &a, const float2 b) |
| ccl_device_inline float2 | operator/= (float2 &a, const float f) |
| ccl_device_inline bool | operator== (const float2 a, const float2 b) |
| ccl_device_inline bool | operator!= (const float2 a, const float2 b) |
| ccl_device_inline int2 | operator>= (const float2 a, const float2 b) |
| ccl_device_inline bool | is_zero (const float2 a) |
| ccl_device_inline float | dot (const float2 a, const float2 b) |
| ccl_device_inline float | average (const float2 a) |
| ccl_device_inline bool | isequal (const float2 a, const float2 b) |
| template<class MaskType> |
| ccl_device_inline float2 | select (const MaskType mask, const float2 a, const float2 b) |
| template<class MaskType> |
| ccl_device_inline float2 | mask (const MaskType mask, const float2 a) |
| ccl_device_inline float | len (const float2 a) |
| ccl_device_inline float | reduce_min (const float2 a) |
| ccl_device_inline float | reduce_max (const float2 a) |
| ccl_device_inline float | reduce_add (const float2 a) |
| ccl_device_inline float | len_squared (const float2 a) |
| ccl_device_inline float2 | safe_normalize (const float2 a) |
| ccl_device_inline float | distance (const float2 a, const float2 b) |
| ccl_device_inline float | cross (const float2 a, const float2 b) |
| ccl_device_inline float2 | normalize (const float2 a) |
| ccl_device_inline float2 | normalize_len (const float2 a, ccl_private float *t) |
| ccl_device_inline float2 | min (const float2 a, const float2 b) |
| ccl_device_inline float2 | max (const float2 a, const float2 b) |
| ccl_device_inline float2 | clamp (const float2 a, const float2 mn, const float2 mx) |
| ccl_device_inline float2 | fmod (const float2 a, const float b) |
| ccl_device_inline float2 | fabs (const float2 a) |
| ccl_device_inline float2 | as_float2 (const float4 &a) |
| ccl_device_inline float2 | interp (const float2 a, const float2 b, const float t) |
| ccl_device_inline float2 | floor (const float2 a) |
| ccl_device_inline float2 | power (const float2 v, const float e) |
| ccl_device_inline float2 | safe_divide_float2_float (const float2 a, const float b) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline vfloat8 | zero_vfloat8 () |
| ccl_device_inline vfloat8 | one_vfloat8 () |
| ccl_device_inline vfloat8 | operator+ (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator+ (const vfloat8 a, const float f) |
| ccl_device_inline vfloat8 | operator+ (const float f, const vfloat8 a) |
| ccl_device_inline vfloat8 | operator- (const vfloat8 a) |
| ccl_device_inline vfloat8 | operator- (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator- (const vfloat8 a, const float f) |
| ccl_device_inline vfloat8 | operator- (const float f, const vfloat8 a) |
| ccl_device_inline vfloat8 | operator* (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator* (const vfloat8 a, const float f) |
| ccl_device_inline vfloat8 | operator* (const float f, const vfloat8 a) |
| ccl_device_inline vfloat8 | operator/ (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator/ (const vfloat8 a, const float f) |
| ccl_device_inline vfloat8 | operator/ (const float f, const vfloat8 a) |
| ccl_device_inline vfloat8 | operator+= (vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator-= (vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator*= (vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator*= (vfloat8 a, const float f) |
| ccl_device_inline vfloat8 | operator/= (vfloat8 a, const float f) |
| ccl_device_inline bool | operator== (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | operator^ (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | sqrt (const vfloat8 a) |
| ccl_device_inline vfloat8 | sqr (const vfloat8 a) |
| ccl_device_inline bool | is_zero (const vfloat8 a) |
| ccl_device_inline float | reduce_add (const vfloat8 a) |
| ccl_device_inline float | average (const vfloat8 a) |
| ccl_device_inline vfloat8 | min (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | max (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | clamp (const vfloat8 a, const vfloat8 mn, const vfloat8 mx) |
| ccl_device_inline vfloat8 | select (const vint8 mask, const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | fabs (const vfloat8 a) |
| ccl_device_inline vfloat8 | mix (const vfloat8 a, const vfloat8 b, const float t) |
| ccl_device_inline vfloat8 | mix (const vfloat8 a, const vfloat8 b, vfloat8 t) |
| ccl_device_inline vfloat8 | saturate (const vfloat8 a) |
| ccl_device_inline vfloat8 | exp (vfloat8 v) |
| ccl_device_inline vfloat8 | log (vfloat8 v) |
| ccl_device_inline float | dot (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | pow (vfloat8 v, const float e) |
| ccl_device_inline float | reduce_min (const vfloat8 a) |
| ccl_device_inline float | reduce_max (const vfloat8 a) |
| ccl_device_inline bool | isequal (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | safe_divide (const vfloat8 a, const float b) |
| ccl_device_inline vfloat8 | safe_divide (const vfloat8 a, const vfloat8 b) |
| ccl_device_inline vfloat8 | ensure_finite (vfloat8 v) |
| ccl_device_inline bool | isfinite_safe (vfloat8 v) |
| ccl_device_inline vint8 | cast (const vfloat8 a) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_template_spec dual1 | make_zero () |
| ccl_device_template_spec dual2 | make_zero () |
| ccl_device_template_spec dual3 | make_zero () |
| ccl_device_template_spec dual4 | make_zero () |
| ccl_device_template_spec dual< Quaternion > | make_zero () |
| template<class T> |
| ccl_device_inline bool | is_zero (const ccl_private dual< T > &a) |
| ccl_device_inline bool | operator< (const ccl_private dual1 &a, const float b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T1 > | operator* (const dual< T1 > a, T2 b) |
| template<class T> |
| ccl_device_inline dual< T > | operator* (const T a, const ccl_private dual< T > &b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T1 > | operator* (const ccl_private dual< T1 > &u, const ccl_private dual< T2 > &v) |
| template<class T> |
| ccl_device_inline dual< T > | operator/ (const dual< T > a, T b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T1 > | operator/ (const ccl_private dual< T1 > &u, const ccl_private dual< T2 > &v) |
| template<class T1, class T2> |
| ccl_device_inline dual< T1 > | operator/= (ccl_private dual< T1 > &a, const ccl_private dual< T2 > &b) |
| template<class T> |
| ccl_device_inline dual< T > | operator+ (const dual< T > a, const dual< T > b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T1 > | operator+ (const dual< T1 > a, T2 b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T2 > | operator+ (const T1 a, const dual< T2 > b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T1 > | operator- (const dual< T1 > a, T2 b) |
| template<class T1, class T2> |
| ccl_device_inline dual< T2 > | operator- (const T1 a, const dual< T2 > b) |
| template<class T> |
| ccl_device_inline dual< T > | operator- (const ccl_private dual< T > &a, const ccl_private dual< T > &b) |
| template<class T> |
| ccl_device_inline dual< T > | operator- (const ccl_private dual< T > &a) |
| template<class T> |
| ccl_device_inline dual< T > | chain_rule (const ccl_private dual< T > &u, const ccl_private T &f, const ccl_private T &dfdu) |
| template<class T> |
| ccl_device_inline dual< T > | chain_rule (const ccl_private dual< T > &u, const ccl_private dual< T > &v, const ccl_private T &f, const ccl_private T &dfdu, const ccl_private T &dfdv) |
| template<class MaskType> |
| ccl_device_inline dual3 | select (const MaskType mask, const dual3 a, const dual3 b) |
| template<class T> |
| ccl_device_inline dual< T > | floor (const ccl_private dual< T > &a) |
| template<class T> |
| ccl_device_inline dual< T > | ceil (const ccl_private dual< T > &a) |
| template<class T> |
| ccl_device_inline dual< T > | compatible_sign (const ccl_private dual< T > &u) |
| ccl_device_inline dual3 | safe_fmod (const dual3 u, const dual3 v) |
| ccl_device_inline dual3 | safe_floored_fmod (const dual3 a, const dual3 b) |
| template<class T> |
| ccl_device_inline dual< T > | safe_divide (const dual< T > f, const T g) |
| template<class T> |
| ccl_device_inline dual< T > | safe_divide (const ccl_private dual< T > &f, const ccl_private dual< T > &g) |
| ccl_device_inline dual3 | wrap (const dual3 value, const dual3 max, const dual3 min) |
| ccl_device_inline dual3 | min (const ccl_private dual3 &a, const ccl_private dual3 &b) |
| ccl_device_inline dual3 | max (const ccl_private dual3 &a, const ccl_private dual3 &b) |
| ccl_device_inline dual1 | max (const ccl_private dual1 &a, const ccl_private dual1 &b) |
| ccl_device_inline dual3 | fabs (const ccl_private dual3 &a) |
| template<class T> |
| ccl_device_inline dual1 | average (const dual< T > a) |
| template<class T> |
| ccl_device_inline dual1 | reduce_add (const dual< T > a) |
| ccl_device_inline dual1 | sqrt (const ccl_private dual1 &u) |
| template<class T> |
| ccl_device_inline dual1 | len (const ccl_private dual< T > &a) |
| template<class T1, class T2> |
| ccl_device_inline dual1 | dot (const dual< T1 > a, const T2 b) |
| template<class T> |
| ccl_device_inline dual1 | len_squared (const ccl_private dual< T > &a) |
| template<class T> |
| ccl_device_inline dual1 | distance (const ccl_private dual< T > &a, const ccl_private dual< T > &b) |
| ccl_device_inline dual3 | cross (const ccl_private dual3 &a, const ccl_private dual3 &b) |
| ccl_device_inline dual3 | cross (const ccl_private dual3 &a, const ccl_private float3 &b) |
| ccl_device_inline dual3 | cross (const ccl_private float3 &a, const ccl_private dual3 &b) |
| ccl_device_inline dual1 | inversesqrt (const ccl_private dual1 &u) |
| template<class T> |
| ccl_device_inline dual< T > | normalize (const ccl_private dual< T > &a) |
| template<class T> |
| ccl_device_inline dual< T > | safe_normalize (const ccl_private dual< T > &a) |
| ccl_device_inline dual1 | atan2 (const ccl_private dual1 &y, const ccl_private dual1 &x) |
| ccl_device_inline dual1 | acos (const ccl_private dual1 &u) |
| ccl_device_inline dual1 | safe_acos (const ccl_private dual1 &u) |
| template<class T> |
| ccl_device_inline dual3 | reflect (const dual3 incident, const T unit_normal) |
| ccl_device_inline dual3 | refract (const dual3 incident, const dual3 normal, const dual1 eta) |
| ccl_device_inline dual3 | faceforward (const dual3 vector, const dual3 incident, const dual3 reference) |
| ccl_device_inline dual3 | project (const dual3 v, const dual3 v_proj) |
| template<class T> |
| ccl_device_inline dual< T > | sin (const ccl_private dual< T > &x) |
| template<class T> |
| ccl_device_inline dual< T > | cos (const ccl_private dual< T > &x) |
| ccl_device_inline dual3 | tan (const ccl_private dual3 &x) |
| template<class T> |
| ccl_device_inline dual< T > | safe_pow (const ccl_private dual< T > &u, const ccl_private dual< T > &v) |
| ccl_device_inline dual2 | map_to_tube (const dual3 co) |
| ccl_device_inline dual2 | map_to_sphere (const dual3 co) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline int4 | rect_from_shape (const int x0, const int y0, const int w, int h) |
| ccl_device_inline int4 | rect_expand (const int4 rect, const int d) |
| ccl_device_inline int4 | rect_clip (const int4 a, const int4 b) |
| ccl_device_inline bool | rect_is_valid (const int4 rect) |
| ccl_device_inline int | coord_to_local_index (const int4 rect, const int x, int y) |
| ccl_device_inline bool | local_index_to_coord (const int4 rect, const int idx, ccl_private int *x, ccl_private int *y) |
| ccl_device_inline int | rect_size (const int4 rect) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline Quaternion | operator- (const Quaternion q) |
| ccl_device_inline Quaternion | operator* (const float a, const Quaternion q) |
| ccl_device_inline Quaternion | operator* (const Quaternion q, const float a) |
| ccl_device_inline Quaternion | operator+ (const Quaternion a, const Quaternion b) |
| ccl_device_inline Quaternion | operator- (const Quaternion a, const Quaternion b) |
| ccl_device_inline ccl_private Quaternion & | operator+= (ccl_private Quaternion &a, const Quaternion b) |
| ccl_device_inline ccl_private Quaternion & | operator-= (ccl_private Quaternion &a, const Quaternion b) |
| ccl_device_inline float | dot (const Quaternion a, const Quaternion b) |
| ccl_device_inline Quaternion | normalized (const Quaternion q) |
| ccl_device_inline Quaternion | lerp (const Quaternion q1, const Quaternion q2, const float t) |
| ccl_device_template_spec Quaternion | make_zero () |
| ccl_device_inline float3 | make_float3 (const Quaternion q) |
| ccl_device_inline float4 | make_float4 (const Quaternion q) |
| ccl_device_inline Quaternion | mix (const Quaternion a, const Quaternion b, const float t) |
| ccl_device_inline void | copy_v4_qt (ccl_private float *r, const Quaternion val) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float3x3 | operator* (const float a, const float3x3 m) |
| ccl_device_inline float3x3 | operator* (const float3x3 m, const float a) |
| ccl_device_inline float3x3 | operator* (const float3x3 a, const float3x3 b) |
| ccl_device_inline float3 | operator* (const float3x3 m, const float3 v) |
| ccl_device_inline float3x3 | operator/ (const float3x3 m, const float a) |
| ccl_device_inline float3x3 | float3x3_scale (const float3 s) |
| ccl_device_inline float3x3 | transposed (const float3x3 m) |
| ccl_device_inline float | determinant (const float3x3 m) |
| ccl_device_inline float3x3 | adjoint (const float3x3 m) |
| ccl_device_inline float3x3 | inverted (const float3x3 m) |
| ccl_device_inline float3x3 | quaternion_to_scaled_rotation (const Quaternion q) |
| ccl_device_inline float3x3 | quaternion_to_rotation (const Quaternion q) |
| template<int L, int M> |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float | spherical_harmonics_polynomial_form (float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| ccl_device_template_spec float | spherical_harmonics_polynomial_form (const float3 v) |
| template<class T> |
| ccl_device_forceinline T | spherical_harmonics_evaluate_band_L0 (const float3 direction, const T M0) |
| template<class T> |
| ccl_device_forceinline T | spherical_harmonics_evaluate_band_L1 (const float3 direction, const T Mn1, const T M0, const T Mp1) |
| template<class T> |
| ccl_device_forceinline T | spherical_harmonics_evaluate_band_L2 (const float3 direction, const T Mn2, const T Mn1, const T M0, const T Mp1, const T Mp2) |
| template<class T> |
| ccl_device_forceinline T | spherical_harmonics_evaluate_band_L3 (const float3 direction, const T Mn3, const T Mn2, const T Mn1, const T M0, const T Mp1, const T Mp2, const T Mp3) |
| ccl_device_inline float3 | spherical_harmonics_evaluate_rest (const ccl_global PackedSphericalHarmonicsRest &packed_spherical_harmonics_rest, const float3 direction) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN int | system_console_width () |
| std::string | system_cpu_brand_string () |
| int | system_cpu_bits () |
| bool | system_cpu_support_sse42 () |
| bool | system_cpu_support_avx2 () |
| size_t | system_physical_ram () |
| uint64_t | system_self_process_id () |
| size_t | system_max_open_files () |
| void | system_max_open_files_ensure () |
| template<class T> |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline T | to_global (const float2 p, const T X, const T Y) |
| template<class T> |
| ccl_device_inline T | to_global (const float3 p, const T X, const T Y, const T Z) |
| template<class T> |
| ccl_device_inline float2 | to_local (const T p, const T X, const T Y) |
| template<class T> |
| ccl_device_inline float3 | to_local (const T p, const T X, const T Y, const T Z) |
| template<class T> |
| ccl_device_inline dual3 | to_local (const dual< T > p, const T X, const T Y, const T Z) |
| ccl_device_inline float3 | transform_point (const ccl_private Transform *t, const float3 a) |
| ccl_device_inline dual3 | transform_point (const ccl_private Transform *t, const dual3 a) |
| ccl_device_inline float3 | transform_direction (const ccl_private Transform *t, const float3 a) |
| ccl_device_inline dual3 | transform_direction (const ccl_private Transform *t, const dual3 a) |
| template<class T> |
| ccl_device_inline T | transform_direction_transposed (const ccl_private Transform *t, const T a) |
| ccl_device_inline Transform | make_transform (const float a, const float b, const float c, const float d, const float e, const float f, const float g, const float h, const float i, const float j, const float k, const float l) |
| ccl_device_inline Transform | make_transform (const float3 x, const float3 y, const float3 z) |
| ccl_device_inline Transform | euler_to_transform (const float3 euler) |
| ccl_device_inline Transform | make_transform_frame (const float3 N) |
| ccl_device_inline Transform | operator* (const Transform a, const Transform b) |
| ccl_device_inline Transform | transform_zero () |
| ccl_device_inline void | print_transform (const char *label, const Transform &t) |
| ccl_device_inline Transform | transform_translate (const float3 t) |
| ccl_device_inline Transform | transform_translate (const float x, const float y, float z) |
| ccl_device_inline void | transform_translate (Transform &T, const float3 t) |
| ccl_device_inline Transform | transform_scale (const float3 s) |
| ccl_device_inline Transform | transform_scale (const float x, const float y, float z) |
| ccl_device_inline Transform | transform_rotate (const float angle, float3 axis) |
| ccl_device_inline Transform | transform_euler (const float3 euler) |
| ccl_device_inline Transform | transform_identity () |
| ccl_device_inline bool | operator== (const Transform &A, const Transform &B) |
| ccl_device_inline bool | operator!= (const Transform &A, const Transform &B) |
| ccl_device_inline bool | transform_equal_threshold (const Transform &A, const Transform &B, const float threshold) |
| ccl_device_inline float3 | transform_get_column (const Transform *t, const int column) |
| ccl_device_inline void | transform_set_column (Transform *t, const int column, const float3 value) |
| ccl_device_inline float3 | transform_get_translation (const Transform *t) |
| Transform | transform_transposed_inverse (const Transform &tfm) |
| ccl_device_inline bool | transform_uniform_scale (const Transform &tfm, float &scale) |
| ccl_device_inline bool | transform_negative_scale (const Transform &tfm) |
| ccl_device_inline Transform | transform_clear_scale (const Transform &tfm) |
| ccl_device_inline Transform | transform_empty () |
| ccl_device_inline float4 | quat_interpolate (const float4 q1, const float4 q2, const float t) |
| void | transform_inverse_cpu_avx2 (const Transform &tfm, Transform &itfm) |
| ccl_device_forceinline float3 | transform_inverse_cross (const float3 a_, const float3 b_) |
| ccl_device_forceinline float | transform_inverse_dot (const float3 a_, const float3 b_) |
| ccl_device_forceinline Transform | transform_inverse_impl (const Transform tfm) |
| ccl_device_inline Transform | transform_inverse (const Transform tfm) |
| ccl_device_inline void | transform_compose (ccl_private Transform *tfm, const ccl_private DecomposedTransform *decomp) |
| ccl_device void | transform_motion_array_interpolate (ccl_private Transform *tfm, const ccl_global DecomposedTransform *motion, const int numsteps, const float time) |
| ccl_device_inline bool | transform_isfinite_safe (ccl_private Transform *tfm) |
| ccl_device_inline bool | transform_decomposed_isfinite_safe (ccl_private DecomposedTransform *decomp) |
| ccl_device_inline bool | operator== (const DecomposedTransform &A, const DecomposedTransform &B) |
| float4 | transform_to_quat (const Transform &tfm) |
| void | transform_motion_decompose (DecomposedTransform *decomp, const Transform *motion, const size_t size) |
| Transform | transform_from_viewplane (const BoundBox2D &viewplane) |
| ccl_device_inline Transform | make_transform (const PackedTransform packed_tfm) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device float2 | direction_to_spherical (const float3 dir) |
| ccl_device float3 | spherical_to_direction (const float theta, const float phi) |
| ccl_device float3 | spherical_cos_to_direction (const float cos_theta, const float phi) |
| ccl_device_inline float2 | polar_to_cartesian (const float r, const float phi) |
| ccl_device_inline float3 | disk_to_hemisphere (const float2 p) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_forceinline bool | projection_inverse_impl (ccl_private float R[4][4], ccl_private float M[4][4]) |
| CCL_NAMESPACE_END CCL_NAMESPACE_BEGIN ccl_device_inline float3 | transform_perspective (const ccl_private ProjectionTransform *t, const float3 a) |
| ccl_device_inline float3 | transform_perspective_direction (const ccl_private ProjectionTransform *t, const float3 a) |
| ccl_device_inline float3 | transform_perspective_deriv (const ccl_private ProjectionTransform *t, const float3 a, const float3 dx, const float3 dy, ccl_private float3 &out_dx, ccl_private float3 &out_dy) |
| ccl_device_inline ProjectionTransform | make_projection (const float a, const float b, const float c, const float d, const float e, const float f, const float g, const float h, const float i, const float j, const float k, const float l, const float m, const float n, const float o, const float p) |
| ccl_device_inline ProjectionTransform | projection_identity () |
| ccl_device_inline Transform | projection_to_transform (const ProjectionTransform &a) |
| ccl_device_inline ProjectionTransform | projection_transpose (const ProjectionTransform a) |
| ccl_device_inline ProjectionTransform | projection_inverse (const ProjectionTransform tfm) |
| ccl_device_inline ProjectionTransform | operator* (const ProjectionTransform a, const ProjectionTransform b) |
| ccl_device_inline ProjectionTransform | operator* (const ProjectionTransform &a, const Transform &b) |
| ccl_device_inline ProjectionTransform | operator* (const Transform &a, const ProjectionTransform &b) |
| ccl_device_inline void | print_projection (const char *label, const ProjectionTransform &t) |
| ccl_device_inline ProjectionTransform | projection_perspective (const float fov, const float n, float f) |
| ccl_device_inline ProjectionTransform | projection_orthographic (const float znear, const float zfar) |
| struct | ccl_align (16) ShaderClosure |
| struct | ccl_align (SHADER_DATA_ALIGNMENT) ShaderData |
| | static_assert_align (KernelCamera, 16) |
| | static_assert_align (KernelFilmConvert, 16) |
| | static_assert_align (KernelTables, 16) |
| | static_assert_align (KernelBake, 16) |
| struct | ccl_align (16) KernelData |
| | static_assert_align (KernelData, 16) |
| | static_assert_align (KernelObject, 16) |
| | static_assert_align (KernelCurve, 16) |
| | static_assert_align (KernelCurveSegment, 8) |
| | static_assert_align (KernelLight, 16) |
| | static_assert_align (KernelLightDistribution, 16) |
| | static_assert_align (KernelLightTreeNode, 16) |
| | static_assert_align (KernelLightTreeEmitter, 16) |
| | static_assert_align (KernelParticle, 16) |
| | static_assert_align (KernelShader, 16) |
| | static_assert_align (KernelShaderEvalInput, 16) |
|
| enum | ShaderNodeType : uint { NODE_NUM
} |
| enum | NodeAttributeOutputType : uint8_t { NODE_ATTR_OUTPUT_FLOAT3 = 0
, NODE_ATTR_OUTPUT_FLOAT
, NODE_ATTR_OUTPUT_FLOAT_ALPHA
} |
| enum | NodeAttributeType : uint8_t {
NODE_ATTR_FLOAT = 0
, NODE_ATTR_FLOAT2
, NODE_ATTR_FLOAT3
, NODE_ATTR_FLOAT4
,
NODE_ATTR_RGBA
, NODE_ATTR_MATRIX
, NODE_ATTR_QUATERNION
, NODE_ATTR_SPHERICAL_HARMONICS_REST
} |
| enum | NodeGeometry : uint8_t {
NODE_GEOM_P = 0
, NODE_GEOM_N
, NODE_GEOM_T
, NODE_GEOM_I
,
NODE_GEOM_Ng
, NODE_GEOM_uv
} |
| enum | NodeObjectInfo : uint {
NODE_INFO_OB_LOCATION
, NODE_INFO_OB_COLOR
, NODE_INFO_OB_ALPHA
, NODE_INFO_OB_INDEX
,
NODE_INFO_MAT_INDEX
, NODE_INFO_OB_RANDOM
} |
| enum | NodeParticleInfo : uint {
NODE_INFO_PAR_INDEX
, NODE_INFO_PAR_RANDOM
, NODE_INFO_PAR_AGE
, NODE_INFO_PAR_LIFETIME
,
NODE_INFO_PAR_LOCATION
, NODE_INFO_PAR_SIZE
, NODE_INFO_PAR_VELOCITY
, NODE_INFO_PAR_ANGULAR_VELOCITY
} |
| enum | NodeHairInfo : uint {
NODE_INFO_CURVE_IS_STRAND
, NODE_INFO_CURVE_INTERCEPT
, NODE_INFO_CURVE_LENGTH
, NODE_INFO_CURVE_THICKNESS
,
NODE_INFO_CURVE_TANGENT_NORMAL
, NODE_INFO_CURVE_RANDOM
} |
| enum | NodePointInfo : uint { NODE_INFO_POINT_POSITION
, NODE_INFO_POINT_RADIUS
, NODE_INFO_POINT_RANDOM
} |
| enum | NodeLightPath : uint {
NODE_LP_camera = 0
, NODE_LP_shadow
, NODE_LP_diffuse
, NODE_LP_glossy
,
NODE_LP_singular
, NODE_LP_reflection
, NODE_LP_transmission
, NODE_LP_volume_scatter
,
NODE_LP_backfacing
, NODE_LP_ray_length
, NODE_LP_ray_depth
, NODE_LP_ray_diffuse
,
NODE_LP_ray_glossy
, NODE_LP_ray_transparent
, NODE_LP_ray_transmission
, NODE_LP_ray_portal
} |
| enum | NodeLightFalloff : uint { NODE_LIGHT_FALLOFF_QUADRATIC
, NODE_LIGHT_FALLOFF_LINEAR
, NODE_LIGHT_FALLOFF_CONSTANT
} |
| enum | NodeTexCoord : uint8_t {
NODE_TEXCO_NORMAL
, NODE_TEXCO_OBJECT
, NODE_TEXCO_OBJECT_WITH_TRANSFORM
, NODE_TEXCO_CAMERA
,
NODE_TEXCO_WINDOW
, NODE_TEXCO_REFLECTION
, NODE_TEXCO_DUPLI_GENERATED
, NODE_TEXCO_DUPLI_UV
,
NODE_TEXCO_VOLUME_GENERATED
} |
| enum | NodeMix : uint {
NODE_MIX_BLEND = 0
, NODE_MIX_ADD
, NODE_MIX_MUL
, NODE_MIX_SUB
,
NODE_MIX_SCREEN
, NODE_MIX_DIV
, NODE_MIX_DIFF
, NODE_MIX_DARK
,
NODE_MIX_LIGHT
, NODE_MIX_OVERLAY
, NODE_MIX_DODGE
, NODE_MIX_BURN
,
NODE_MIX_HUE
, NODE_MIX_SAT
, NODE_MIX_VAL
, NODE_MIX_COL
,
NODE_MIX_SOFT
, NODE_MIX_LINEAR
, NODE_MIX_EXCLUSION
, NODE_MIX_CLAMP
} |
| enum | NodeMathType : uint {
NODE_MATH_ADD
, NODE_MATH_SUBTRACT
, NODE_MATH_MULTIPLY
, NODE_MATH_DIVIDE
,
NODE_MATH_SINE
, NODE_MATH_COSINE
, NODE_MATH_TANGENT
, NODE_MATH_ARCSINE
,
NODE_MATH_ARCCOSINE
, NODE_MATH_ARCTANGENT
, NODE_MATH_POWER
, NODE_MATH_LOGARITHM
,
NODE_MATH_MINIMUM
, NODE_MATH_MAXIMUM
, NODE_MATH_ROUND
, NODE_MATH_LESS_THAN
,
NODE_MATH_GREATER_THAN
, NODE_MATH_MODULO
, NODE_MATH_ABSOLUTE
, NODE_MATH_ARCTAN2
,
NODE_MATH_FLOOR
, NODE_MATH_CEIL
, NODE_MATH_FRACTION
, NODE_MATH_SQRT
,
NODE_MATH_INV_SQRT
, NODE_MATH_SIGN
, NODE_MATH_EXPONENT
, NODE_MATH_RADIANS
,
NODE_MATH_DEGREES
, NODE_MATH_SINH
, NODE_MATH_COSH
, NODE_MATH_TANH
,
NODE_MATH_TRUNC
, NODE_MATH_SNAP
, NODE_MATH_WRAP
, NODE_MATH_COMPARE
,
NODE_MATH_MULTIPLY_ADD
, NODE_MATH_PINGPONG
, NODE_MATH_SMOOTH_MIN
, NODE_MATH_SMOOTH_MAX
,
NODE_MATH_FLOORED_MODULO
} |
| enum | NodeBooleanMathType : uint {
NODE_BOOLEAN_MATH_AND
, NODE_BOOLEAN_MATH_OR
, NODE_BOOLEAN_MATH_NOT
, NODE_BOOLEAN_MATH_NAND
,
NODE_BOOLEAN_MATH_NOR
, NODE_BOOLEAN_MATH_XNOR
, NODE_BOOLEAN_MATH_XOR
, NODE_BOOLEAN_MATH_IMPLY
,
NODE_BOOLEAN_MATH_NIMPLY
} |
| enum | NodeIntegerMathType : uint {
NODE_INTEGER_MATH_ADD
, NODE_INTEGER_MATH_SUBTRACT
, NODE_INTEGER_MATH_MULTIPLY
, NODE_INTEGER_MATH_DIVIDE
,
NODE_INTEGER_MATH_MULTIPLY_ADD
, NODE_INTEGER_MATH_POWER
, NODE_INTEGER_MATH_FLOORED_MODULO
, NODE_INTEGER_MATH_ABSOLUTE
,
NODE_INTEGER_MATH_MINIMUM
, NODE_INTEGER_MATH_MAXIMUM
, NODE_INTEGER_MATH_GCD
, NODE_INTEGER_MATH_LCM
,
NODE_INTEGER_MATH_NEGATE
, NODE_INTEGER_MATH_SIGN
, NODE_INTEGER_MATH_DIVIDE_FLOOR
, NODE_INTEGER_MATH_DIVIDE_CEIL
,
NODE_INTEGER_MATH_DIVIDE_ROUND
, NODE_INTEGER_MATH_MODULO
} |
| enum | NodeVectorMathType : uint {
NODE_VECTOR_MATH_ADD
, NODE_VECTOR_MATH_SUBTRACT
, NODE_VECTOR_MATH_MULTIPLY
, NODE_VECTOR_MATH_DIVIDE
,
NODE_VECTOR_MATH_CROSS_PRODUCT
, NODE_VECTOR_MATH_PROJECT
, NODE_VECTOR_MATH_REFLECT
, NODE_VECTOR_MATH_DOT_PRODUCT
,
NODE_VECTOR_MATH_DISTANCE
, NODE_VECTOR_MATH_LENGTH
, NODE_VECTOR_MATH_SCALE
, NODE_VECTOR_MATH_NORMALIZE
,
NODE_VECTOR_MATH_SNAP
, NODE_VECTOR_MATH_FLOOR
, NODE_VECTOR_MATH_CEIL
, NODE_VECTOR_MATH_MODULO
,
NODE_VECTOR_MATH_FRACTION
, NODE_VECTOR_MATH_ABSOLUTE
, NODE_VECTOR_MATH_MINIMUM
, NODE_VECTOR_MATH_MAXIMUM
,
NODE_VECTOR_MATH_WRAP
, NODE_VECTOR_MATH_SINE
, NODE_VECTOR_MATH_COSINE
, NODE_VECTOR_MATH_TANGENT
,
NODE_VECTOR_MATH_REFRACT
, NODE_VECTOR_MATH_FACEFORWARD
, NODE_VECTOR_MATH_MULTIPLY_ADD
, NODE_VECTOR_MATH_POWER
,
NODE_VECTOR_MATH_SIGN
, NODE_VECTOR_MATH_ROUND
} |
| enum | NodeClampType : uint { NODE_CLAMP_MINMAX
, NODE_CLAMP_RANGE
} |
| enum | NodeMapRangeType : uint { NODE_MAP_RANGE_LINEAR
, NODE_MAP_RANGE_STEPPED
, NODE_MAP_RANGE_SMOOTHSTEP
, NODE_MAP_RANGE_SMOOTHERSTEP
} |
| enum | NodeMappingType : uint { NODE_MAPPING_TYPE_POINT
, NODE_MAPPING_TYPE_TEXTURE
, NODE_MAPPING_TYPE_VECTOR
, NODE_MAPPING_TYPE_NORMAL
} |
| enum | NodeVectorRotateType : uint {
NODE_VECTOR_ROTATE_TYPE_AXIS
, NODE_VECTOR_ROTATE_TYPE_AXIS_X
, NODE_VECTOR_ROTATE_TYPE_AXIS_Y
, NODE_VECTOR_ROTATE_TYPE_AXIS_Z
,
NODE_VECTOR_ROTATE_TYPE_EULER_XYZ
} |
| enum | NodeVectorTransformType : uint { NODE_VECTOR_TRANSFORM_TYPE_VECTOR
, NODE_VECTOR_TRANSFORM_TYPE_POINT
, NODE_VECTOR_TRANSFORM_TYPE_NORMAL
} |
| enum | NodeVectorTransformConvertSpace : uint { NODE_VECTOR_TRANSFORM_CONVERT_SPACE_WORLD
, NODE_VECTOR_TRANSFORM_CONVERT_SPACE_OBJECT
, NODE_VECTOR_TRANSFORM_CONVERT_SPACE_CAMERA
} |
| enum | NodeConvert : uint {
NODE_CONVERT_FV
, NODE_CONVERT_FI
, NODE_CONVERT_CF
, NODE_CONVERT_CI
,
NODE_CONVERT_VF
, NODE_CONVERT_VI
, NODE_CONVERT_IF
, NODE_CONVERT_IV
,
NODE_CONVERT_NONE
} |
| enum | NodeNoiseType : uint {
NODE_NOISE_MULTIFRACTAL
, NODE_NOISE_FBM
, NODE_NOISE_HYBRID_MULTIFRACTAL
, NODE_NOISE_RIDGED_MULTIFRACTAL
,
NODE_NOISE_HETERO_TERRAIN
} |
| enum | NodeGaborType : uint { NODE_GABOR_TYPE_2D
, NODE_GABOR_TYPE_3D
} |
| enum | NodeWaveType : uint { NODE_WAVE_BANDS
, NODE_WAVE_RINGS
} |
| enum | NodeWaveBandsDirection : uint { NODE_WAVE_BANDS_DIRECTION_X
, NODE_WAVE_BANDS_DIRECTION_Y
, NODE_WAVE_BANDS_DIRECTION_Z
, NODE_WAVE_BANDS_DIRECTION_DIAGONAL
} |
| enum | NodeWaveRingsDirection : uint { NODE_WAVE_RINGS_DIRECTION_X
, NODE_WAVE_RINGS_DIRECTION_Y
, NODE_WAVE_RINGS_DIRECTION_Z
, NODE_WAVE_RINGS_DIRECTION_SPHERICAL
} |
| enum | NodeWaveProfile : uint { NODE_WAVE_PROFILE_SIN
, NODE_WAVE_PROFILE_SAW
, NODE_WAVE_PROFILE_TRI
} |
| enum | NodeSkyType : uint { NODE_SKY_PREETHAM
, NODE_SKY_HOSEK
, NODE_SKY_SINGLE_SCATTERING
, NODE_SKY_MULTIPLE_SCATTERING
} |
| enum | NodeGradientType : uint {
NODE_BLEND_LINEAR
, NODE_BLEND_QUADRATIC
, NODE_BLEND_EASING
, NODE_BLEND_DIAGONAL
,
NODE_BLEND_RADIAL
, NODE_BLEND_QUADRATIC_SPHERE
, NODE_BLEND_SPHERICAL
} |
| enum | NodeVoronoiDistanceMetric : uint { NODE_VORONOI_EUCLIDEAN
, NODE_VORONOI_MANHATTAN
, NODE_VORONOI_CHEBYCHEV
, NODE_VORONOI_MINKOWSKI
} |
| enum | NodeVoronoiFeature : uint {
NODE_VORONOI_F1
, NODE_VORONOI_F2
, NODE_VORONOI_SMOOTH_F1
, NODE_VORONOI_DISTANCE_TO_EDGE
,
NODE_VORONOI_N_SPHERE_RADIUS
} |
| enum | NodeBlendWeightType : uint { NODE_LAYER_WEIGHT_FRESNEL
, NODE_LAYER_WEIGHT_FACING
} |
| enum | NodeTangentDirectionType : uint { NODE_TANGENT_RADIAL
, NODE_TANGENT_UVMAP
} |
| enum | NodeTangentAxis : uint { NODE_TANGENT_AXIS_X
, NODE_TANGENT_AXIS_Y
, NODE_TANGENT_AXIS_Z
} |
| enum | NodeNormalMapSpace : uint {
NODE_NORMAL_MAP_TANGENT
, NODE_NORMAL_MAP_OBJECT
, NODE_NORMAL_MAP_WORLD
, NODE_NORMAL_MAP_BLENDER_OBJECT
,
NODE_NORMAL_MAP_BLENDER_WORLD
} |
| enum | NodeNormalMapConvention { NODE_NORMAL_MAP_CONVENTION_OPENGL = 0
, NODE_NORMAL_MAP_CONVENTION_DIRECTX = 1
} |
| enum | NodeNormalMapBase { NODE_NORMAL_MAP_BASE_ORIGINAL = 0
, NODE_NORMAL_MAP_BASE_DISPLACED = 1
} |
| enum | NodeNormalMapFlags { NODE_NORMAL_MAP_FLAG_SPACE_MASK = 0x7
, NODE_NORMAL_MAP_FLAG_DIRECTX = (1 << 3)
, NODE_NORMAL_MAP_FLAG_ORIGINAL = (1 << 4)
} |
| enum | NodeImageProjection : uint { NODE_IMAGE_PROJ_FLAT = 0
, NODE_IMAGE_PROJ_BOX = 1
, NODE_IMAGE_PROJ_SPHERE = 2
, NODE_IMAGE_PROJ_TUBE = 3
} |
| enum | NodeImageFlags { NODE_IMAGE_COMPRESS_AS_SRGB = 1
, NODE_IMAGE_ALPHA_UNASSOCIATE = 2
} |
| enum | NodeEnvironmentProjection : uint { NODE_ENVIRONMENT_EQUIRECTANGULAR = 0
, NODE_ENVIRONMENT_MIRROR_BALL = 1
} |
| enum | NodeBumpOffset : uint8_t { NODE_BUMP_OFFSET_CENTER
, NODE_BUMP_OFFSET_DX
, NODE_BUMP_OFFSET_DY
} |
| enum | NodeAO { NODE_AO_ONLY_LOCAL = (1 << 0)
, NODE_AO_INSIDE = (1 << 1)
, NODE_AO_GLOBAL_RADIUS = (1 << 2)
} |
| enum | ShaderType { SHADER_TYPE_SURFACE
, SHADER_TYPE_VOLUME
, SHADER_TYPE_DISPLACEMENT
, SHADER_TYPE_BUMP
} |
| enum | NodePrincipledHairModel : uint { NODE_PRINCIPLED_HAIR_CHIANG = 0
, NODE_PRINCIPLED_HAIR_HUANG = 1
, NODE_PRINCIPLED_HAIR_MODEL_NUM
} |
| enum | NodePrincipledHairParametrization : uint { NODE_PRINCIPLED_HAIR_REFLECTANCE = 0
, NODE_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION = 1
, NODE_PRINCIPLED_HAIR_DIRECT_ABSORPTION = 2
, NODE_PRINCIPLED_HAIR_PARAMETRIZATION_NUM
} |
| enum | NodeCombSepColorType : uint { NODE_COMBSEP_COLOR_RGB
, NODE_COMBSEP_COLOR_HSV
, NODE_COMBSEP_COLOR_HSL
} |
| enum | ClosureType : uint {
CLOSURE_NONE_ID
, CLOSURE_BSDF_ID
, CLOSURE_BSDF_DIFFUSE_ID
, CLOSURE_BSDF_OREN_NAYAR_ID
,
CLOSURE_BSDF_ROUGH_TRANSLUCENT_ID
, CLOSURE_BSDF_BURLEY_ID
, CLOSURE_BSDF_DIFFUSE_RAMP_ID
, CLOSURE_BSDF_SHEEN_ID
,
CLOSURE_BSDF_DIFFUSE_TOON_ID
, CLOSURE_BSDF_TRANSLUCENT_ID
, CLOSURE_BSDF_PHYSICAL_CONDUCTOR
, CLOSURE_BSDF_F82_CONDUCTOR
,
CLOSURE_BSDF_MICROFACET_GGX_ID
, CLOSURE_BSDF_MICROFACET_BECKMANN_ID
, CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID
, CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID
,
CLOSURE_BSDF_ASHIKHMIN_VELVET_ID
, CLOSURE_BSDF_PHONG_RAMP_ID
, CLOSURE_BSDF_GLOSSY_TOON_ID
, CLOSURE_BSDF_HAIR_REFLECTION_ID
,
CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID
, CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID
, CLOSURE_BSDF_THIN_GLASS_TRANSMISSION_ID
, CLOSURE_BSDF_HAIR_TRANSMISSION_ID
,
CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID
, CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID
, CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID
, CLOSURE_BSDF_HAIR_CHIANG_ID
,
CLOSURE_BSDF_HAIR_HUANG_ID
, CLOSURE_BSDF_RAY_PORTAL_ID
, CLOSURE_BSDF_TRANSPARENT_ID
, CLOSURE_BSSRDF_BURLEY_ID
,
CLOSURE_BSSRDF_RANDOM_WALK_ID
, CLOSURE_BSSRDF_RANDOM_WALK_LEGACY_ID
, CLOSURE_BSSRDF_RANDOM_WALK_SKIN_ID
, CLOSURE_HOLDOUT_ID
,
CLOSURE_VOLUME_ID
, CLOSURE_VOLUME_ABSORPTION_ID
, CLOSURE_VOLUME_HENYEY_GREENSTEIN_ID
, CLOSURE_VOLUME_MIE_ID
,
CLOSURE_VOLUME_FOURNIER_FORAND_ID
, CLOSURE_VOLUME_RAYLEIGH_ID
, CLOSURE_VOLUME_DRAINE_ID
, CLOSURE_BSDF_PRINCIPLED_ID
,
NBUILTIN_CLOSURES
} |
| enum | PathTraceDimension {
PRNG_FILTER = 0
, PRNG_LENS_TIME = 1
, PRNG_TERMINATE = 0
, PRNG_LIGHT = 1
,
PRNG_LIGHT_TERMINATE = 2
, PRNG_SURFACE_BSDF = 3
, PRNG_SURFACE_AO = 4
, PRNG_SURFACE_BEVEL = 5
,
PRNG_SURFACE_BSDF_GUIDING = 6
, PRNG_SURFACE_RIS_GUIDING_0 = 10
, PRNG_SURFACE_RIS_GUIDING_1 = 11
, PRNG_VOLUME_PHASE = 3
,
PRNG_VOLUME_RESERVOIR = 4
, PRNG_VOLUME_SCATTER_DISTANCE = 5
, PRNG_VOLUME_EXPANSION_ORDER = 6
, PRNG_VOLUME_SHADE_OFFSET = 7
,
PRNG_VOLUME_PHASE_GUIDING_DISTANCE = 8
, PRNG_VOLUME_PHASE_GUIDING_EQUIANGULAR = 9
, PRNG_VOLUME_COLOR_CHANNEL = 4
, PRNG_VOLUME_OFFSET = 6
,
PRNG_SUBSURFACE_BSDF = 0
, PRNG_SUBSURFACE_COLOR_CHANNEL = 1
, PRNG_SUBSURFACE_SCATTER_DISTANCE = 2
, PRNG_SUBSURFACE_GUIDE_STRATEGY = 3
,
PRNG_SUBSURFACE_GUIDE_DIRECTION = 4
, PRNG_SUBSURFACE_DISK = 0
, PRNG_SUBSURFACE_DISK_RESAMPLE = 1
, PRNG_BAKE_VOLUME_DENSITY_EVAL = 0
,
PRNG_WAVELENGTH = 12
, PRNG_BOUNCE_NUM = 16
} |
| enum | SamplingPattern {
SAMPLING_PATTERN_SOBOL_BURLEY = 0
, SAMPLING_PATTERN_TABULATED_SOBOL = 1
, SAMPLING_PATTERN_BLUE_NOISE_PURE = 2
, SAMPLING_PATTERN_BLUE_NOISE_FIRST = 3
,
SAMPLING_PATTERN_BLUE_NOISE_ROUND = 4
, SAMPLING_PATTERN_AUTOMATIC = 5
, SAMPLING_NUM_PATTERNS
} |
| enum | PathRayVisibilityFlag : uint32_t {
PATH_RAY_VISIBILITY_NONE = 0
, PATH_RAY_VISIBILITY_CAMERA = (1U << 0U)
, PATH_RAY_VISIBILITY_TRANSMIT = (1U << 1U)
, PATH_RAY_VISIBILITY_DIFFUSE = (1U << 2U)
,
PATH_RAY_VISIBILITY_GLOSSY = (1U << 3U)
, PATH_RAY_VISIBILITY_VOLUME_SCATTER = (1U << 4U)
, PATH_RAY_VISIBILITY_SHADOW_OPAQUE = (1U << 5U)
, PATH_RAY_VISIBILITY_SHADOW_TRANSPARENT = (1U << 6U)
,
PATH_RAY_VISIBILITY_SHADOW
, PATH_RAY_VISIBILITY_ALL = ((1U << 7U) - 1U)
, PATH_RAY_VISIBILITY_RAYCAST = (1U << 7U)
, PATH_RAY_VISIBILITY_OBJECT_ALL = (PATH_RAY_VISIBILITY_ALL | PATH_RAY_VISIBILITY_RAYCAST)
,
PATH_RAY_VISIBILITY_NODE_UNALIGNED = (1U << 15U)
} |
| enum | PathRayFlag : uint32_t {
PATH_RAY_FLAG_NONE = 0
, PATH_RAY_REFLECT = (1U << 0U)
, PATH_RAY_SINGULAR = (1U << 1U)
, PATH_RAY_TRANSPARENT = (1U << 2U)
,
PATH_RAY_IMPORTANCE_BAKE = (1U << 3U)
, PATH_RAY_DIFFUSE_ANCESTOR = (1U << 4U)
, PATH_RAY_EMISSION = (1U << 5U)
, PATH_RAY_MIS_HAD_TRANSMISSION = (1U << 6U)
,
PATH_RAY_MIS_SKIP = (1U << 7U)
, PATH_RAY_SINGLE_PASS_DONE = (1U << 8U)
, PATH_RAY_TRANSPARENT_BACKGROUND = (1U << 9U)
, PATH_RAY_TERMINATE_ON_NEXT_SURFACE = (1U << 10U)
,
PATH_RAY_TERMINATE_IN_NEXT_VOLUME = (1U << 11U)
, PATH_RAY_TERMINATE_AFTER_TRANSPARENT = (1U << 12U)
, PATH_RAY_TERMINATE_AFTER_VOLUME = (1U << 13U)
, PATH_RAY_TERMINATE
,
PATH_RAY_SUBSURFACE_RANDOM_WALK = (1U << 14U)
, PATH_RAY_SUBSURFACE_DISK = (1U << 15U)
, PATH_RAY_SUBSURFACE_BACKFACING = (1U << 16U)
, PATH_RAY_SUBSURFACE
,
PATH_RAY_DENOISING_FEATURES = (1U << 17U)
, PATH_RAY_SURFACE_PASS = (1U << 18U)
, PATH_RAY_VOLUME_PASS = (1U << 19U)
, PATH_RAY_ANY_PASS = (PATH_RAY_SURFACE_PASS | PATH_RAY_VOLUME_PASS)
,
PATH_RAY_SHADOW_FOR_AO = (1U << 20U)
, PATH_RAY_SHADOW_CATCHER_HIT = (1U << 21U)
, PATH_RAY_SHADOW_CATCHER_PASS = (1U << 22U)
, PATH_RAY_SHADOW_CATCHER_BACKGROUND = (1U << 23U)
,
PATH_RAY_VOLUME_PRIMARY_TRANSMIT = (1U << 24U)
, PATH_RAY_SHADOW_FOR_LIGHT_LINKING = (1U << 25U)
, PATH_RAY_EXTINCTION = (1U << 26U)
, PATH_RAY_SPECTRAL = (1U << 27U)
} |
| enum | PathRayMNEE {
PATH_MNEE_NONE = 0
, PATH_MNEE_VALID = (1U << 0U)
, PATH_MNEE_RECEIVER_ANCESTOR = (1U << 1U)
, PATH_MNEE_CULL_LIGHT_CONNECTION = (1U << 2U)
,
PATH_MNEE_SAMPLED = (1U << 3U)
} |
| enum | ClosureLabel {
LABEL_NONE = 0
, LABEL_TRANSMIT = 1
, LABEL_REFLECT = 2
, LABEL_DIFFUSE = 4
,
LABEL_GLOSSY = 8
, LABEL_SINGULAR = 16
, LABEL_TRANSPARENT = 32
, LABEL_VOLUME_SCATTER = 64
,
LABEL_TRANSMIT_TRANSPARENT = 128
, LABEL_SUBSURFACE_SCATTER = 256
, LABEL_RAY_PORTAL = 512
, LABEL_CACHE_MISS = 1024
} |
| enum | PassType {
PASS_NONE = 0
, PASS_COMBINED = 1
, PASS_EMISSION
, PASS_BACKGROUND
,
PASS_AO
, PASS_DIFFUSE
, PASS_DIFFUSE_DIRECT
, PASS_DIFFUSE_INDIRECT
,
PASS_GLOSSY
, PASS_GLOSSY_DIRECT
, PASS_GLOSSY_INDIRECT
, PASS_TRANSMISSION
,
PASS_TRANSMISSION_DIRECT
, PASS_TRANSMISSION_INDIRECT
, PASS_VOLUME
, PASS_VOLUME_DIRECT
,
PASS_VOLUME_INDIRECT
, PASS_VOLUME_SCATTER
, PASS_VOLUME_TRANSMIT
, PASS_CATEGORY_LIGHT_END = 31
,
PASS_DEPTH = 32
, PASS_POSITION
, PASS_NORMAL
, PASS_ROUGHNESS
,
PASS_UV
, PASS_OBJECT_ID
, PASS_MATERIAL_ID
, PASS_MOTION
,
PASS_MOTION_WEIGHT
, PASS_CRYPTOMATTE
, PASS_AOV_COLOR
, PASS_AOV_VALUE
,
PASS_ADAPTIVE_AUX_BUFFER
, PASS_SAMPLE_COUNT
, PASS_DIFFUSE_COLOR
, PASS_GLOSSY_COLOR
,
PASS_TRANSMISSION_COLOR
, PASS_MIST
, PASS_RENDER_TIME
, PASS_SHADOW_CATCHER
,
PASS_SHADOW_CATCHER_SAMPLE_COUNT
, PASS_SHADOW_CATCHER_MATTE
, PASS_GUIDING_COLOR
, PASS_GUIDING_PROBABILITY
,
PASS_GUIDING_AVG_ROUGHNESS
, PASS_VOLUME_MAJORANT
, PASS_VOLUME_MAJORANT_SAMPLE_COUNT
, PASS_CATEGORY_DATA_END = 63
,
PASS_DENOISING_ALBEDO
, PASS_DENOISING_SPECULAR_ALBEDO
, PASS_DENOISING_NORMAL
, PASS_DENOISING_ROUGHNESS
,
PASS_DENOISING_DEPTH
, PASS_DENOISING_BACKWARD_MOTION
, PASS_DENOISING_SPECULAR_MOTION
, PASS_CATEGORY_DENOISING_END = 95
,
PASS_BAKE_PRIMITIVE
, PASS_BAKE_SEED
, PASS_BAKE_DIFFERENTIAL
, PASS_CATEGORY_BAKE_END = 127
,
PASS_DENOISING_PREVIOUS
, PASS_NUM
} |
| enum | CryptomatteType {
CRYPT_NONE = 0
, CRYPT_OBJECT = (1 << 0)
, CRYPT_MATERIAL = (1 << 1)
, CRYPT_ASSET = (1 << 2)
,
CRYPT_ACCURATE = (1 << 3)
} |
| enum | DenoisingPassFlag { DENOISING_PASS_FOLLOW_REFLECTIONS = (1 << 0)
, DENOISING_PASS_USE_ALBEDO_ROUGHNESS_WEIGHTING = (1 << 1)
} |
| enum | FilterClosures {
FILTER_CLOSURE_EMISSION = (1 << 0)
, FILTER_CLOSURE_DIFFUSE = (1 << 1)
, FILTER_CLOSURE_GLOSSY = (1 << 2)
, FILTER_CLOSURE_TRANSMISSION = (1 << 3)
,
FILTER_CLOSURE_TRANSPARENT = (1 << 4)
, FILTER_CLOSURE_DIRECT_LIGHT = (1 << 5)
} |
| enum | ShaderFlag {
SHADER_SMOOTH_NORMAL = (1 << 31)
, SHADER_CAST_SHADOW = (1 << 30)
, SHADER_USE_MIS = (1 << 28)
, SHADER_EXCLUDE_DIFFUSE = (1 << 27)
,
SHADER_EXCLUDE_GLOSSY = (1 << 26)
, SHADER_EXCLUDE_TRANSMIT = (1 << 25)
, SHADER_EXCLUDE_CAMERA = (1 << 24)
, SHADER_EXCLUDE_SCATTER = (1 << 23)
,
SHADER_EXCLUDE_SHADOW_CATCHER = (1 << 22)
, SHADER_EXCLUDE_ANY
, SHADER_MASK = ~(SHADER_SMOOTH_NORMAL | SHADER_CAST_SHADOW | SHADER_USE_MIS | SHADER_EXCLUDE_ANY)
} |
| enum | EmissionSampling {
EMISSION_SAMPLING_NONE = 0
, EMISSION_SAMPLING_AUTO = 1
, EMISSION_SAMPLING_FRONT = 2
, EMISSION_SAMPLING_BACK = 3
,
EMISSION_SAMPLING_FRONT_BACK = 4
, EMISSION_SAMPLING_NUM
} |
| enum | LightType {
LIGHT_POINT
, LIGHT_SUN
, LIGHT_BACKGROUND
, LIGHT_AREA
,
LIGHT_SPOT
, LIGHT_TRIANGLE
} |
| enum | GuidingDistributionType { GUIDING_TYPE_PARALLAX_AWARE_VMM = 0
, GUIDING_TYPE_DIRECTIONAL_QUAD_TREE = 1
, GUIDING_TYPE_VMM = 2
, GUIDING_NUM_TYPES
} |
| enum | GuidingDirectionalSamplingType { GUIDING_DIRECTIONAL_SAMPLING_TYPE_PRODUCT_MIS = 0
, GUIDING_DIRECTIONAL_SAMPLING_TYPE_RIS = 1
, GUIDING_DIRECTIONAL_SAMPLING_TYPE_ROUGHNESS = 2
, GUIDING_DIRECTIONAL_SAMPLING_NUM_TYPES
} |
| enum | CameraType { CAMERA_PERSPECTIVE
, CAMERA_ORTHOGRAPHIC
, CAMERA_PANORAMA
, CAMERA_CUSTOM
} |
| enum | PanoramaType {
PANORAMA_EQUIRECTANGULAR = 0
, PANORAMA_FISHEYE_EQUIDISTANT = 1
, PANORAMA_FISHEYE_EQUISOLID = 2
, PANORAMA_MIRRORBALL = 3
,
PANORAMA_FISHEYE_LENS_POLYNOMIAL = 4
, PANORAMA_EQUIANGULAR_CUBEMAP_FACE = 5
, PANORAMA_CENTRAL_CYLINDRICAL = 6
, PANORAMA_NUM_TYPES
} |
| enum | MotionPosition { MOTION_POSITION_START = 0
, MOTION_POSITION_CENTER = 1
, MOTION_POSITION_END = 2
, MOTION_NUM_POSITIONS
} |
| enum | DirectLightSamplingType { DIRECT_LIGHT_SAMPLING_MIS = 0
, DIRECT_LIGHT_SAMPLING_FORWARD = 1
, DIRECT_LIGHT_SAMPLING_NEE = 2
, DIRECT_LIGHT_SAMPLING_NUM
} |
| enum | PrimitiveType {
PRIMITIVE_NONE = 0
, PRIMITIVE_TRIANGLE = (1 << 0)
, PRIMITIVE_CURVE_THICK = (1 << 1)
, PRIMITIVE_CURVE_RIBBON = (1 << 2)
,
PRIMITIVE_CURVE_THICK_LINEAR = PRIMITIVE_CURVE_THICK | PRIMITIVE_CURVE_RIBBON
, PRIMITIVE_POINT = (1 << 3)
, PRIMITIVE_VOLUME = (1 << 4)
, PRIMITIVE_LAMP = (1 << 5)
,
PRIMITIVE_GSPLAT = (1 << 6)
, PRIMITIVE_MOTION = (1 << 7)
, PRIMITIVE_MOTION_TRIANGLE = (PRIMITIVE_TRIANGLE | PRIMITIVE_MOTION)
, PRIMITIVE_MOTION_CURVE_THICK = (PRIMITIVE_CURVE_THICK | PRIMITIVE_MOTION)
,
PRIMITIVE_MOTION_CURVE_RIBBON = (PRIMITIVE_CURVE_RIBBON | PRIMITIVE_MOTION)
, PRIMITIVE_MOTION_CURVE_THICK_LINEAR = (PRIMITIVE_CURVE_THICK_LINEAR | PRIMITIVE_MOTION)
, PRIMITIVE_MOTION_POINT = (PRIMITIVE_POINT | PRIMITIVE_MOTION)
, PRIMITIVE_MOTION_GSPLAT = (PRIMITIVE_GSPLAT | PRIMITIVE_MOTION)
,
PRIMITIVE_CURVE = (PRIMITIVE_CURVE_THICK | PRIMITIVE_CURVE_RIBBON)
, PRIMITIVE_ALL
, PRIMITIVE_ANY_POINT = (PRIMITIVE_POINT | PRIMITIVE_GSPLAT)
, PRIMITIVE_NUM_SHAPES = 7
,
PRIMITIVE_NUM_BITS = PRIMITIVE_NUM_SHAPES + 1
, PRIMITIVE_NUM = PRIMITIVE_NUM_SHAPES * 2
} |
| enum | CurveShapeType { CURVE_RIBBON = 0
, CURVE_THICK = 1
, CURVE_THICK_LINEAR = 2
, CURVE_NUM_SHAPE_TYPES
} |
| enum | AttributePrimitive { ATTR_PRIM_GEOMETRY = 0
, ATTR_PRIM_SUBD
, ATTR_PRIM_TYPES
} |
| enum | AttributeElement {
ATTR_ELEMENT_NONE = 0
, ATTR_ELEMENT_OBJECT = (1 << 0)
, ATTR_ELEMENT_MESH = (1 << 1)
, ATTR_ELEMENT_FACE = (1 << 2)
,
ATTR_ELEMENT_VERTEX = (1 << 3)
, ATTR_ELEMENT_CORNER = (1 << 4)
, ATTR_ELEMENT_CURVE = (1 << 5)
, ATTR_ELEMENT_CURVE_KEY = (1 << 6)
,
ATTR_ELEMENT_VOXEL = (1 << 7)
, ATTR_ELEMENT_IS_MOTION = (1 << 8)
, ATTR_ELEMENT_IS_NORMAL = (1 << 9)
, ATTR_ELEMENT_IS_BYTE = (1 << 10)
,
ATTR_ELEMENT_VERTEX_NORMAL = ATTR_ELEMENT_VERTEX | ATTR_ELEMENT_IS_NORMAL
, ATTR_ELEMENT_CORNER_BYTE = ATTR_ELEMENT_CORNER | ATTR_ELEMENT_IS_BYTE
, ATTR_ELEMENT_CORNER_NORMAL = ATTR_ELEMENT_CORNER | ATTR_ELEMENT_IS_NORMAL
, ATTR_ELEMENT_CURVE_KEY_NORMAL = ATTR_ELEMENT_CURVE_KEY | ATTR_ELEMENT_IS_NORMAL
} |
| enum | AttributeStandard : int {
ATTR_STD_NONE = 0
, ATTR_STD_POSITION
, ATTR_STD_RADIUS
, ATTR_STD_VERTEX_NORMAL
,
ATTR_STD_CORNER_NORMAL
, ATTR_STD_UV
, ATTR_STD_UV_TANGENT
, ATTR_STD_UV_TANGENT_SIGN
,
ATTR_STD_UV_TANGENT_UNDISPLACED
, ATTR_STD_UV_TANGENT_SIGN_UNDISPLACED
, ATTR_STD_VERTEX_COLOR
, ATTR_STD_GENERATED
,
ATTR_STD_GENERATED_TRANSFORM
, ATTR_STD_POSITION_UNDEFORMED
, ATTR_STD_POSITION_UNDISPLACED
, ATTR_STD_NORMAL_UNDISPLACED
,
ATTR_STD_PARTICLE
, ATTR_STD_CURVE_INTERCEPT
, ATTR_STD_CURVE_LENGTH
, ATTR_STD_CURVE_RANDOM
,
ATTR_STD_POINT_RANDOM
, ATTR_STD_PTEX_FACE_ID
, ATTR_STD_PTEX_UV
, ATTR_STD_VOLUME_DENSITY
,
ATTR_STD_VOLUME_COLOR
, ATTR_STD_VOLUME_FLAME
, ATTR_STD_VOLUME_HEAT
, ATTR_STD_VOLUME_TEMPERATURE
,
ATTR_STD_VOLUME_VELOCITY
, ATTR_STD_VOLUME_VELOCITY_X
, ATTR_STD_VOLUME_VELOCITY_Y
, ATTR_STD_VOLUME_VELOCITY_Z
,
ATTR_STD_POINTINESS
, ATTR_STD_RANDOM_PER_ISLAND
, ATTR_STD_SHADOW_TRANSPARENCY
, ATTR_STD_GSPLAT_RADIANCE_BASE
,
ATTR_STD_GSPLAT_RADIANCE_SPHERICAL_HARMONICS_REST
, ATTR_STD_GSPLAT_RADIANCE
, ATTR_STD_GSPLAT_ROTATION
, ATTR_STD_GSPLAT_SCALE
,
ATTR_STD_NUM
, ATTR_STD_NOT_FOUND = -0x7fffffff
} |
| enum | AttributeFlag { ATTR_SUBDIVIDE_SMOOTH_FVAR = (1 << 0)
} |
| enum | ShaderRuntimeFlag {
SR_BACKFACING = (1 << 0)
, SR_CACHE_MISS = (1 << 1)
, SR_EMISSION = (1 << 2)
, SR_BSDF = (1 << 3)
,
SR_BSDF_HAS_EVAL = (1 << 4)
, SR_BSSRDF = (1 << 5)
, SR_HOLDOUT = (1 << 6)
, SR_EXTINCTION = (1 << 7)
,
SR_SCATTER = (1 << 8)
, SR_IS_VOLUME_SHADER_EVAL = (1 << 9)
, SR_TRANSPARENT = (1 << 10)
, SR_BSDF_HAS_TRANSMISSION = (1 << 11)
,
SR_RAY_PORTAL = (1 << 12)
, SR_BSDF_HAS_DISPERSION = (1 << 13)
, SR_CLOSURE_FLAG
} |
| enum | ShaderDataFlag {
SD_REQUIRES_WAVELENGTH = (1 << 12)
, SD_HAS_LIGHT_PATH_NODE = (1 << 13)
, SD_HAS_BUMP_FROM_SURFACE = (1 << 14)
, SD_USE_BUMP_MAP_CORRECTION = (1 << 15)
,
SD_MIS_FRONT = (1 << 16)
, SD_HAS_TRANSPARENT_SHADOW = (1 << 17)
, SD_HAS_VOLUME = (1 << 18)
, SD_HAS_ONLY_VOLUME = (1 << 19)
,
SD_HETEROGENEOUS_VOLUME = (1 << 20)
, SD_HAS_BSSRDF_BUMP = (1 << 21)
, SD_VOLUME_EQUIANGULAR = (1 << 22)
, SD_VOLUME_MIS = (1 << 23)
,
SD_VOLUME_CUBIC = (1 << 24)
, SD_HAS_BUMP_FROM_DISPLACEMENT = (1 << 25)
, SD_HAS_BUMP = (SD_HAS_BUMP_FROM_DISPLACEMENT | SD_HAS_BUMP_FROM_SURFACE)
, SD_HAS_DISPLACEMENT = (1 << 26)
,
SD_HAS_CONSTANT_EMISSION = (1 << 27)
, SD_NEED_VOLUME_ATTRIBUTES = (1 << 28)
, SD_HAS_EMISSION = (1 << 29)
, SD_HAS_RAYTRACE = (1 << 30)
,
SD_MIS_BACK = (1 << 31)
} |
| enum | ShaderDataObjectFlag : uint {
SD_OBJECT_HOLDOUT_MASK = (1u << 0)
, SD_OBJECT_MOTION = (1u << 1)
, SD_OBJECT_TRANSFORM_APPLIED = (1u << 2)
, SD_OBJECT_NEGATIVE_SCALE = (1u << 3)
,
SD_OBJECT_HAS_VOLUME = (1u << 4)
, SD_OBJECT_INTERSECTS_VOLUME = (1u << 5)
, SD_OBJECT_HAS_VERTEX_MOTION = (1u << 6)
, SD_OBJECT_SHADOW_CATCHER = (1u << 7)
,
SD_OBJECT_HAS_VOLUME_ATTRIBUTES = (1u << 8)
, SD_OBJECT_CAUSTICS_CASTER = (1u << 9)
, SD_OBJECT_CAUSTICS_RECEIVER = (1u << 10)
, SD_OBJECT_HAS_VOLUME_MOTION = (1u << 11)
,
SD_OBJECT_HAS_CORNER_NORMALS = (1u << 12)
, SD_OBJECT_CAUSTICS = (SD_OBJECT_CAUSTICS_CASTER | SD_OBJECT_CAUSTICS_RECEIVER)
, SD_OBJECT_FLAGS
} |
| enum | KernelBVHLayout {
BVH_LAYOUT_NONE = 0
, BVH_LAYOUT_BVH2 = (1 << 0)
, BVH_LAYOUT_EMBREE = (1 << 1)
, BVH_LAYOUT_OPTIX = (1 << 2)
,
BVH_LAYOUT_MULTI_OPTIX = (1 << 3)
, BVH_LAYOUT_MULTI_OPTIX_EMBREE = (1 << 4)
, BVH_LAYOUT_METAL = (1 << 5)
, BVH_LAYOUT_MULTI_METAL = (1 << 6)
,
BVH_LAYOUT_MULTI_METAL_EMBREE = (1 << 7)
, BVH_LAYOUT_HIPRT = (1 << 8)
, BVH_LAYOUT_MULTI_HIPRT = (1 << 9)
, BVH_LAYOUT_MULTI_HIPRT_EMBREE = (1 << 10)
,
BVH_LAYOUT_EMBREEGPU = (1 << 11)
, BVH_LAYOUT_MULTI_EMBREEGPU = (1 << 12)
, BVH_LAYOUT_MULTI_EMBREEGPU_EMBREE = (1 << 13)
, BVH_LAYOUT_AUTO = BVH_LAYOUT_EMBREE
,
BVH_LAYOUT_ALL
} |
| enum | LightTreeNodeType : uint8_t { LIGHT_TREE_INSTANCE = (1 << 0)
, LIGHT_TREE_INNER = (1 << 1)
, LIGHT_TREE_LEAF = (1 << 2)
, LIGHT_TREE_DISTANT = (1 << 3)
} |
| enum | ShaderEvalResult { SHADER_EVAL_EMPTY = 0
, SHADER_EVAL_OK = 1
, SHADER_EVAL_CACHE_MISS = 2
} |
| enum | DeviceKernel : int {
DEVICE_KERNEL_INTEGRATOR_INIT_FROM_CAMERA = 0
, DEVICE_KERNEL_INTEGRATOR_INIT_FROM_BAKE
, DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST
, DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW
,
DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE
, DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK
, DEVICE_KERNEL_INTEGRATOR_INTERSECT_DEDICATED_LIGHT
, DEVICE_KERNEL_INTEGRATOR_INTERSECT_MNEE
,
DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND
, DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_NEE
, DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_FORWARD
, DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE
,
DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE
, DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME
, DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME_RAY_MARCHING
, DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW
,
DEVICE_KERNEL_INTEGRATOR_SHADE_DEDICATED_LIGHT
, DEVICE_KERNEL_INTEGRATOR_SHADOW_PATH_MNEE_PENDING
, DEVICE_KERNEL_INTEGRATOR_MEGAKERNEL
, DEVICE_KERNEL_INTEGRATOR_QUEUED_PATHS_ARRAY
,
DEVICE_KERNEL_INTEGRATOR_QUEUED_SHADOW_PATHS_ARRAY
, DEVICE_KERNEL_INTEGRATOR_ACTIVE_PATHS_ARRAY
, DEVICE_KERNEL_INTEGRATOR_TERMINATED_PATHS_ARRAY
, DEVICE_KERNEL_INTEGRATOR_SORTED_PATHS_ARRAY
,
DEVICE_KERNEL_INTEGRATOR_SORT_BUCKET_PASS
, DEVICE_KERNEL_INTEGRATOR_SORT_WRITE_PASS
, DEVICE_KERNEL_INTEGRATOR_COMPACT_PATHS_ARRAY
, DEVICE_KERNEL_INTEGRATOR_COMPACT_STATES
,
DEVICE_KERNEL_INTEGRATOR_TERMINATED_SHADOW_PATHS_ARRAY
, DEVICE_KERNEL_INTEGRATOR_COMPACT_SHADOW_PATHS_ARRAY
, DEVICE_KERNEL_INTEGRATOR_COMPACT_SHADOW_STATES
, DEVICE_KERNEL_INTEGRATOR_RESET
,
DEVICE_KERNEL_INTEGRATOR_SHADOW_CATCHER_COUNT_POSSIBLE_SPLITS
, DEVICE_KERNEL_SHADER_EVAL_DISPLACE
, DEVICE_KERNEL_SHADER_EVAL_BACKGROUND
, DEVICE_KERNEL_SHADER_EVAL_CURVE_SHADOW_TRANSPARENCY
,
DEVICE_KERNEL_SHADER_EVAL_VOLUME_DENSITY
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
,
DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
,
DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
,
DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
, DECLARE_FILM_CONVERT_KERNEL =(DEPTH)
,
DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_CHECK
, DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_FILTER_X
, DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_FILTER_Y
, DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS
,
DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS_TO_SURFACE
, DEVICE_KERNEL_FILTER_GUIDING_SET_FAKE_ALBEDO
, DEVICE_KERNEL_FILTER_COLOR_PREPROCESS
, DEVICE_KERNEL_FILTER_COLOR_PREPROCESS_TO_SURFACE
,
DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS
, DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS_FROM_SURFACE
, DEVICE_KERNEL_FILTER_COLOR_FLIP_Y
, DEVICE_KERNEL_VOLUME_GUIDING_FILTER_X
,
DEVICE_KERNEL_VOLUME_GUIDING_FILTER_Y
, DEVICE_KERNEL_CRYPTOMATTE_POSTPROCESS
, DEVICE_KERNEL_PREFIX_SUM
, DEVICE_KERNEL_NUM
} |
| enum | { DEVICE_GPU_KERNEL_INTEGRATOR_NUM = DEVICE_KERNEL_INTEGRATOR_MEGAKERNEL
} |
| using | uchar = unsigned char |
| using | uint = unsigned int |
| using | ushort = unsigned short |
| using | device_ptr = uint64_t |
| using | Spectrum = float3 |
| using | PackedSpectrum = packed_float3 |
| using | dual1 = dual<float> |
| using | dual2 = dual<float2> |
| using | dual3 = dual<float3> |
| using | dual4 = dual<float4> |
| template<typename T> |
| using | dual_base_t = typename dual_base_type<T>::type |
| template<typename T> |
| using | dual_scalar_t = typename dual_scalar_type<T>::type |
| template<typename...> |
| using | gpu_void_t = void |
| using | SVMStackOffset = uint8_t |
| using | PathRayVisibility = uint32_t |
| using | ShaderDataTinyStorage = ShaderData |
| using | ShaderDataCausticsStorage = ShaderData |
| template<typename T> |
| ccl_static_constexpr bool | is_dual_v = is_dual<T>::value |
| CCL_NAMESPACE_END KernelData | data = {} |
| KernelImageLoadRequestedCPU | image_load_requested_cpu |
| ProfilingState | profiler |