Blender V5.3
mesh_primitive_cuboid.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_attribute.hh"
10#include "BKE_mesh.hh"
11
13
14namespace blender::geometry {
15
27
29 : size(size),
33 edges_x(verts_x - 1),
34 edges_y(verts_y - 1),
35 edges_z(verts_z - 1)
36 {
37 BLI_assert(edges_x > 0 && edges_y > 0 && edges_z > 0);
38 this->vertex_count = this->get_vertex_count();
39 this->face_count = this->get_face_count();
40 this->loop_count = this->face_count * 4;
41 }
42
43 private:
44 int get_vertex_count()
45 {
46 const int inner_position_count = (verts_x - 2) * (verts_y - 2) * (verts_z - 2);
47 return verts_x * verts_y * verts_z - inner_position_count;
48 }
49
50 int get_face_count()
51 {
52 return 2 * (edges_x * edges_y + edges_y * edges_z + edges_z * edges_x);
53 }
54};
55
56static void calculate_positions(const CuboidConfig &config, MutableSpan<float3> positions)
57{
58 const float z_bottom = -config.size.z / 2.0f;
59 const float z_delta = config.size.z / config.edges_z;
60
61 const float x_left = -config.size.x / 2.0f;
62 const float x_delta = config.size.x / config.edges_x;
63
64 const float y_front = -config.size.y / 2.0f;
65 const float y_delta = config.size.y / config.edges_y;
66
67 int vert_index = 0;
68
69 for (const int z : IndexRange(config.verts_z)) {
70 if (ELEM(z, 0, config.edges_z)) {
71 /* Fill bottom and top. */
72 const float z_pos = z_bottom + z_delta * z;
73 for (const int y : IndexRange(config.verts_y)) {
74 const float y_pos = y_front + y_delta * y;
75 for (const int x : IndexRange(config.verts_x)) {
76 const float x_pos = x_left + x_delta * x;
77 positions[vert_index++] = float3(x_pos, y_pos, z_pos);
78 }
79 }
80 }
81 else {
82 for (const int y : IndexRange(config.verts_y)) {
83 if (ELEM(y, 0, config.edges_y)) {
84 /* Fill y-sides. */
85 const float y_pos = y_front + y_delta * y;
86 const float z_pos = z_bottom + z_delta * z;
87 for (const int x : IndexRange(config.verts_x)) {
88 const float x_pos = x_left + x_delta * x;
89 positions[vert_index++] = float3(x_pos, y_pos, z_pos);
90 }
91 }
92 else {
93 /* Fill x-sides. */
94 const float x_pos = x_left;
95 const float y_pos = y_front + y_delta * y;
96 const float z_pos = z_bottom + z_delta * z;
97 positions[vert_index++] = float3(x_pos, y_pos, z_pos);
98 const float x_pos2 = x_left + x_delta * config.edges_x;
99 positions[vert_index++] = float3(x_pos2, y_pos, z_pos);
100 }
101 }
102 }
103 }
104}
105
106/* vert_1 = bottom left, vert_2 = bottom right, vert_3 = top right, vert_4 = top left.
107 * Hence they are passed as 1,4,3,2 when calculating faces clockwise, and 1,2,3,4 for
108 * anti-clockwise.
109 */
110static void define_quad(MutableSpan<int> corner_verts,
111 const int corner,
112 const int vert_1,
113 const int vert_2,
114 const int vert_3,
115 const int vert_4)
116{
117 corner_verts[corner] = vert_1;
118 corner_verts[corner + 1] = vert_2;
119 corner_verts[corner + 2] = vert_3;
120 corner_verts[corner + 3] = vert_4;
121}
122
123static void calculate_corner_verts(const CuboidConfig &config, MutableSpan<int> corner_verts)
124{
125 int corner = 0;
126
127 /* Number of vertices in an XY cross-section of the cube (barring top and bottom faces). */
128 const int xy_cross_section_vert_count = config.verts_x * config.verts_y -
129 (config.verts_x - 2) * (config.verts_y - 2);
130
131 /* Calculate faces for Bottom faces. */
132 int vert_1_start = 0;
133
134 for ([[maybe_unused]] const int y : IndexRange(config.edges_y)) {
135 for (const int x : IndexRange(config.edges_x)) {
136 const int vert_1 = vert_1_start + x;
137 const int vert_2 = vert_1_start + config.verts_x + x;
138 const int vert_3 = vert_2 + 1;
139 const int vert_4 = vert_1 + 1;
140
141 define_quad(corner_verts, corner, vert_1, vert_2, vert_3, vert_4);
142 corner += 4;
143 }
144 vert_1_start += config.verts_x;
145 }
146
147 /* Calculate faces for Front faces. */
148 vert_1_start = 0;
149 int vert_2_start = config.verts_x * config.verts_y;
150
151 for ([[maybe_unused]] const int z : IndexRange(config.edges_z)) {
152 for (const int x : IndexRange(config.edges_x)) {
153 define_quad(corner_verts,
154 corner,
155 vert_1_start + x,
156 vert_1_start + x + 1,
157 vert_2_start + x + 1,
158 vert_2_start + x);
159 corner += 4;
160 }
161 vert_1_start = vert_2_start;
162 vert_2_start += config.verts_x * config.verts_y - (config.verts_x - 2) * (config.verts_y - 2);
163 }
164
165 /* Calculate faces for Top faces. */
166 vert_1_start = config.verts_x * config.verts_y +
167 (config.verts_z - 2) * (config.verts_x * config.verts_y -
168 (config.verts_x - 2) * (config.verts_y - 2));
169 vert_2_start = vert_1_start + config.verts_x;
170
171 for ([[maybe_unused]] const int y : IndexRange(config.edges_y)) {
172 for (const int x : IndexRange(config.edges_x)) {
173 define_quad(corner_verts,
174 corner,
175 vert_1_start + x,
176 vert_1_start + x + 1,
177 vert_2_start + x + 1,
178 vert_2_start + x);
179 corner += 4;
180 }
181 vert_2_start += config.verts_x;
182 vert_1_start += config.verts_x;
183 }
184
185 /* Calculate faces for Back faces. */
186 vert_1_start = config.verts_x * config.edges_y;
187 vert_2_start = vert_1_start + xy_cross_section_vert_count;
188
189 for (const int z : IndexRange(config.edges_z)) {
190 if (z == (config.edges_z - 1)) {
191 vert_2_start += (config.verts_x - 2) * (config.verts_y - 2);
192 }
193 for (const int x : IndexRange(config.edges_x)) {
194 define_quad(corner_verts,
195 corner,
196 vert_1_start + x,
197 vert_2_start + x,
198 vert_2_start + x + 1,
199 vert_1_start + x + 1);
200 corner += 4;
201 }
202 vert_2_start += xy_cross_section_vert_count;
203 vert_1_start += xy_cross_section_vert_count;
204 }
205
206 /* Calculate faces for Left faces. */
207 vert_1_start = 0;
208 vert_2_start = config.verts_x * config.verts_y;
209
210 for (const int z : IndexRange(config.edges_z)) {
211 for (const int y : IndexRange(config.edges_y)) {
212 int vert_1;
213 int vert_2;
214 int vert_3;
215 int vert_4;
216
217 if (z == 0 || y == 0) {
218 vert_1 = vert_1_start + config.verts_x * y;
219 vert_4 = vert_1 + config.verts_x;
220 }
221 else {
222 vert_1 = vert_1_start + 2 * y;
223 vert_1 += config.verts_x - 2;
224 vert_4 = vert_1 + 2;
225 }
226
227 if (y == 0 || z == (config.edges_z - 1)) {
228 vert_2 = vert_2_start + config.verts_x * y;
229 vert_3 = vert_2 + config.verts_x;
230 }
231 else {
232 vert_2 = vert_2_start + 2 * y;
233 vert_2 += config.verts_x - 2;
234 vert_3 = vert_2 + 2;
235 }
236
237 define_quad(corner_verts, corner, vert_1, vert_2, vert_3, vert_4);
238 corner += 4;
239 }
240 if (z == 0) {
241 vert_1_start += config.verts_x * config.verts_y;
242 }
243 else {
244 vert_1_start += xy_cross_section_vert_count;
245 }
246 vert_2_start += xy_cross_section_vert_count;
247 }
248
249 /* Calculate faces for Right faces. */
250 vert_1_start = config.edges_x;
251 vert_2_start = vert_1_start + config.verts_x * config.verts_y;
252
253 for (const int z : IndexRange(config.edges_z)) {
254 for (const int y : IndexRange(config.edges_y)) {
255 int vert_1 = vert_1_start;
256 int vert_2 = vert_2_start;
257 int vert_3 = vert_2_start + 2;
258 int vert_4 = vert_1 + config.verts_x;
259
260 if (z == 0) {
261 vert_1 = vert_1_start + config.verts_x * y;
262 vert_4 = vert_1 + config.verts_x;
263 }
264 else {
265 vert_1 = vert_1_start + 2 * y;
266 vert_4 = vert_1 + 2;
267 }
268
269 if (z == (config.edges_z - 1)) {
270 vert_2 = vert_2_start + config.verts_x * y;
271 vert_3 = vert_2 + config.verts_x;
272 }
273 else {
274 vert_2 = vert_2_start + 2 * y;
275 vert_3 = vert_2 + 2;
276 }
277
278 if (y == (config.edges_y - 1)) {
279 vert_3 = vert_2 + config.verts_x;
280 vert_4 = vert_1 + config.verts_x;
281 }
282
283 define_quad(corner_verts, corner, vert_1, vert_4, vert_3, vert_2);
284 corner += 4;
285 }
286 if (z == 0) {
287 vert_1_start += config.verts_x * config.verts_y;
288 }
289 else {
290 vert_1_start += xy_cross_section_vert_count;
291 }
292 vert_2_start += xy_cross_section_vert_count;
293 }
294}
295
296static void calculate_uvs(const CuboidConfig &config, Mesh *mesh, const StringRef uv_id)
297{
298 bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
301 MutableSpan<float2> uvs = uv_attribute.span;
302
303 int corner = 0;
304
305 const float x_delta = 0.25f / float(config.edges_x);
306 const float y_delta = 0.25f / float(config.edges_y);
307 const float z_delta = 0.25f / float(config.edges_z);
308
309 /* Calculate bottom face UVs. */
310 for (const int y : IndexRange(config.edges_y)) {
311 for (const int x : IndexRange(config.edges_x)) {
312 uvs[corner++] = float2(0.25f + x * x_delta, 0.375f - y * y_delta);
313 uvs[corner++] = float2(0.25f + x * x_delta, 0.375f - (y + 1) * y_delta);
314 uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f - (y + 1) * y_delta);
315 uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f - y * y_delta);
316 }
317 }
318
319 /* Calculate front face UVs. */
320 for (const int z : IndexRange(config.edges_z)) {
321 for (const int x : IndexRange(config.edges_x)) {
322 uvs[corner++] = float2(0.25f + x * x_delta, 0.375f + z * z_delta);
323 uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f + z * z_delta);
324 uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f + (z + 1) * z_delta);
325 uvs[corner++] = float2(0.25f + x * x_delta, 0.375f + (z + 1) * z_delta);
326 }
327 }
328
329 /* Calculate top face UVs. */
330 for (const int y : IndexRange(config.edges_y)) {
331 for (const int x : IndexRange(config.edges_x)) {
332 uvs[corner++] = float2(0.25f + x * x_delta, 0.625f + y * y_delta);
333 uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.625f + y * y_delta);
334 uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.625f + (y + 1) * y_delta);
335 uvs[corner++] = float2(0.25f + x * x_delta, 0.625f + (y + 1) * y_delta);
336 }
337 }
338
339 /* Calculate back face UVs. */
340 for (const int z : IndexRange(config.edges_z)) {
341 for (const int x : IndexRange(config.edges_x)) {
342 uvs[corner++] = float2(1.0f - x * x_delta, 0.375f + z * z_delta);
343 uvs[corner++] = float2(1.0f - x * x_delta, 0.375f + (z + 1) * z_delta);
344 uvs[corner++] = float2(1.0f - (x + 1) * x_delta, 0.375f + (z + 1) * z_delta);
345 uvs[corner++] = float2(1.0f - (x + 1) * x_delta, 0.375f + z * z_delta);
346 }
347 }
348
349 /* Calculate left face UVs. */
350 for (const int z : IndexRange(config.edges_z)) {
351 for (const int y : IndexRange(config.edges_y)) {
352 uvs[corner++] = float2(0.25f - y * y_delta, 0.375f + z * z_delta);
353 uvs[corner++] = float2(0.25f - y * y_delta, 0.375f + (z + 1) * z_delta);
354 uvs[corner++] = float2(0.25f - (y + 1) * y_delta, 0.375f + (z + 1) * z_delta);
355 uvs[corner++] = float2(0.25f - (y + 1) * y_delta, 0.375f + z * z_delta);
356 }
357 }
358
359 /* Calculate right face UVs. */
360 for (const int z : IndexRange(config.edges_z)) {
361 for (const int y : IndexRange(config.edges_y)) {
362 uvs[corner++] = float2(0.50f + y * y_delta, 0.375f + z * z_delta);
363 uvs[corner++] = float2(0.50f + (y + 1) * y_delta, 0.375f + z * z_delta);
364 uvs[corner++] = float2(0.50f + (y + 1) * y_delta, 0.375f + (z + 1) * z_delta);
365 uvs[corner++] = float2(0.50f + y * y_delta, 0.375f + (z + 1) * z_delta);
366 }
367 }
368
369 uv_attribute.finish();
370}
371
373 const int verts_x,
374 const int verts_y,
375 const int verts_z,
376 const std::optional<StringRef> uv_id)
377{
378 const CuboidConfig config(size, verts_x, verts_y, verts_z);
379
380 Mesh *mesh = BKE_mesh_new_nomain(config.vertex_count, 0, config.face_count, config.loop_count);
381 MutableSpan<float3> positions = mesh->vert_positions_for_write();
382 MutableSpan<int> corner_verts = mesh->corner_verts_for_write();
383 bke::mesh_smooth_set(*mesh, false);
384
385 calculate_positions(config, positions);
386 offset_indices::fill_constant_group_size(4, 0, mesh->face_offsets_for_write());
387 calculate_corner_verts(config, corner_verts);
388 bke::mesh_calc_edges(*mesh, false, false);
389
390 if (uv_id) {
391 calculate_uvs(config, mesh, *uv_id);
392 }
393
394 const float3 bounds = size * 0.5f;
395 mesh->bounds_set_eager({-bounds, bounds});
396 mesh->tag_loose_verts_none();
397 mesh->tag_overlapping_none();
398
399 return mesh;
400}
401
403 const int verts_x,
404 const int verts_y,
405 const int verts_z)
406{
407 return create_cuboid_mesh(size, verts_x, verts_y, verts_z, {});
408}
409
410} // namespace blender::geometry
#define ELEM(...)
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
constexpr IndexRange()=default
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void mesh_smooth_set(Mesh &mesh, bool use_smooth, bool keep_sharp_edges=false)
void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, bool select_new_edges)
Mesh * create_cuboid_mesh(const float3 &size, int verts_x, int verts_y, int verts_z, std::optional< StringRef > uv_id)
static void calculate_positions(const CuboidConfig &config, MutableSpan< float3 > positions)
static void define_quad(MutableSpan< int > corner_verts, const int corner, const int vert_1, const int vert_2, const int vert_3, const int vert_4)
static void calculate_uvs(const CuboidConfig &config, Mesh *mesh, const StringRef uv_id)
static void calculate_corner_verts(const CuboidConfig &config, MutableSpan< int > corner_verts)
void fill_constant_group_size(int size, int start_offset, MutableSpan< int > offsets)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
VecBase< float, 2 > float2
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
VecBase< float, 3 > float3
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
CuboidConfig(float3 size, int verts_x, int verts_y, int verts_z)