Blender  V3.3
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
blender Namespace Reference

Namespaces

 attribute_math
 
 bke
 
 bounds
 
 color
 
 compositor
 
 cpp_type_util
 
 deg
 
 detail
 
 devirtualize_parameters
 
 dot
 
 draw
 
 ed
 
 editor
 
 eevee
 
 fn
 
 geometry
 
 gpu
 
 imbuf
 
 index_mask_ops
 
 io
 
 length_parameterize
 
 math
 
 meshintersect
 
 modifiers
 
 nodes
 
 noise
 
 opensubdiv
 
 parameter_pack_utils_static_tests
 
 render
 
 robust_pred
 
 
 tests
 
 threading
 
 timeit
 
 ui
 
 varray_tag
 

Classes

class  GuardedAllocator
 
class  RawAllocator
 
class  Any
 
class  Array
 
class  ColorRGBA
 
class  ColorSceneLinear4f
 
class  ColorSceneLinearByteEncoded4b
 
class  ColorTheme4
 
struct  CPPTypeParam
 
class  CPPType
 
class  DisjointSet
 
class  fstream
 
struct  float3x3
 
struct  float4x4
 
class  FunctionRef
 
class  FunctionRef< Ret(Params...)>
 
class  GArray
 
class  GMutablePointer
 
class  GPointer
 
class  GSpan
 
class  GMutableSpan
 
class  GValueMap
 
class  GVectorArray
 
class  GVectorArray_TypedMutableRef
 
class  GVVectorArray_For_GVectorArray
 
class  GVArrayImpl
 
class  GVMutableArrayImpl
 
class  GVArrayCommon
 
class  GVArray
 
class  GVMutableArray
 
class  GVArraySpan
 
class  GMutableVArraySpan
 
class  GVArrayImpl_For_VArray
 
class  VArrayImpl_For_GVArray
 
class  GVMutableArrayImpl_For_VMutableArray
 
class  VMutableArrayImpl_For_GVMutableArray
 
class  GVArrayImpl_For_GSpan
 
class  GVArrayImpl_For_GSpan_final
 
class  GVArrayImpl_For_SingleValueRef
 
class  GVArrayImpl_For_SingleValueRef_final
 
class  GVVectorArray
 
class  GVArray_For_GVVectorArrayIndex
 
class  GVVectorArray_For_SingleGVArray
 
class  GVVectorArray_For_SingleGSpan
 
class  VVectorArray_For_GVVectorArray
 
struct  DefaultHash
 
struct  DefaultHash< const T >
 
struct  DefaultHash< float >
 
struct  DefaultHash< double >
 
struct  DefaultHash< bool >
 
struct  DefaultHash< std::string >
 
struct  DefaultHash< StringRef >
 
struct  DefaultHash< StringRefNull >
 
struct  DefaultHash< std::string_view >
 
struct  DefaultHash< T * >
 
struct  DefaultHash< std::unique_ptr< T > >
 
struct  DefaultHash< std::shared_ptr< T > >
 
struct  DefaultHash< std::reference_wrapper< T > >
 
struct  DefaultHash< std::pair< T1, T2 > >
 
class  LoadFactor
 
struct  TemplatedKeyInfo
 
struct  PointerKeyInfo
 
class  HashTableStats
 
struct  DefaultEquality
 
class  IndexMask
 
class  Span
 
class  IndexRange
 
class  InplacePriorityQueue
 
class  LinearAllocator
 
class  ListBaseWrapper
 
class  Map
 
class  StdUnorderedMapWrapper
 
class  SimpleMapSlot
 
class  IntrusiveMapSlot
 
struct  DefaultMapSlot
 
struct  DefaultMapSlot< Key *, Value >
 
struct  vec_struct_base
 
struct  vec_struct_base< T, 2 >
 
struct  vec_struct_base< T, 3 >
 
struct  vec_struct_base< T, 4 >
 
struct  vec_base
 
struct  DestructValueAtAddress
 
class  AlignedBuffer
 
class  TypedBuffer
 
class  DynamicStackBuffer
 
class  NoInitialization
 
class  NoExceptConstructor
 
class  MultiValueMap
 
struct  TypeForValue
 
struct  ValueSequence
 
struct  TypeSequence
 
class  LinearProbingStrategy
 
class  QuadraticProbingStrategy
 
class  PythonProbingStrategy
 
class  ShuffleProbingStrategy
 
class  RandomNumberGenerator
 
class  ResourceScope
 
class  Set
 
class  StdUnorderedSetWrapper
 
class  SimpleSetSlot
 
class  HashedSetSlot
 
class  IntrusiveSetSlot
 
struct  DefaultSetSlot
 
struct  DefaultSetSlot< std::string >
 
struct  DefaultSetSlot< StringRef >
 
struct  DefaultSetSlot< StringRefNull >
 
struct  DefaultSetSlot< Key * >
 
class  MutableSpan
 
struct  StackChunk
 
class  Stack
 
class  StringRefBase
 
class  StringRefNull
 
class  StringRef
 
class  UserCounter
 
class  NonCopyable
 
class  NonMovable
 
class  Vector
 
class  VectorAdaptor
 
class  VectorSet
 
class  SimpleVectorSetSlot
 
struct  DefaultVectorSetSlot
 
struct  CommonVArrayInfo
 
class  VArrayImpl
 
class  VMutableArrayImpl
 
class  VArrayImpl_For_Span
 
class  VArrayImpl_For_Span_final
 
class  VArrayImpl_For_ArrayContainer
 
class  VArrayImpl_For_Single
 
class  VArrayImpl_For_Func
 
class  VArrayImpl_For_DerivedSpan
 
class  VArrayCommon
 
class  VMutableArray
 
class  VArray
 
class  VArraySpan
 
class  MutableVArraySpan
 
class  SingleAsSpan
 
class  VVectorArray
 
class  GVArrayImpl_For_SingleValue
 
class  GVArrayImpl_For_SmallTrivialSingleValue
 
class  GVArrayImpl_For_SlicedGVArray
 
class  GVArrayImpl_For_GArray
 
struct  DefaultHash< tests::Type1 >
 
struct  DefaultHash< SpreadsheetColumnID >
 
struct  DefaultHash< io::obj::eMTLSyntaxElement >
 

Typedefs

template<typename T , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T))>
using RawArray = Array< T, InlineBufferCapacity, RawAllocator >
 
using ColorTheme4b = ColorTheme4< uint8_t >
 
using ColorTheme4f = ColorTheme4< float >
 
using ColorGeometry4f = ColorSceneLinear4f< eAlpha::Premultiplied >
 
using ColorGeometry4b = ColorSceneLinearByteEncoded4b< eAlpha::Premultiplied >
 
using ColorPaint4f = ColorSceneLinear4f< eAlpha::Straight >
 
using ColorPaint4b = ColorSceneLinearByteEncoded4b< eAlpha::Straight >
 
