Blender V4.3
BLI_virtual_array_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "BLI_array.hh"
6#include "BLI_generic_virtual_array.hh"
7#include "BLI_vector.hh"
8#include "BLI_vector_set.hh"
9#include "BLI_virtual_array.hh"
10#include "testing/testing.h"
11
12#include "BLI_strict_flags.h" /* Keep last. */
13
14namespace blender::tests {
15
16TEST(virtual_array, Span)
17{
18 std::array<int, 5> data = {3, 4, 5, 6, 7};
19 VArray<int> varray = VArray<int>::ForSpan(data);
20 EXPECT_EQ(varray.size(), 5);
21 EXPECT_EQ(varray.get(0), 3);
22 EXPECT_EQ(varray.get(4), 7);
23 EXPECT_TRUE(varray.is_span());
24 EXPECT_FALSE(varray.is_single());
25 EXPECT_EQ(varray.get_internal_span().data(), data.data());
26}
27
28TEST(virtual_array, Single)
29{
30 VArray<int> varray = VArray<int>::ForSingle(10, 4);
31 EXPECT_EQ(varray.size(), 4);
32 EXPECT_EQ(varray.get(0), 10);
33 EXPECT_EQ(varray.get(3), 10);
34 EXPECT_FALSE(varray.is_span());
35 EXPECT_TRUE(varray.is_single());
36 EXPECT_EQ(varray.get_internal_single(), 10);
37}
38
39TEST(virtual_array, Array)
40{
41 Array<int> array = {1, 2, 3, 5, 8};
42 {
43 VArray<int> varray = VArray<int>::ForContainer(array);
44 EXPECT_EQ(varray.size(), 5);
45 EXPECT_EQ(varray[0], 1);
46 EXPECT_EQ(varray[2], 3);
47 EXPECT_EQ(varray[3], 5);
48 EXPECT_TRUE(varray.is_span());
49 }
50 {
51 VArray<int> varray = VArray<int>::ForContainer(std::move(array));
52 EXPECT_EQ(varray.size(), 5);
53 EXPECT_EQ(varray[0], 1);
54 EXPECT_EQ(varray[2], 3);
55 EXPECT_EQ(varray[3], 5);
56 EXPECT_TRUE(varray.is_span());
57 }
58 {
59 VArray<int> varray = VArray<int>::ForContainer(array); /* NOLINT: bugprone-use-after-move */
60 EXPECT_TRUE(varray.is_empty());
61 }
62}
63
64TEST(virtual_array, Vector)
65{
66 Vector<int> vector = {9, 8, 7, 6};
67 VArray<int> varray = VArray<int>::ForContainer(std::move(vector));
68 EXPECT_EQ(varray.size(), 4);
69 EXPECT_EQ(varray[0], 9);
70 EXPECT_EQ(varray[3], 6);
71}
72
73TEST(virtual_array, StdVector)
74{
75 std::vector<int> vector = {5, 6, 7, 8};
76 VArray<int> varray = VArray<int>::ForContainer(std::move(vector));
77 EXPECT_EQ(varray.size(), 4);
78 EXPECT_EQ(varray[0], 5);
79 EXPECT_EQ(varray[1], 6);
80}
81
82TEST(virtual_array, StdArray)
83{
84 std::array<int, 4> array = {2, 3, 4, 5};
85 VArray<int> varray = VArray<int>::ForContainer(std::move(array));
86 EXPECT_EQ(varray.size(), 4);
87 EXPECT_EQ(varray[0], 2);
88 EXPECT_EQ(varray[1], 3);
89}
90
91TEST(virtual_array, VectorSet)
92{
93 VectorSet<int> vector_set = {5, 3, 7, 3, 3, 5, 1};
94 VArray<int> varray = VArray<int>::ForContainer(std::move(vector_set));
95 EXPECT_TRUE(vector_set.is_empty()); /* NOLINT: bugprone-use-after-move. */
96 EXPECT_EQ(varray.size(), 4);
97 EXPECT_EQ(varray[0], 5);
98 EXPECT_EQ(varray[1], 3);
99 EXPECT_EQ(varray[2], 7);
100 EXPECT_EQ(varray[3], 1);
101}
102
103TEST(virtual_array, Func)
104{
105 auto func = [](int64_t index) { return int(index * index); };
106 VArray<int> varray = VArray<int>::ForFunc(10, func);
107 EXPECT_EQ(varray.size(), 10);
108 EXPECT_EQ(varray[0], 0);
109 EXPECT_EQ(varray[3], 9);
110 EXPECT_EQ(varray[9], 81);
111}
112
113TEST(virtual_array, AsSpan)
114{
115 auto func = [](int64_t index) { return int(10 * index); };
116 VArray<int> func_varray = VArray<int>::ForFunc(10, func);
117 VArraySpan span_varray{func_varray};
118 EXPECT_EQ(span_varray.size(), 10);
119 Span<int> span = span_varray;
120 EXPECT_EQ(span.size(), 10);
121 EXPECT_EQ(span[0], 0);
122 EXPECT_EQ(span[3], 30);
123 EXPECT_EQ(span[6], 60);
124}
125
126static int get_x(const std::array<int, 3> &item)
127{
128 return item[0];
129}
130
131static void set_x(std::array<int, 3> &item, int value)
132{
133 item[0] = value;
134}
135
136TEST(virtual_array, DerivedSpan)
137{
138 Vector<std::array<int, 3>> vector;
139 vector.append({3, 4, 5});
140 vector.append({1, 1, 1});
141 {
142 VArray<int> varray = VArray<int>::ForDerivedSpan<std::array<int, 3>, get_x>(vector);
143 EXPECT_EQ(varray.size(), 2);
144 EXPECT_EQ(varray[0], 3);
145 EXPECT_EQ(varray[1], 1);
146 }
147 {
148 VMutableArray<int> varray =
149 VMutableArray<int>::ForDerivedSpan<std::array<int, 3>, get_x, set_x>(vector);
150 EXPECT_EQ(varray.size(), 2);
151 EXPECT_EQ(varray[0], 3);
152 EXPECT_EQ(varray[1], 1);
153 varray.set(0, 10);
154 varray.set(1, 20);
155 EXPECT_EQ(vector[0][0], 10);
156 EXPECT_EQ(vector[1][0], 20);
157 }
158}
159
160TEST(virtual_array, MutableToImmutable)
161{
162 std::array<int, 4> array = {4, 2, 6, 4};
163 {
164 VMutableArray<int> mutable_varray = VMutableArray<int>::ForSpan(array);
165 VArray<int> varray = mutable_varray;
166 EXPECT_TRUE(varray.is_span());
167 EXPECT_EQ(varray.size(), 4);
168 EXPECT_EQ(varray[1], 2);
169 EXPECT_EQ(mutable_varray.size(), 4);
170 }
171 {
172 VMutableArray<int> mutable_varray = VMutableArray<int>::ForSpan(array);
173 EXPECT_EQ(mutable_varray.size(), 4);
174 VArray<int> varray = std::move(mutable_varray);
175 EXPECT_TRUE(varray.is_span());
176 EXPECT_EQ(varray.size(), 4);
177 EXPECT_EQ(varray[1], 2);
178 EXPECT_EQ(mutable_varray.size(), 0); /* NOLINT: bugprone-use-after-move */
179 }
180 {
181 VArray<int> varray = VMutableArray<int>::ForSpan(array);
182 EXPECT_TRUE(varray.is_span());
183 EXPECT_EQ(varray.size(), 4);
184 EXPECT_EQ(varray[1], 2);
185 }
186}
187
188TEST(virtual_array, MaterializeCompressed)
189{
190 IndexMaskMemory memory;
191 {
192 std::array<int, 10> array = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
193 VArray<int> varray = VArray<int>::ForSpan(array);
194 std::array<int, 3> compressed_array;
195 varray.materialize_compressed(IndexMask::from_indices<int>({3, 6, 7}, memory),
196 compressed_array);
197 EXPECT_EQ(compressed_array[0], 30);
198 EXPECT_EQ(compressed_array[1], 60);
199 EXPECT_EQ(compressed_array[2], 70);
200 varray.materialize_compressed_to_uninitialized(IndexMask::from_indices<int>({2, 8, 9}, memory),
201 compressed_array);
202 EXPECT_EQ(compressed_array[0], 20);
203 EXPECT_EQ(compressed_array[1], 80);
204 EXPECT_EQ(compressed_array[2], 90);
205 }
206 {
207 VArray<int> varray = VArray<int>::ForSingle(4, 10);
208 std::array<int, 3> compressed_array;
209 varray.materialize_compressed(IndexMask::from_indices<int>({2, 6, 7}, memory),
210 compressed_array);
211 EXPECT_EQ(compressed_array[0], 4);
212 EXPECT_EQ(compressed_array[1], 4);
213 EXPECT_EQ(compressed_array[2], 4);
214 compressed_array.fill(0);
215 varray.materialize_compressed_to_uninitialized(IndexMask::from_indices<int>({0, 1, 2}, memory),
216 compressed_array);
217 EXPECT_EQ(compressed_array[0], 4);
218 EXPECT_EQ(compressed_array[1], 4);
219 EXPECT_EQ(compressed_array[2], 4);
220 }
221 {
222 VArray<int> varray = VArray<int>::ForFunc(10, [](const int64_t i) { return int(i * i); });
223 std::array<int, 3> compressed_array;
224 varray.materialize_compressed(IndexMask::from_indices<int>({5, 7, 8}, memory),
225 compressed_array);
226 EXPECT_EQ(compressed_array[0], 25);
227 EXPECT_EQ(compressed_array[1], 49);
228 EXPECT_EQ(compressed_array[2], 64);
229 varray.materialize_compressed_to_uninitialized(IndexMask::from_indices<int>({1, 2, 3}, memory),
230 compressed_array);
231 EXPECT_EQ(compressed_array[0], 1);
232 EXPECT_EQ(compressed_array[1], 4);
233 EXPECT_EQ(compressed_array[2], 9);
234 }
235}
236
237TEST(virtual_array, EmptySpanWrapper)
238{
239 {
240 VArray<int> varray;
241 VArraySpan<int> span1 = varray;
242 EXPECT_TRUE(span1.is_empty());
243 VArraySpan<int> span2 = std::move(span1);
244 EXPECT_TRUE(span2.is_empty());
245 }
246 {
247 VMutableArray<int> varray;
248 MutableVArraySpan<int> span1 = varray;
249 EXPECT_TRUE(span1.is_empty());
250 MutableVArraySpan<int> span2 = std::move(span1);
251 EXPECT_TRUE(span2.is_empty());
252 }
253 {
254 GVArray varray;
255 GVArraySpan span1 = varray;
256 EXPECT_TRUE(span1.is_empty());
257 GVArraySpan span2 = std::move(span1);
258 EXPECT_TRUE(span2.is_empty());
259 }
260 {
261 GVMutableArray varray;
262 GMutableVArraySpan span1 = varray;
263 EXPECT_TRUE(span1.is_empty());
264 GMutableVArraySpan span2 = std::move(span1);
265 EXPECT_TRUE(span2.is_empty());
266 }
267}
268
269} // namespace blender::tests
BLI_array.hh
EXPECT_EQ
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
BLI_generic_virtual_array.hh
BLI_strict_flags.h
BLI_vector.hh
BLI_vector_set.hh
BLI_virtual_array.hh
vector
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Gabor Generate Gabor noise Gradient Generate interpolated color and intensity values based on the input vector Magic Generate a psychedelic color texture Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a vector
Definition NOD_static_types.h:111
blender::GSpan::is_empty
bool is_empty() const
Definition BLI_generic_span.hh:60
blender::MutableSpan::is_empty
constexpr bool is_empty() const
Definition BLI_span.hh:510
blender::Span::size
constexpr int64_t size() const
Definition BLI_span.hh:253
blender::Span::is_empty
constexpr bool is_empty() const
Definition BLI_span.hh:261
blender::VArrayCommon::materialize_compressed_to_uninitialized
void materialize_compressed_to_uninitialized(const IndexMask &mask, MutableSpan< T > r_span) const
Definition BLI_virtual_array.hh:762
blender::VArrayCommon::get
T get(const int64_t index) const
Definition BLI_virtual_array.hh:634
blender::VArrayCommon::materialize_compressed
void materialize_compressed(const IndexMask &mask, MutableSpan< T > r_span) const
Definition BLI_virtual_array.hh:757
blender::VArrayCommon::get_internal_span
Span< T > get_internal_span() const
Definition BLI_virtual_array.hh:694
blender::VArray::ForContainer
static VArray ForContainer(ContainerT container)
Definition BLI_virtual_array.hh:876
blender::VArray::ForSingle
static VArray ForSingle(T value, const int64_t size)
Definition BLI_virtual_array.hh:835
blender::VArray::ForSpan
static VArray ForSpan(Span< T > values)
Definition BLI_virtual_array.hh:844
blender::VArray::ForFunc
static VArray ForFunc(const int64_t size, GetFunc get_func)
Definition BLI_virtual_array.hh:853
blender::VMutableArray::set
void set(const int64_t index, T value)
Definition BLI_virtual_array.hh:981
blender::VMutableArray::ForSpan
static VMutableArray ForSpan(MutableSpan< T > values)
Definition BLI_virtual_array.hh:924
blender::index_mask::IndexMaskMemory
Definition BLI_index_mask.hh:108
blender::index_mask::IndexMask::from_indices
static IndexMask from_indices(Span< T > indices, IndexMaskMemory &memory)
Definition index_mask.cc:409
int
draw_view push_constant(Type::INT, "radiance_src") .push_constant(Type capture_info_buf storage_buf(1, Qualifier::READ, "ObjectBounds", "bounds_buf[]") .push_constant(Type draw_view int
Definition eevee_lightprobe_volume_info.hh:143
blender::tests::get_x
static int get_x(const std::array< int, 3 > &item)
Definition BLI_virtual_array_test.cc:126
blender::tests::set_x
static void set_x(std::array< int, 3 > &item, int value)
Definition BLI_virtual_array_test.cc:131
blender::tests::TEST
TEST(any, DefaultConstructor)
Definition BLI_any_test.cc:12
int64_t
__int64 int64_t
Definition stdint.h:89
Generated on Thu Feb 6 2025 07:36:39 for Blender by  doxygen 1.11.0