template<typename Key , typename Value , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(Key) + sizeof(Value)), typename ProbingStrategy = DefaultProbingStrategy, typename Hash = DefaultHash<Key>, typename IsEqual = DefaultEquality, typename Slot = typename DefaultMapSlot<Key, Value>::type>
using RawMap = Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, RawAllocator >
 
template<typename T >
using as_uint_type = std::conditional_t< sizeof(T)==sizeof(uint8_t), uint8_t, std::conditional_t< sizeof(T)==sizeof(uint16_t), uint16_t, std::conditional_t< sizeof(T)==sizeof(uint32_t), uint32_t, std::conditional_t< sizeof(T)==sizeof(uint64_t), uint64_t, void > >> >
 
using int2 = vec_base< int32_t, 2 >
 
using int3 = vec_base< int32_t, 3 >
 
using int4 = vec_base< int32_t, 4 >
 
using uint2 = vec_base< uint32_t, 2 >
 
using uint3 = vec_base< uint32_t, 3 >
 
using uint4 = vec_base< uint32_t, 4 >
 
using ushort2 = vec_base< uint16_t, 2 >
 
using float2 = vec_base< float, 2 >
 
using float3 = vec_base< float, 3 >
 
using float4 = vec_base< float, 4 >
 
using double2 = vec_base< double, 2 >
 
using double3 = vec_base< double, 3 >
 
using double4 = vec_base< double, 4 >
 
template<typename T >
using destruct_ptr = std::unique_ptr< T, DestructValueAtAddress< T > >
 
template<typename T , T Value, size_t Size>
using make_value_sequence = decltype(detail::make_value_sequence_impl< T, Value >(std::make_index_sequence< Size >()))
 
template<typename T , T Value1, T Value2, size_t Size, size_t... Value1Indices>
using make_two_value_sequence = decltype(detail::make_two_value_sequence_impl< T, Value1, Value2 >(ValueSequence< size_t, Value1Indices... >(), std::make_index_sequence< Size >()))
 
using DefaultProbingStrategy = PythonProbingStrategy<>
 
template<typename Key , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(Key)), typename ProbingStrategy = DefaultProbingStrategy, typename Hash = DefaultHash<Key>, typename IsEqual = DefaultEquality, typename Slot = typename DefaultSetSlot<Key>::type>
using RawSet = Set< Key, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, RawAllocator >
 
template<typename Int , Int EmptyValue, Int RemovedValue>
using IntegerSetSlot = IntrusiveSetSlot< Int, TemplatedKeyInfo< Int, EmptyValue, RemovedValue > >
 
template<typename T , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T))>
using RawStack = Stack< T, InlineBufferCapacity, RawAllocator >
 
template<typename T , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T))>
using RawVector = Vector< T, InlineBufferCapacity, RawAllocator >
 
template<typename Key , typename ProbingStrategy = DefaultProbingStrategy, typename Hash = DefaultHash<Key>, typename IsEqual = DefaultEquality, typename Slot = typename DefaultVectorSetSlot<Key>::type>
using RawVectorSet = VectorSet< Key, ProbingStrategy, Hash, IsEqual, Slot, RawAllocator >
 

Enumerations

enum class  eAlpha { Straight , Premultiplied }
 
enum class  eSpace { Theme , SceneLinear , SceneLinearByteEncoded }
 

Functions

 TEST_F (TrackingTest, BKE_tracking_marker_get)
 
 TEST_F (TrackingTest, BKE_tracking_marker_get_exact)
 
 TEST_F (TrackingTest, BKE_tracking_marker_get_interpolated)
 
std::ostream & operator<< (std::ostream &stream, const eAlpha &space)
 
std::ostream & operator<< (std::ostream &stream, const eSpace &space)
 
BLI_INLINE ColorTheme4< floatBLI_color_convert_to_theme4f (const ColorTheme4< uint8_t > &srgb4b)
 
BLI_INLINE ColorTheme4< uint8_tBLI_color_convert_to_theme4b (const ColorTheme4< float > &srgb4f)
 
BLI_INLINE ColorTheme4f BLI_color_convert_to_theme4f (const ColorTheme4b &theme4b)
 
BLI_INLINE ColorSceneLinear4f< eAlpha::StraightBLI_color_convert_to_scene_linear (const ColorTheme4f &theme4f)
 
BLI_INLINE ColorSceneLinear4f< eAlpha::StraightBLI_color_convert_to_scene_linear (const ColorTheme4b &theme4b)
 
BLI_INLINE ColorTheme4f BLI_color_convert_to_theme4f (const ColorSceneLinear4f< eAlpha::Straight > &scene_linear)
 
BLI_INLINE ColorTheme4b BLI_color_convert_to_theme4b (const ColorSceneLinear4f< eAlpha::Straight > &scene_linear)
 
template<typename T , typename Func >
void devirtualize_varray (const VArray< T > &varray, const Func &func, bool enable=true)
 
template<typename T1 , typename T2 , typename Func >
void devirtualize_varray2 (const VArray< T1 > &varray1, const VArray< T2 > &varray2, const Func &func, bool enable=true)
 
 TRIVIAL_DEFAULT_INT_HASH (int8_t)
 
 TRIVIAL_DEFAULT_INT_HASH (uint8_t)
 
 TRIVIAL_DEFAULT_INT_HASH (int16_t)
 
 TRIVIAL_DEFAULT_INT_HASH (uint16_t)
 
 TRIVIAL_DEFAULT_INT_HASH (int32_t)
 
 TRIVIAL_DEFAULT_INT_HASH (uint32_t)
 
 TRIVIAL_DEFAULT_INT_HASH (int64_t)
 
 TRIVIAL_DEFAULT_INT_HASH (uint64_t)
 
uint64_t hash_string (StringRef str)
 
template<typename T >
uint64_t get_default_hash (const T &v)
 
template<typename T1 , typename T2 >
uint64_t get_default_hash_2 (const T1 &v1, const T2 &v2)
 
template<typename T1 , typename T2 , typename T3 >
uint64_t get_default_hash_3 (const T1 &v1, const T2 &v2, const T3 &v3)
 
template<typename T1 , typename T2 , typename T3 , typename T4 >
uint64_t get_default_hash_4 (const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
 
template<typename Src1 , typename Src2 , typename Dst1 , typename Dst2 >
void initialize_pointer_pair (Src1 &&src1, Src2 &&src2, Dst1 *dst1, Dst2 *dst2)
 
int orient2d (const double2 &a, const double2 &b, const double2 &c)
 
int orient2d_fast (const double2 &a, const double2 &b, const double2 &c)
 
int incircle (const double2 &a, const double2 &b, const double2 &c, const double2 &d)
 
int incircle_fast (const double2 &a, const double2 &b, const double2 &c, const double2 &d)
 
int orient3d (const double3 &a, const double3 &b, const double3 &c, const double3 &d)
 
int orient3d_fast (const double3 &a, const double3 &b, const double3 &c, const double3 &d)
 
int insphere (const double3 &a, const double3 &b, const double3 &c, const double3 &d, const double3 &e)
 
int insphere_fast (const double3 &a, const double3 &b, const double3 &c, const double3 &d, const double3 &e)
 
template<typename T >
void destruct_n (T *ptr, int64_t n)
 
template<typename T >
void default_construct_n (T *ptr, int64_t n)
 
template<typename T >
void initialized_copy_n (const T *src, int64_t n, T *dst)
 
template<typename T >
void uninitialized_copy_n (const T *src, int64_t n, T *dst)
 
template<typename From , typename To >
void uninitialized_convert_n (const From *src, int64_t n, To *dst)
 
template<typename T >
void initialized_move_n (T *src, int64_t n, T *dst)
 
template<typename T >
void uninitialized_move_n (T *src, int64_t n, T *dst)
 
template<typename T >
void initialized_relocate_n (T *src, int64_t n, T *dst)
 
template<typename T >
void uninitialized_relocate_n (T *src, int64_t n, T *dst)
 
template<typename T >
void initialized_fill_n (T *dst, int64_t n, const T &value)
 
template<typename T >
void uninitialized_fill_n (T *dst, int64_t n, const T &value)
 
constexpr int64_t default_inline_buffer_capacity (size_t element_size)
 
template<typename Container >
Container & copy_assign_container (Container &dst, const Container &src)
 
template<typename Container >
Container & move_assign_container (Container &dst, Container &&src) noexcept(std::is_nothrow_move_constructible_v< Container >)
 
template<typename T >
bool assign_if_different (T &old_value, T new_value)
 
template<typename RandomAccessIterator >
void parallel_sort (RandomAccessIterator begin, RandomAccessIterator end)
 
template<typename RandomAccessIterator , typename Compare >
void parallel_sort (RandomAccessIterator begin, RandomAccessIterator end, const Compare &comp)
 
static int sgn (double x)
 
bool operator== (const bUUID uuid1, const bUUID uuid2)
 
bool operator!= (const bUUID uuid1, const bUUID uuid2)
 
bool operator< (const bUUID uuid1, const bUUID uuid2)
 
Constexpr Utility Functions

Those should eventually be de-duplicated with functions in BLI_math_base.h.

constexpr int64_t is_power_of_2_constexpr (const int64_t x)
 
constexpr int64_t log2_floor_constexpr (const int64_t x)
 
constexpr int64_t log2_ceil_constexpr (const int64_t x)
 
constexpr int64_t power_of_2_max_constexpr (const int64_t x)
 
template<typename IntT >
constexpr IntT ceil_division (const IntT x, const IntT y)
 
template<typename IntT >
constexpr IntT floor_division (const IntT x, const IntT y)
 
constexpr int64_t ceil_division_by_fraction (const int64_t x, const int64_t numerator, const int64_t denominator)
 
constexpr int64_t floor_multiplication_with_fraction (const int64_t x, const int64_t numerator, const int64_t denominator)
 
constexpr int64_t total_slot_amount_for_usable_slots (const int64_t min_usable_slots, const int64_t max_load_factor_numerator, const int64_t max_load_factor_denominator)
 
#StringRefBase Inline Methods
constexpr int64_t index_or_npos_to_int64 (size_t index)
 
Operator Overloads
std::ostream & operator<< (std::ostream &stream, StringRef ref)
 
std::ostream & operator<< (std::ostream &stream, StringRefNull ref)
 
std::string operator+ (StringRef a, StringRef b)
 
constexpr bool operator== (StringRef a, StringRef b)
 
constexpr bool operator!= (StringRef a, StringRef b)
 
constexpr bool operator< (StringRef a, StringRef b)
 
constexpr bool operator> (StringRef a, StringRef b)
 
constexpr bool operator<= (StringRef a, StringRef b)
 
constexpr bool operator>= (StringRef a, StringRef b)
 

Variables

template<typename T >
constexpr bool is_trivial_extended_v = std::is_trivial_v<T>
 
template<typename T >
constexpr bool is_trivially_destructible_extended_v
 
template<typename T >
constexpr bool is_trivially_copy_constructible_extended_v
 
template<typename T >
constexpr bool is_trivially_move_constructible_extended_v
 
template<typename From , typename To >
constexpr bool is_convertible_pointer_v
 
template<typename From , typename To >
constexpr bool is_span_convertible_pointer_v
 
template<typename T , typename... Args>
constexpr bool is_same_any_v = (std::is_same_v<T, Args> || ...)
 
template<typename T >
constexpr bool is_trivial_extended_v< VArrayImpl_For_Span_final< T > > = true
 
template<typename T >
constexpr bool is_trivial_extended_v< VArrayImpl_For_Single< T > > = is_trivial_extended_v<T>
 
template<typename StructT , typename ElemT , ElemT(*)(const StructT &) GetFunc, void(*)(StructT &, ElemT) SetFunc>
constexpr bool is_trivial_extended_v< VArrayImpl_For_DerivedSpan< StructT, ElemT, GetFunc, SetFunc > > = true
 
template<typename T >
static constexpr bool is_VArray_v = false
 
template<typename T >
static constexpr bool is_VArray_v< VArray< T > > = true
 
template<typename T >
static constexpr bool is_VMutableArray_v = false
 
template<typename T >
static constexpr bool is_VMutableArray_v< VMutableArray< T > > = true
 
static RawVector< RawArray< int64_t, 0 > > arrays
 
static std::mutex current_array_mutex
 
#GVArrayImpl_For_GSpan.
template<>
constexpr bool is_trivial_extended_v< GVArrayImpl_For_GSpan_final > = true
 
#GVArrayImpl_For_SingleValueRef.
template<>
constexpr bool is_trivial_extended_v< GVArrayImpl_For_SingleValueRef_final > = true
 

Typedef Documentation

◆ as_uint_type

template<typename T >
using blender::as_uint_type = typedef std::conditional_t<sizeof(T) == sizeof(uint8_t), uint8_t, std::conditional_t<sizeof(T) == sizeof(uint16_t), uint16_t, std::conditional_t<sizeof(T) == sizeof(uint32_t), uint32_t, std::conditional_t<sizeof(T) == sizeof(uint64_t), uint64_t, void> >> >

Definition at line 21 of file BLI_math_vec_types.hh.

◆ ColorGeometry4b

Definition at line 347 of file BLI_color.hh.

◆ ColorGeometry4f

Definition at line 346 of file BLI_color.hh.

◆ ColorPaint4b

Definition at line 349 of file BLI_color.hh.

◆ ColorPaint4f

Definition at line 348 of file BLI_color.hh.

◆ ColorTheme4b

Definition at line 295 of file BLI_color.hh.

◆ ColorTheme4f

Definition at line 296 of file BLI_color.hh.

◆ DefaultProbingStrategy

Having a specified default is convenient.

Definition at line 199 of file BLI_probing_strategies.hh.

◆ destruct_ptr

template<typename T >
using blender::destruct_ptr = typedef std::unique_ptr<T, DestructValueAtAddress<T> >

A destruct_ptr is like unique_ptr, but it will only call the destructor and will not free the memory. This is useful when using custom allocators.

Definition at line 329 of file BLI_memory_utils.hh.

◆ double2

using blender::double2 = typedef vec_base<double, 2>

Definition at line 584 of file BLI_math_vec_types.hh.

◆ double3

using blender::double3 = typedef vec_base<double, 3>

Definition at line 585 of file BLI_math_vec_types.hh.

◆ double4

using blender::double4 = typedef vec_base<double, 4>

Definition at line 586 of file BLI_math_vec_types.hh.

◆ float2

using blender::float2 = typedef vec_base<float, 2>

Definition at line 580 of file BLI_math_vec_types.hh.

◆ float3

using blender::float3 = typedef vec_base<float, 3>

Definition at line 581 of file BLI_math_vec_types.hh.

◆ float4

using blender::float4 = typedef vec_base<float, 4>

Definition at line 582 of file BLI_math_vec_types.hh.

◆ int2

using blender::int2 = typedef vec_base<int32_t, 2>

Definition at line 570 of file BLI_math_vec_types.hh.

◆ int3

using blender::int3 = typedef vec_base<int32_t, 3>

Definition at line 571 of file BLI_math_vec_types.hh.

◆ int4

using blender::int4 = typedef vec_base<int32_t, 4>

Definition at line 572 of file BLI_math_vec_types.hh.

◆ IntegerSetSlot

template<typename Int , Int EmptyValue, Int RemovedValue>
using blender::IntegerSetSlot = typedef IntrusiveSetSlot<Int, TemplatedKeyInfo<Int, EmptyValue, RemovedValue> >

This exists just to make it more convenient to define which special integer values can be used to indicate an empty and removed value.

Definition at line 334 of file BLI_set_slots.hh.

◆ make_two_value_sequence

template<typename T , T Value1, T Value2, size_t Size, size_t... Value1Indices>
using blender::make_two_value_sequence = typedef decltype(detail::make_two_value_sequence_impl<T, Value1, Value2>( ValueSequence<size_t, Value1Indices...>(), std::make_index_sequence<Size>()))

Utility to create a #ValueSequence that contains two different values. The indices of where the first value should be used are passed in.

Definition at line 110 of file BLI_parameter_pack_utils.hh.

◆ make_value_sequence

template<typename T , T Value, size_t Size>
using blender::make_value_sequence = typedef decltype(detail::make_value_sequence_impl<T, Value>( std::make_index_sequence<Size>()))

Utility to create a #ValueSequence that has the same value at every index.

Definition at line 102 of file BLI_parameter_pack_utils.hh.

◆ RawArray

template<typename T , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T))>
using blender::RawArray = typedef Array<T, InlineBufferCapacity, RawAllocator>

Same as a normal Array, but does not use Blender's guarded allocator. This is useful when allocating memory with static storage duration.

Definition at line 444 of file BLI_array.hh.

◆ RawMap

template<typename Key , typename Value , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(Key) + sizeof(Value)), typename ProbingStrategy = DefaultProbingStrategy, typename Hash = DefaultHash<Key>, typename IsEqual = DefaultEquality, typename Slot = typename DefaultMapSlot<Key, Value>::type>
using blender::RawMap = typedef Map<Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, RawAllocator>

Same as a normal Map, but does not use Blender's guarded allocator. This is useful when allocating memory with static storage duration.

Definition at line 1249 of file BLI_map.hh.

◆ RawSet

template<typename Key , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(Key)), typename ProbingStrategy = DefaultProbingStrategy, typename Hash = DefaultHash<Key>, typename IsEqual = DefaultEquality, typename Slot = typename DefaultSetSlot<Key>::type>
using blender::RawSet = typedef Set<Key, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, RawAllocator>

Same as a normal Set, but does not use Blender's guarded allocator. This is useful when allocating memory with static storage duration.

Definition at line 936 of file BLI_set.hh.

◆ RawStack

template<typename T , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T))>
using blender::RawStack = typedef Stack<T, InlineBufferCapacity, RawAllocator>

Same as a normal Stack, but does not use Blender's guarded allocator. This is useful when allocating memory with static storage duration.

Definition at line 404 of file BLI_stack.hh.

◆ RawVector

template<typename T , int64_t InlineBufferCapacity = default_inline_buffer_capacity(sizeof(T))>
using blender::RawVector = typedef Vector<T, InlineBufferCapacity, RawAllocator>

Same as a normal Vector, but does not use Blender's guarded allocator. This is useful when allocating memory with static storage duration.

Definition at line 1004 of file BLI_vector.hh.

◆ RawVectorSet

template<typename Key , typename ProbingStrategy = DefaultProbingStrategy, typename Hash = DefaultHash<Key>, typename IsEqual = DefaultEquality, typename Slot = typename DefaultVectorSetSlot<Key>::type>
using blender::RawVectorSet = typedef VectorSet<Key, ProbingStrategy, Hash, IsEqual, Slot, RawAllocator>

Same as a normal VectorSet, but does not use Blender's guarded allocator. This is useful when allocating memory with static storage duration.

Definition at line 860 of file BLI_vector_set.hh.

◆ uint2

using blender::uint2 = typedef vec_base<uint32_t, 2>

Definition at line 574 of file BLI_math_vec_types.hh.

◆ uint3

using blender::uint3 = typedef vec_base<uint32_t, 3>

Definition at line 575 of file BLI_math_vec_types.hh.

◆ uint4

using blender::uint4 = typedef vec_base<uint32_t, 4>

Definition at line 576 of file BLI_math_vec_types.hh.

◆ ushort2

using blender::ushort2 = typedef vec_base<uint16_t, 2>

Definition at line 578 of file BLI_math_vec_types.hh.

Enumeration Type Documentation

◆ eAlpha

enum blender::eAlpha
strong

CPP based color structures.

Strongly typed color storage structures with space and alpha association. Will increase readability and visibility of typical mistakes when working with colors.

The storage structs can hold 4 channels (r, g, b and a).

Usage:

Convert a theme byte color to a linearrgb premultiplied.

ColorTheme4b theme_color;
ColorSceneLinear4f<eAlpha::Premultiplied> linearrgb_color =
BLI_color_convert_to_scene_linear(theme_color).premultiply_alpha();
BLI_INLINE ColorSceneLinear4f< eAlpha::Straight > BLI_color_convert_to_scene_linear(const ColorTheme4f &theme4f)
Definition: BLI_color.hh:312
ColorTheme4< uint8_t > ColorTheme4b
Definition: BLI_color.hh:295

The API is structured to make most use of inlining. Most notable are space conversions done via BLI_color_convert_to* functions.

  • Conversions between spaces (theme <=> scene linear) should always be done by invoking the BLI_color_convert_to* methods.
  • Encoding colors (compressing to store colors inside a less precision storage) should be done by invoking the encode and decode methods.
  • Changing alpha association should be done by invoking premultiply_alpha or unpremultiply_alpha methods.

Encoding.

Color encoding is used to store colors with less precision as in using uint8_t in stead of float. This encoding is supported for eSpace::SceneLinear. To make this clear to the developer the eSpace::SceneLinearByteEncoded space is added.

Precision

Colors can be stored using uint8_t or float colors. The conversion between the two precisions are available as methods. (to_4b and to_4f).

Alpha conversion

Alpha conversion is only supported in SceneLinear space.

Extending this file:

  • This file can be extended with ColorHex/Hsl/Hsv for different representations of rgb based colors. ColorHsl4f<eSpace::SceneLinear, eAlpha::Premultiplied>
  • Add non RGB spaces/storages ColorXyz. Enumeration containing the different alpha modes.
Enumerator
Straight 

Color and alpha are unassociated.

Premultiplied 

Color and alpha are associated.

Definition at line 63 of file BLI_color.hh.

◆ eSpace

enum blender::eSpace
strong

Enumeration containing internal spaces.

Enumerator
Theme 

Blender theme color space (sRGB).

SceneLinear 

Blender internal scene linear color space (maps to scene_linear role in OCIO).

SceneLinearByteEncoded 

Blender internal scene linear color space compressed to be stored in 4 uint8_t.

Definition at line 72 of file BLI_color.hh.

Function Documentation

◆ assign_if_different()

template<typename T >
bool blender::assign_if_different ( T old_value,
T  new_value 
)
inline

Returns true if the value is different and was assigned.

Definition at line 570 of file BLI_memory_utils.hh.

Referenced by blender::eevee::Film::init(), blender::eevee::World::sync(), and IMAGE_InstanceData::update_gpu_texture_allocations().

◆ BLI_color_convert_to_scene_linear() [1/2]

BLI_INLINE ColorSceneLinear4f<eAlpha::Straight> blender::BLI_color_convert_to_scene_linear ( const ColorTheme4b theme4b)

Definition at line 320 of file BLI_color.hh.

References srgb_to_linearrgb_uchar4().

◆ BLI_color_convert_to_scene_linear() [2/2]

BLI_INLINE ColorSceneLinear4f<eAlpha::Straight> blender::BLI_color_convert_to_scene_linear ( const ColorTheme4f theme4f)

Definition at line 312 of file BLI_color.hh.

References srgb_to_linearrgb_v4().

Referenced by blender::tests::TEST().

◆ BLI_color_convert_to_theme4b() [1/2]

BLI_INLINE ColorTheme4b blender::BLI_color_convert_to_theme4b ( const ColorSceneLinear4f< eAlpha::Straight > &  scene_linear)

Definition at line 337 of file BLI_color.hh.

References linearrgb_to_srgb_uchar4().

◆ BLI_color_convert_to_theme4b() [2/2]

BLI_INLINE ColorTheme4b blender::BLI_color_convert_to_theme4b ( const ColorTheme4< float > &  srgb4f)

◆ BLI_color_convert_to_theme4f() [1/3]

BLI_INLINE ColorTheme4f blender::BLI_color_convert_to_theme4f ( const ColorSceneLinear4f< eAlpha::Straight > &  scene_linear)

Definition at line 329 of file BLI_color.hh.

References linearrgb_to_srgb_v4().

◆ BLI_color_convert_to_theme4f() [2/3]

BLI_INLINE ColorTheme4<float> blender::BLI_color_convert_to_theme4f ( const ColorTheme4< uint8_t > &  srgb4b)

◆ BLI_color_convert_to_theme4f() [3/3]

BLI_INLINE ColorTheme4f blender::BLI_color_convert_to_theme4f ( const ColorTheme4b theme4b)

Definition at line 305 of file BLI_color.hh.

References rgba_uchar_to_float().

◆ ceil_division()

template<typename IntT >
constexpr IntT blender::ceil_division ( const IntT  x,
const IntT  y 
)
inlineconstexpr

Definition at line 56 of file BLI_hash_tables.hh.

References BLI_assert, x, and y.

Referenced by ceil_division_by_fraction().

◆ ceil_division_by_fraction()

constexpr int64_t blender::ceil_division_by_fraction ( const int64_t  x,
const int64_t  numerator,
const int64_t  denominator 
)
inlineconstexpr

Definition at line 70 of file BLI_hash_tables.hh.

References ceil_division(), and x.

Referenced by total_slot_amount_for_usable_slots().

◆ copy_assign_container()

template<typename Container >
Container& blender::copy_assign_container ( Container &  dst,
const Container &  src 
)

◆ default_construct_n()

template<typename T >
void blender::default_construct_n ( T ptr,
int64_t  n 
)

Call the default constructor on n consecutive elements. For trivially constructible types, this does nothing.

Exception Safety: Strong.

Before: ptr: uninitialized After: ptr: initialized

Definition at line 76 of file BLI_memory_utils.hh.

References BLI_assert, destruct_n(), ptr, and T.

Referenced by blender::Array< T, InlineBufferCapacity, Allocator >::reinitialize(), blender::Vector< T, InlineBufferCapacity, Allocator >::resize(), and blender::tests::TEST().

◆ default_inline_buffer_capacity()

constexpr int64_t blender::default_inline_buffer_capacity ( size_t  element_size)
inlineconstexpr

Inline buffers for small-object-optimization should be disable by default. Otherwise we might get large unexpected allocations on the stack.

Definition at line 517 of file BLI_memory_utils.hh.

◆ destruct_n()

template<typename T >
void blender::destruct_n ( T ptr,
int64_t  n 
)

◆ devirtualize_varray()

template<typename T , typename Func >
void blender::devirtualize_varray ( const VArray< T > &  varray,
const Func &  func,
bool  enable = true 
)
inline

Generate multiple versions of the given function optimized for different virtual arrays. One has to be careful with nesting multiple devirtualizations, because that results in an exponential number of function instantiations (increasing compile time and binary size).

Generally, this function should only be used when the virtual method call overhead to get an element from a virtual array is significant.

Definition at line 290 of file BLI_devirtualize_parameters.hh.

References blender::devirtualize_parameters::Single, and blender::devirtualize_parameters::Span.

Referenced by blender::nodes::SeparateRGBAFunction::call(), blender::nodes::node_geo_curve_sample_cc::SampleCurveFunction::call(), blender::nodes::node_shader_sepcomb_xyz_cc::MF_SeparateXYZ::call(), blender::bke::copy_indices_to_offset_ranges(), blender::geometry::copy_with_map(), blender::nodes::node_geo_set_position_cc::set_computed_position_and_offset(), and blender::ed::curves::varray_contains_nonzero().

◆ devirtualize_varray2()

template<typename T1 , typename T2 , typename Func >
void blender::devirtualize_varray2 ( const VArray< T1 > &  varray1,
const VArray< T2 > &  varray2,
const Func &  func,
bool  enable = true 
)
inline

Same as devirtualize_varray, but devirtualizes two virtual arrays at the same time. This is better than nesting two calls to devirtualize_varray, because it instantiates fewer cases.

Definition at line 310 of file BLI_devirtualize_parameters.hh.

References blender::devirtualize_parameters::Single, and blender::devirtualize_parameters::Span.

Referenced by blender::nodes::node_geo_curve_endpoint_selection_cc::EndpointFieldInput::get_varray_for_context(), and blender::nodes::node_geo_set_position_cc::set_computed_position_and_offset().

◆ floor_division()

template<typename IntT >
constexpr IntT blender::floor_division ( const IntT  x,
const IntT  y 
)
inlineconstexpr

Definition at line 63 of file BLI_hash_tables.hh.

References BLI_assert, x, and y.

◆ floor_multiplication_with_fraction()

constexpr int64_t blender::floor_multiplication_with_fraction ( const int64_t  x,
const int64_t  numerator,
const int64_t  denominator 
)
inlineconstexpr

Definition at line 79 of file BLI_hash_tables.hh.

References x.

Referenced by blender::LoadFactor::compute_total_and_usable_slots().

◆ get_default_hash()

template<typename T >
uint64_t blender::get_default_hash ( const T v)

◆ get_default_hash_2()

template<typename T1 , typename T2 >
uint64_t blender::get_default_hash_2 ( const T1 v1,
const T2 v2 
)

◆ get_default_hash_3()

template<typename T1 , typename T2 , typename T3 >
uint64_t blender::get_default_hash_3 ( const T1 v1,
const T2 v2,
const T3 v3 
)

◆ get_default_hash_4()

template<typename T1 , typename T2 , typename T3 , typename T4 >
uint64_t blender::get_default_hash_4 ( const T1 v1,
const T2 v2,
const T3 v3,
const T4 v4 
)

◆ hash_string()

uint64_t blender::hash_string ( StringRef  str)
inline

◆ incircle()

int blender::incircle ( const double2 a,
const double2 b,
const double2 c,
const double2 d 
)

◆ incircle_fast()

int blender::incircle_fast ( const double2 a,
const double2 b,
const double2 c,
const double2 d 
)

◆ index_or_npos_to_int64()

constexpr int64_t blender::index_or_npos_to_int64 ( size_t  index)
constexpr

◆ initialize_pointer_pair()

template<typename Src1 , typename Src2 , typename Dst1 , typename Dst2 >
void blender::initialize_pointer_pair ( Src1 &&  src1,
Src2 &&  src2,
Dst1 *  dst1,
Dst2 *  dst2 
)

◆ initialized_copy_n()

template<typename T >
void blender::initialized_copy_n ( const T src,
int64_t  n,
T dst 
)

Copy n values from src to dst.

Exception Safety: Basic.

Before: src: initialized dst: initialized After: src: initialized dst: initialized

Definition at line 110 of file BLI_memory_utils.hh.

References BLI_assert, and src.

Referenced by blender::fn::MFProcedureBuilder::add_call(), blender::MutableSpan< T >::copy_from(), and blender::VMutableArrayImpl< T >::set_all().

◆ initialized_fill_n()

template<typename T >
void blender::initialized_fill_n ( T dst,
int64_t  n,
const T value 
)

Copy the value to n consecutive elements.

Exception Safety: Basic.

Before: dst: initialized After: dst: initialized

Definition at line 277 of file BLI_memory_utils.hh.

References BLI_assert.

Referenced by blender::MutableSpan< T >::fill(), blender::Array< T, InlineBufferCapacity, Allocator >::fill(), and blender::Vector< T, InlineBufferCapacity, Allocator >::fill().

◆ initialized_move_n()

template<typename T >
void blender::initialized_move_n ( T src,
int64_t  n,
T dst 
)

Move n values from src to dst.

Exception Safety: Basic.

Before: src: initialized dst: initialized After: src: initialized, moved-from dst: initialized

Definition at line 188 of file BLI_memory_utils.hh.

References BLI_assert, and src.

Referenced by initialized_relocate_n(), and blender::cpp_type_util::move_assign_cb().

◆ initialized_relocate_n()

template<typename T >
void blender::initialized_relocate_n ( T src,
int64_t  n,
T dst 
)

Relocate n values from src to dst. Relocation is a move followed by destruction of the src value.

Exception Safety: Basic.

Before: src: initialized dst: initialized After: src: uninitialized dst: initialized

Definition at line 238 of file BLI_memory_utils.hh.

References BLI_assert, destruct_n(), initialized_move_n(), and src.

◆ insphere()

int blender::insphere ( const double3 a,
const double3 b,
const double3 c,
const double3 d,
const double3 e 
)

◆ insphere_fast()

int blender::insphere_fast ( const double3 a,
const double3 b,
const double3 c,
const double3 d,
const double3 e 
)

◆ is_power_of_2_constexpr()

constexpr int64_t blender::is_power_of_2_constexpr ( const int64_t  x)
inlineconstexpr

Definition at line 31 of file BLI_hash_tables.hh.

References BLI_assert, and x.

Referenced by log2_ceil_constexpr().

◆ log2_ceil_constexpr()

constexpr int64_t blender::log2_ceil_constexpr ( const int64_t  x)
inlineconstexpr

Definition at line 43 of file BLI_hash_tables.hh.

References BLI_assert, is_power_of_2_constexpr(), log2_floor_constexpr(), and x.

Referenced by power_of_2_max_constexpr().

◆ log2_floor_constexpr()

constexpr int64_t blender::log2_floor_constexpr ( const int64_t  x)
inlineconstexpr

Definition at line 37 of file BLI_hash_tables.hh.

References BLI_assert, and x.

Referenced by log2_ceil_constexpr().

◆ move_assign_container()

template<typename Container >
Container& blender::move_assign_container ( Container &  dst,
Container &&  src 
)
noexcept

◆ operator!=() [1/2]

bool blender::operator!= ( const bUUID  uuid1,
const bUUID  uuid2 
)

Definition at line 174 of file uuid.cc.

◆ operator!=() [2/2]

constexpr bool blender::operator!= ( StringRef  a,
StringRef  b 
)
constexpr

Definition at line 625 of file BLI_string_ref.hh.

References Freestyle::a, and usdtokens::b().

Referenced by ccl_try_align().

◆ operator+()

std::string blender::operator+ ( StringRef  a,
StringRef  b 
)
inline

Adding two #StringRefs will allocate an std::string. This is not efficient, but convenient in most cases.

Definition at line 604 of file BLI_string_ref.hh.

References Freestyle::a, and usdtokens::b().

◆ operator<() [1/2]

bool blender::operator< ( const bUUID  uuid1,
const bUUID  uuid2 
)

◆ operator<() [2/2]

constexpr bool blender::operator< ( StringRef  a,
StringRef  b 
)
constexpr

Definition at line 630 of file BLI_string_ref.hh.

References Freestyle::a, and usdtokens::b().

◆ operator<<() [1/4]

std::ostream & blender::operator<< ( std::ostream &  stream,
const eAlpha space 
)

Definition at line 7 of file BLI_color.cc.

References Premultiplied, and Straight.

◆ operator<<() [2/4]

std::ostream & blender::operator<< ( std::ostream &  stream,
const eSpace space 
)

Definition at line 22 of file BLI_color.cc.

References SceneLinear, SceneLinearByteEncoded, and Theme.

◆ operator<<() [3/4]

std::ostream& blender::operator<< ( std::ostream &  stream,
StringRef  ref 
)
inline

Definition at line 588 of file BLI_string_ref.hh.

◆ operator<<() [4/4]

std::ostream& blender::operator<< ( std::ostream &  stream,
StringRefNull  ref 
)
inline

◆ operator<=()

constexpr bool blender::operator<= ( StringRef  a,
StringRef  b 
)
constexpr

Definition at line 640 of file BLI_string_ref.hh.

References Freestyle::a, and usdtokens::b().

◆ operator==() [1/2]

bool blender::operator== ( const bUUID  uuid1,
const bUUID  uuid2 
)

Definition at line 169 of file uuid.cc.

References BLI_uuid_equal().

◆ operator==() [2/2]

constexpr bool blender::operator== ( StringRef  a,
StringRef  b 
)
constexpr

Definition at line 613 of file BLI_string_ref.hh.

References Freestyle::a, usdtokens::b(), and STREQLEN.

◆ operator>()

constexpr bool blender::operator> ( StringRef  a,
StringRef  b 
)
constexpr

Definition at line 635 of file BLI_string_ref.hh.

References Freestyle::a, and usdtokens::b().

◆ operator>=()

constexpr bool blender::operator>= ( StringRef  a,
StringRef  b 
)
constexpr

Definition at line 645 of file BLI_string_ref.hh.

References Freestyle::a, and usdtokens::b().

◆ orient2d()

int blender::orient2d ( const double2 a,
const double2 b,
const double2 c 
)

orient2d gives the exact result, using multi-precision arithmetic when result is close to zero. orient3d_fast just uses double arithmetic, so may be wrong if the answer is very close to zero. Similarly, for incircle and incircle_fast.

Definition at line 2457 of file math_boolean.cc.

References Freestyle::a, usdtokens::b(), Freestyle::c, blender::robust_pred::orient2d(), and sgn().

Referenced by filtered_orient2d< double >().

◆ orient2d_fast()

int blender::orient2d_fast ( const double2 a,
const double2 b,
const double2 c 
)

◆ orient3d()

int blender::orient3d ( const double3 a,
const double3 b,
const double3 c,
const double3 d 
)

orient3d gives the exact result, using multi-precision arithmetic when result is close to zero. orient3d_fast just uses double arithmetic, so may be wrong if the answer is very close to zero. Similarly, for insphere and insphere_fast.

Definition at line 2477 of file math_boolean.cc.

References Freestyle::a, usdtokens::b(), Freestyle::c, blender::robust_pred::orient3d(), and sgn().

◆ orient3d_fast()

int blender::orient3d_fast ( const double3 a,
const double3 b,
const double3 c,
const double3 d 
)

◆ parallel_sort() [1/2]

template<typename RandomAccessIterator >
void blender::parallel_sort ( RandomAccessIterator  begin,
RandomAccessIterator  end 
)

◆ parallel_sort() [2/2]

template<typename RandomAccessIterator , typename Compare >
void blender::parallel_sort ( RandomAccessIterator  begin,
RandomAccessIterator  end,
const Compare &  comp 
)

Definition at line 26 of file BLI_sort.hh.

◆ power_of_2_max_constexpr()

constexpr int64_t blender::power_of_2_max_constexpr ( const int64_t  x)
inlineconstexpr

Definition at line 50 of file BLI_hash_tables.hh.

References BLI_assert, log2_ceil_constexpr(), and x.

Referenced by total_slot_amount_for_usable_slots().

◆ sgn()

static int blender::sgn ( double  x)
static

◆ TEST_F() [1/3]

blender::TEST_F ( TrackingTest  ,
BKE_tracking_marker_get   
)

◆ TEST_F() [2/3]

blender::TEST_F ( TrackingTest  ,
BKE_tracking_marker_get_exact   
)

◆ TEST_F() [3/3]

blender::TEST_F ( TrackingTest  ,
BKE_tracking_marker_get_interpolated   
)

◆ total_slot_amount_for_usable_slots()

constexpr int64_t blender::total_slot_amount_for_usable_slots ( const int64_t  min_usable_slots,
const int64_t  max_load_factor_numerator,
const int64_t  max_load_factor_denominator 
)
inlineconstexpr

◆ TRIVIAL_DEFAULT_INT_HASH() [1/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( int16_t  )

◆ TRIVIAL_DEFAULT_INT_HASH() [2/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( int32_t  )

◆ TRIVIAL_DEFAULT_INT_HASH() [3/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( int64_t  )

◆ TRIVIAL_DEFAULT_INT_HASH() [4/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( int8_t  )

We cannot make any assumptions about the distribution of keys, so use a trivial hash function by default. The default probing strategy is designed to take all bits of the hash into account to avoid worst case behavior when the lower bits are all zero. Special hash functions can be implemented when more knowledge about a specific key distribution is available.

◆ TRIVIAL_DEFAULT_INT_HASH() [5/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( uint16_t  )

◆ TRIVIAL_DEFAULT_INT_HASH() [6/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( uint32_t  )

◆ TRIVIAL_DEFAULT_INT_HASH() [7/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( uint64_t  )

◆ TRIVIAL_DEFAULT_INT_HASH() [8/8]

blender::TRIVIAL_DEFAULT_INT_HASH ( uint8_t  )

◆ uninitialized_convert_n()

template<typename From , typename To >
void blender::uninitialized_convert_n ( const From *  src,
int64_t  n,
To *  dst 
)

Convert n values from type From to type To.

Exception Safety: Strong.

Before: src: initialized dst: uninitialized After: src: initialized dst: initialized

Definition at line 160 of file BLI_memory_utils.hh.

References BLI_assert, destruct_n(), and src.

◆ uninitialized_copy_n()

template<typename T >
void blender::uninitialized_copy_n ( const T src,
int64_t  n,
T dst 
)

◆ uninitialized_fill_n()

template<typename T >
void blender::uninitialized_fill_n ( T dst,
int64_t  n,
const T value 
)

◆ uninitialized_move_n()

template<typename T >
void blender::uninitialized_move_n ( T src,
int64_t  n,
T dst 
)

Move n values from src to dst.

Exception Safety: Basic.

Before: src: initialized dst: uninitialized After: src: initialized, moved-from dst: initialized

Definition at line 209 of file BLI_memory_utils.hh.

References BLI_assert, destruct_n(), src, and T.

Referenced by blender::cpp_type_util::move_construct_cb(), and uninitialized_relocate_n().

◆ uninitialized_relocate_n()

template<typename T >
void blender::uninitialized_relocate_n ( T src,
int64_t  n,
T dst 
)

Relocate n values from src to dst. Relocation is a move followed by destruction of the src value.

Exception Safety: Basic.

Before: src: initialized dst: uninitialized After: src: uninitialized dst: initialized

Definition at line 259 of file BLI_memory_utils.hh.

References BLI_assert, destruct_n(), src, and uninitialized_move_n().

Referenced by blender::Array< T, InlineBufferCapacity, Allocator >::Array(), and blender::Vector< T, InlineBufferCapacity, Allocator >::Vector().

Variable Documentation

◆ arrays

RawVector<RawArray<int64_t, 0> > blender::arrays
static

◆ current_array_mutex

std::mutex blender::current_array_mutex
static

Definition at line 14 of file BLI_index_range.cc.

◆ is_convertible_pointer_v

template<typename From , typename To >
constexpr bool blender::is_convertible_pointer_v
inlineconstexpr
Initial value:
=
std::is_convertible_v<From, To> &&std::is_pointer_v<From> &&std::is_pointer_v<To>

Helper variable that checks if a pointer type can be converted into another pointer type without issues. Possible issues are casting away const and casting a pointer to a child class. Adding const or casting to a parent class is fine.

Definition at line 485 of file BLI_memory_utils.hh.

◆ is_same_any_v

template<typename T , typename... Args>
constexpr bool blender::is_same_any_v = (std::is_same_v<T, Args> || ...)
inlineconstexpr

Same as #std::is_same_v but allows for checking multiple types at the same time.

Definition at line 511 of file BLI_memory_utils.hh.

Referenced by blender::detail::GVArrayAnyExtraInfo::get(), and blender::detail::VArrayAnyExtraInfo< T >::get().

◆ is_span_convertible_pointer_v

template<typename From , typename To >
constexpr bool blender::is_span_convertible_pointer_v
inlineconstexpr
Initial value:
=
std::is_pointer_v<From> &&std::is_pointer_v<To> &&
(
std::is_same_v<From, To> ||
std::is_same_v<const std::remove_pointer_t<From>, std::remove_pointer_t<To>> ||
(!std::is_const_v<std::remove_pointer_t<From>> && std::is_same_v<To, void *>) ||
std::is_same_v<To, const void *>)

Helper variable that checks if a Span<From> can be converted to Span<To> safely, whereby From and To are pointers. Adding const and casting to a void pointer is allowed. Casting up and down a class hierarchy generally is not allowed, because this might change the pointer under some circumstances.

Definition at line 495 of file BLI_memory_utils.hh.

◆ is_trivial_extended_v

template<typename T >
constexpr bool blender::is_trivial_extended_v = std::is_trivial_v<T>
inlineconstexpr

Under some circumstances #std::is_trivial_v<T> is false even though we know that the type is actually trivial. Using that extra knowledge allows for some optimizations.

Definition at line 25 of file BLI_memory_utils.hh.

◆ is_trivial_extended_v< GVArrayImpl_For_GSpan_final >

template<>
constexpr bool blender::is_trivial_extended_v< GVArrayImpl_For_GSpan_final > = true
inlineconstexpr

Definition at line 611 of file BLI_generic_virtual_array.hh.

◆ is_trivial_extended_v< GVArrayImpl_For_SingleValueRef_final >

template<>
constexpr bool blender::is_trivial_extended_v< GVArrayImpl_For_SingleValueRef_final > = true
inlineconstexpr

Definition at line 652 of file BLI_generic_virtual_array.hh.

◆ is_trivial_extended_v< VArrayImpl_For_DerivedSpan< StructT, ElemT, GetFunc, SetFunc > >

template<typename StructT , typename ElemT , ElemT(*)(const StructT &) GetFunc, void(*)(StructT &, ElemT) SetFunc>
constexpr bool blender::is_trivial_extended_v< VArrayImpl_For_DerivedSpan< StructT, ElemT, GetFunc, SetFunc > > = true
inlineconstexpr

Definition at line 538 of file BLI_virtual_array.hh.

◆ is_trivial_extended_v< VArrayImpl_For_Single< T > >

template<typename T >
constexpr bool blender::is_trivial_extended_v< VArrayImpl_For_Single< T > > = is_trivial_extended_v<T>
inlineconstexpr

Definition at line 389 of file BLI_virtual_array.hh.

◆ is_trivial_extended_v< VArrayImpl_For_Span_final< T > >

template<typename T >
constexpr bool blender::is_trivial_extended_v< VArrayImpl_For_Span_final< T > > = true
inlineconstexpr

Definition at line 326 of file BLI_virtual_array.hh.

◆ is_trivially_copy_constructible_extended_v

template<typename T >
constexpr bool blender::is_trivially_copy_constructible_extended_v
inlineconstexpr
Initial value:
=
is_trivial_extended_v<T> || std::is_trivially_copy_constructible_v<T>

Definition at line 30 of file BLI_memory_utils.hh.

◆ is_trivially_destructible_extended_v

template<typename T >
constexpr bool blender::is_trivially_destructible_extended_v
inlineconstexpr
Initial value:
= is_trivial_extended_v<T> ||
std::is_trivially_destructible_v<T>

Definition at line 27 of file BLI_memory_utils.hh.

◆ is_trivially_move_constructible_extended_v

template<typename T >
constexpr bool blender::is_trivially_move_constructible_extended_v
inlineconstexpr
Initial value:
=
is_trivial_extended_v<T> || std::is_trivially_move_constructible_v<T>

Definition at line 33 of file BLI_memory_utils.hh.

◆ is_VArray_v

template<typename T >
constexpr bool blender::is_VArray_v = false
staticconstexpr

Definition at line 1106 of file BLI_virtual_array.hh.

◆ is_VArray_v< VArray< T > >

template<typename T >
constexpr bool blender::is_VArray_v< VArray< T > > = true
staticconstexpr

Definition at line 1107 of file BLI_virtual_array.hh.

◆ is_VMutableArray_v

template<typename T >
constexpr bool blender::is_VMutableArray_v = false
staticconstexpr

Definition at line 1109 of file BLI_virtual_array.hh.

◆ is_VMutableArray_v< VMutableArray< T > >

template<typename T >
constexpr bool blender::is_VMutableArray_v< VMutableArray< T > > = true
staticconstexpr

Definition at line 1110 of file BLI_virtual_array.hh.