Blender V5.3
BlenderStrokeRenderer.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
12#include "../stroke/Canvas.h"
13
14#include "MEM_guardedalloc.h"
15
16#include "RNA_access.hh"
17#include "RNA_prototypes.hh"
18#include "RNA_types.hh"
19
20#include "DNA_camera_types.h"
22#include "DNA_linestyle_types.h"
23#include "DNA_listBase.h"
24#include "DNA_material_types.h"
25#include "DNA_mesh_types.h"
26#include "DNA_meshdata_types.h"
27#include "DNA_object_types.h"
28#include "DNA_scene_types.h"
29#include "DNA_screen_types.h"
30
31#include "BKE_attribute.h"
32#include "BKE_attribute.hh"
33#include "BKE_collection.hh"
34#include "BKE_customdata.hh"
35#include "BKE_global.hh"
36#include "BKE_idprop.hh"
37#include "BKE_layer.hh"
38#include "BKE_lib_id.hh" /* free_libblock */
39#include "BKE_main.hh"
40#include "BKE_material.hh"
41#include "BKE_mesh.hh"
42#include "BKE_node.hh"
45#include "BKE_object.hh"
46#include "BKE_scene.hh"
47
48#include "BLI_listbase.hh"
49#include "BLI_math_color_c.hh"
50#include "BLI_math_vector_c.hh"
52#include "BLI_utildefines.hh"
53
54#include "DEG_depsgraph.hh"
56
57#include "RE_pipeline.h"
58
59#include "render_types.h"
60
61#include <climits>
62
63using blender::float3;
65
66namespace Freestyle {
67
68const char *BlenderStrokeRenderer::uvNames[] = {"along_stroke", "along_stroke_tips"};
69
71{
72 using namespace blender;
73
75
76 /* NOTE(@sergey): We use the same window manager for freestyle `bmain` as real `bmain` uses.
77 * This is needed because freestyle's `bmain` could be used to tag scenes for update,
78 * which implies call of #ED_render_scene_update in some cases and that function
79 * requires proper window manager to present. */
80 freestyle_bmain->wm = re->main->wm;
81
82 // for stroke mesh generation
83 _width = re->winx;
84 _height = re->winy;
85
86 old_scene = re->scene;
87
88 char name[MAX_ID_NAME - 2];
89 SNPRINTF(name, "FRS%d_%s", render_count, re->scene->id.name + 2);
93 freestyle_scene->r.xsch = re->rectx; // old_scene->r.xsch
94 freestyle_scene->r.ysch = re->recty; // old_scene->r.ysch
95 freestyle_scene->r.xasp = 1.0f; // old_scene->r.xasp;
96 freestyle_scene->r.yasp = 1.0f; // old_scene->r.yasp;
97 freestyle_scene->r.size = 100; // old_scene->r.size
98 freestyle_scene->r.color_mgt_flag = 0; // old_scene->r.color_mgt_flag;
101 (re->r.scemode);
112 cout << "Stroke rendering engine : " << freestyle_scene->r.engine << endl;
113 }
116
117 // Copy ID properties, including Cycles render properties
118 if (old_scene->id.properties) {
120 }
123 0);
124 }
125 // Copy eevee render settings.
127
128 /* Render with transparent background. */
130
132 printf("%s: %d thread(s)\n", __func__, BKE_render_num_threads(&freestyle_scene->r));
133 }
134
136
137 // Scene layer.
138 ViewLayer *view_layer = (ViewLayer *)freestyle_scene->view_layers.first_;
139 view_layer->layflag = SCE_LAY_SOLID;
140
141 // Camera
142 Object *object_camera = BKE_object_add(
143 freestyle_bmain, freestyle_scene, view_layer, OB_CAMERA, nullptr);
144
145 Camera *camera = (Camera *)object_camera->data;
146 camera->type = CAM_ORTHO;
147 camera->ortho_scale = max(re->rectx, re->recty);
148 camera->clip_start = 0.1f;
149 camera->clip_end = 100.0f;
150
151 _z_delta = 0.00001f;
152 _z = camera->clip_start + _z_delta;
153
154 object_camera->loc[0] = re->disprect.xmin + 0.5f * re->rectx;
155 object_camera->loc[1] = re->disprect.ymin + 0.5f * re->recty;
156 object_camera->loc[2] = 1.0f;
157
158 freestyle_scene->camera = object_camera;
159
160 // Reset serial mesh ID (used for BlenderStrokeRenderer::NewMesh())
161 _mesh_id = 0xffffffff;
162
163 // Depsgraph
169}
170
172{
174
176
177 /* detach the window manager from freestyle bmain (see comments
178 * in add_freestyle() for more detail)
179 */
180 freestyle_bmain->wm.clear_no_delete();
181
183}
184
186{
187 float z = _z;
188 BlenderStrokeRenderer *self = const_cast<BlenderStrokeRenderer *>(this);
189 self->_z += _z_delta;
190 return -z;
191}
192
194{
195 uint mesh_id = _mesh_id;
196 BlenderStrokeRenderer *self = const_cast<BlenderStrokeRenderer *>(this);
197 self->_mesh_id--;
198 return mesh_id;
199}
200
202 blender::bNodeTree *iNodeTree,
203 bool do_id_user)
204{
205 using namespace blender;
206
207 Material *ma = BKE_material_add(bmain, "stroke_shader");
208 bNodeTree *ntree;
209 bNode *output_linestyle = nullptr;
210 bNodeSocket *fromsock, *tosock;
211 PointerRNA fromptr, toptr;
213
214 id_us_min(&ma->id);
215
216 if (iNodeTree) {
217 // make a copy of linestyle->nodetree
218 if (ma->nodetree) {
220 MEM_delete(ma->nodetree);
221 ma->nodetree = nullptr;
222 }
223 ntree = blender::bke::node_tree_copy_tree_ex(*iNodeTree, bmain, do_id_user);
224
225 // find the active Output Line Style node
226 for (bNode &node : ntree->nodes) {
227 if (node.type_legacy == SH_NODE_OUTPUT_LINESTYLE && (node.flag & NODE_DO_OUTPUT)) {
228 output_linestyle = &node;
229 break;
230 }
231 }
232 ma->nodetree = ntree;
233 ntree->owner_id = &ma->id;
234 }
235 else {
236 ntree = ma->nodetree;
237 }
238 ma->blend_method = MA_BM_HASHED;
239
240 bNode *input_attr_color = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_ATTRIBUTE);
241 input_attr_color->location[0] = 0.0f;
242 input_attr_color->location[1] = -200.0f;
243 storage = (NodeShaderAttribute *)input_attr_color->storage;
244 STRNCPY(storage->name, "Color");
245
247 nullptr, *ntree, SH_NODE_MIX_RGB_LEGACY);
248 mix_rgb_color->custom1 = MA_RAMP_BLEND; // Mix
249 mix_rgb_color->location[0] = 200.0f;
250 mix_rgb_color->location[1] = -200.0f;
251 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 0); // Fac
252 toptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, tosock);
253 RNA_float_set(&toptr, "default_value", 0.0f);
254
255 bNode *input_attr_alpha = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_ATTRIBUTE);
256 input_attr_alpha->location[0] = 400.0f;
257 input_attr_alpha->location[1] = 300.0f;
258 storage = (NodeShaderAttribute *)input_attr_alpha->storage;
259 STRNCPY(storage->name, "Alpha");
260
262 nullptr, *ntree, SH_NODE_MIX_RGB_LEGACY);
263 mix_rgb_alpha->custom1 = MA_RAMP_BLEND; // Mix
264 mix_rgb_alpha->location[0] = 600.0f;
265 mix_rgb_alpha->location[1] = 300.0f;
266 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 0); // Fac
267 toptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, tosock);
268 RNA_float_set(&toptr, "default_value", 0.0f);
269
270 bNode *shader_emission = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_EMISSION);
271 shader_emission->location[0] = 400.0f;
272 shader_emission->location[1] = -200.0f;
273
274 bNode *input_light_path = blender::bke::node_add_static_node(
275 nullptr, *ntree, SH_NODE_LIGHT_PATH);
276 input_light_path->location[0] = 400.0f;
277 input_light_path->location[1] = 100.0f;
278
279 bNode *mix_shader_color = blender::bke::node_add_static_node(
280 nullptr, *ntree, SH_NODE_MIX_SHADER);
281 mix_shader_color->location[0] = 600.0f;
282 mix_shader_color->location[1] = -100.0f;
283
284 bNode *shader_transparent = blender::bke::node_add_static_node(
285 nullptr, *ntree, SH_NODE_BSDF_TRANSPARENT);
286 shader_transparent->location[0] = 600.0f;
287 shader_transparent->location[1] = 100.0f;
288
289 bNode *mix_shader_alpha = blender::bke::node_add_static_node(
290 nullptr, *ntree, SH_NODE_MIX_SHADER);
291 mix_shader_alpha->location[0] = 800.0f;
292 mix_shader_alpha->location[1] = 100.0f;
293
294 bNode *output_material = blender::bke::node_add_static_node(
295 nullptr, *ntree, SH_NODE_OUTPUT_MATERIAL);
296 output_material->location[0] = 1000.0f;
297 output_material->location[1] = 100.0f;
298
299 fromsock = (bNodeSocket *)BLI_findlink(&input_attr_color->outputs, 0); // Color
300 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 1); // Color1
301 blender::bke::node_add_link(*ntree, *input_attr_color, *fromsock, *mix_rgb_color, *tosock);
302
303 fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->outputs, 0); // Color
304 tosock = (bNodeSocket *)BLI_findlink(&shader_emission->inputs, 0); // Color
305 blender::bke::node_add_link(*ntree, *mix_rgb_color, *fromsock, *shader_emission, *tosock);
306
307 fromsock = (bNodeSocket *)BLI_findlink(&shader_emission->outputs, 0); // Emission
308 tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 2); // Shader (second)
309 blender::bke::node_add_link(*ntree, *shader_emission, *fromsock, *mix_shader_color, *tosock);
310
311 fromsock = (bNodeSocket *)BLI_findlink(&input_light_path->outputs, 0); // In Camera Ray
312 tosock = (bNodeSocket *)BLI_findlink(&mix_shader_color->inputs, 0); // Fac
313 blender::bke::node_add_link(*ntree, *input_light_path, *fromsock, *mix_shader_color, *tosock);
314
315 fromsock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->outputs, 0); // Color
316 tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 0); // Fac
317 blender::bke::node_add_link(*ntree, *mix_rgb_alpha, *fromsock, *mix_shader_alpha, *tosock);
318
319 fromsock = (bNodeSocket *)BLI_findlink(&input_attr_alpha->outputs, 0); // Color
320 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 1); // Color1
321 blender::bke::node_add_link(*ntree, *input_attr_alpha, *fromsock, *mix_rgb_alpha, *tosock);
322
323 fromsock = (bNodeSocket *)BLI_findlink(&shader_transparent->outputs, 0); // BSDF
324 tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 1); // Shader (first)
325 blender::bke::node_add_link(*ntree, *shader_transparent, *fromsock, *mix_shader_alpha, *tosock);
326
327 fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_color->outputs, 0); // Shader
328 tosock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->inputs, 2); // Shader (second)
329 blender::bke::node_add_link(*ntree, *mix_shader_color, *fromsock, *mix_shader_alpha, *tosock);
330
331 fromsock = (bNodeSocket *)BLI_findlink(&mix_shader_alpha->outputs, 0); // Shader
332 tosock = (bNodeSocket *)BLI_findlink(&output_material->inputs, 0); // Surface
333 blender::bke::node_add_link(*ntree, *mix_shader_alpha, *fromsock, *output_material, *tosock);
334
335 if (output_linestyle) {
336 bNodeSocket *outsock;
337 bNodeLink *link;
338
339 mix_rgb_color->custom1 = output_linestyle->custom1; // blend_type
340 mix_rgb_color->custom2 = output_linestyle->custom2; // use_clamp
341
342 outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 0); // Color
343 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 2); // Color2
344 link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
345 if (link) {
347 *ntree, *link->fromnode, *link->fromsock, *mix_rgb_color, *tosock);
348 }
349 else {
350 float color[4];
351 fromptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, outsock);
352 toptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, tosock);
353 RNA_float_get_array(&fromptr, "default_value", color);
354 RNA_float_set_array(&toptr, "default_value", color);
355 }
356
357 outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 1); // Color Fac
358 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_color->inputs, 0); // Fac
359 link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
360 if (link) {
362 *ntree, *link->fromnode, *link->fromsock, *mix_rgb_color, *tosock);
363 }
364 else {
365 fromptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, outsock);
366 toptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, tosock);
367 RNA_float_set(&toptr, "default_value", RNA_float_get(&fromptr, "default_value"));
368 }
369
370 outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 2); // Alpha
371 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 2); // Color2
372 link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
373 if (link) {
375 *ntree, *link->fromnode, *link->fromsock, *mix_rgb_alpha, *tosock);
376 }
377 else {
378 float color[4];
379 fromptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, outsock);
380 toptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, tosock);
381 color[0] = color[1] = color[2] = RNA_float_get(&fromptr, "default_value");
382 color[3] = 1.0f;
383 RNA_float_set_array(&toptr, "default_value", color);
384 }
385
386 outsock = (bNodeSocket *)BLI_findlink(&output_linestyle->inputs, 3); // Alpha Fac
387 tosock = (bNodeSocket *)BLI_findlink(&mix_rgb_alpha->inputs, 0); // Fac
388 link = (bNodeLink *)BLI_findptr(&ntree->links, outsock, offsetof(bNodeLink, tosock));
389 if (link) {
391 *ntree, *link->fromnode, *link->fromsock, *mix_rgb_alpha, *tosock);
392 }
393 else {
394 fromptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, outsock);
395 toptr = RNA_pointer_create_discrete((ID *)ntree, RNA_NodeSocket, tosock);
396 RNA_float_set(&toptr, "default_value", RNA_float_get(&fromptr, "default_value"));
397 }
398
399 for (bNode &node : ntree->nodes) {
400 if (node.type_legacy == SH_NODE_UVALONGSTROKE) {
401 // UV output of the UV Along Stroke node
402 bNodeSocket *sock = (bNodeSocket *)BLI_findlink(&node.outputs, 0);
403
404 // add new UV Map node
405 bNode *input_uvmap = blender::bke::node_add_static_node(nullptr, *ntree, SH_NODE_UVMAP);
406 input_uvmap->location[0] = node.location[0] - 200.0f;
407 input_uvmap->location[1] = node.location[1];
409 if (node.custom1 & 1) { // use_tips
410 STRNCPY(storage->uv_map, uvNames[1]);
411 }
412 else {
413 STRNCPY(storage->uv_map, uvNames[0]);
414 }
415 fromsock = (bNodeSocket *)BLI_findlink(&input_uvmap->outputs, 0); // UV
416
417 // replace links from the UV Along Stroke node by links from the UV Map node
418 for (bNodeLink &link : ntree->links) {
419 if (link.fromnode == &node && link.fromsock == sock) {
421 *ntree, *input_uvmap, *fromsock, *link.tonode, *link.tosock);
422 }
423 }
425 }
426 }
427 }
428
429 blender::bke::node_set_active(*ntree, *output_material);
431
432 return ma;
433}
434
436{
437 RenderStrokeRepBasic(iStrokeRep);
438}
439
441{
442 using namespace blender;
443 bNodeTree *nt = iStrokeRep->getNodeTree();
444 Material *ma = _nodetree_hash.lookup_or_add_cb(
445 nt, [&]() { return BlenderStrokeRenderer::GetStrokeShader(freestyle_bmain, nt, false); });
446 iStrokeRep->setMaterial(ma);
447
448 const vector<Strip *> &strips = iStrokeRep->getStrips();
449 const bool hasTex = iStrokeRep->hasTex();
450 int totvert = 0, totedge = 0, faces_num = 0, totloop = 0;
451 int visible_faces, visible_segments;
452 for (vector<Strip *>::const_iterator s = strips.begin(), send = strips.end(); s != send; ++s) {
453 Strip::vertex_container &strip_vertices = (*s)->vertices();
454
455 // count visible faces and strip segments
456 test_strip_visibility(strip_vertices, &visible_faces, &visible_segments);
457 if (visible_faces == 0) {
458 continue;
459 }
460
461 totvert += visible_faces + visible_segments * 2;
462 totedge += visible_faces * 2 + visible_segments;
463 faces_num += visible_faces;
464 totloop += visible_faces * 3;
465 }
466
467 BlenderStrokeRenderer *self = const_cast<BlenderStrokeRenderer *>(this); // FIXME
468 vector<StrokeGroup *> *groups = hasTex ? &self->texturedStrokeGroups : &self->strokeGroups;
469 StrokeGroup *group;
470 if (groups->empty() || !(groups->back()->totvert + totvert < MESH_MAX_VERTS &&
471 groups->back()->materials.size() + 1 < MAXMAT))
472 {
473 group = new StrokeGroup;
474 groups->push_back(group);
475 }
476 else {
477 group = groups->back();
478 }
479 group->strokes.push_back(iStrokeRep);
480 group->totvert += totvert;
481 group->totedge += totedge;
482 group->faces_num += faces_num;
483 group->totloop += totloop;
484
485 if (!group->materials.contains(ma)) {
486 group->materials.add_new(ma, group->materials.size());
487 }
488}
489
490// Check if the triangle is visible (i.e., within the render image boundary)
492{
493 int xl, xu, yl, yu;
494 Vec2r p;
495
496 xl = xu = yl = yu = 0;
497 for (int i = 0; i < 3; i++) {
498 p = svRep[i]->point2d();
499 if (p[0] < 0.0) {
500 xl++;
501 }
502 else if (p[0] > _width) {
503 xu++;
504 }
505 if (p[1] < 0.0) {
506 yl++;
507 }
508 else if (p[1] > _height) {
509 yu++;
510 }
511 }
512 return !(xl == 3 || xu == 3 || yl == 3 || yu == 3);
513}
514
515// Check the visibility of faces and strip segments.
517 int *visible_faces,
518 int *visible_segments) const
519{
520 const int strip_vertex_count = strip_vertices.size();
521 Strip::vertex_container::iterator v[3];
522 StrokeVertexRep *svRep[3];
523 bool visible;
524
525 /* Iterate over all vertices and count visible faces and strip segments
526 * (NOTE: a strip segment is a series of visible faces, while two strip
527 * segments are separated by one or more invisible faces). */
528 v[0] = strip_vertices.begin();
529 v[1] = v[0] + 1;
530 v[2] = v[0] + 2;
531 *visible_faces = *visible_segments = 0;
532 visible = false;
533 for (int n = 2; n < strip_vertex_count; n++, v[0]++, v[1]++, v[2]++) {
534 svRep[0] = *(v[0]);
535 svRep[1] = *(v[1]);
536 svRep[2] = *(v[2]);
537 if (test_triangle_visibility(svRep)) {
538 (*visible_faces)++;
539 if (!visible) {
540 (*visible_segments)++;
541 }
542 visible = true;
543 }
544 else {
545 visible = false;
546 }
547 }
548}
549
550// Release allocated memory for stroke groups
552{
553 vector<StrokeGroup *>::const_iterator it, itend;
554
555 for (it = strokeGroups.begin(), itend = strokeGroups.end(); it != itend; ++it) {
556 delete (*it);
557 }
558 for (it = texturedStrokeGroups.begin(), itend = texturedStrokeGroups.end(); it != itend; ++it) {
559 delete (*it);
560 }
561}
562
563// Build a scene populated by mesh objects representing stylized strokes
565{
566 vector<StrokeGroup *>::const_iterator it, itend;
567
568 /* Each stroke is placed at a different z depth. Compute the delta based the number
569 * of vertices to try to maximize the available precision. */
570 int verts_num = 0;
571 for (it = strokeGroups.begin(), itend = strokeGroups.end(); it != itend; ++it) {
572 verts_num += (*it)->totvert;
573 }
574 for (it = texturedStrokeGroups.begin(), itend = texturedStrokeGroups.end(); it != itend; ++it) {
575 verts_num += (*it)->totvert;
576 }
577
578 const blender::Camera *camera = blender::id_cast<const blender::Camera *>(
580 const float z_range = 0.9f;
581 _z_delta = std::min((verts_num > 0) ? z_range / float(verts_num) : z_range, 1e-5f);
582 _z = camera->clip_start + _z_delta;
583
584 for (it = strokeGroups.begin(), itend = strokeGroups.end(); it != itend; ++it) {
585 GenerateStrokeMesh(*it, false);
586 }
587 for (it = texturedStrokeGroups.begin(), itend = texturedStrokeGroups.end(); it != itend; ++it) {
588 GenerateStrokeMesh(*it, true);
589 }
590 return get_stroke_count();
591}
592
593// Return the number of strokes
595{
596 return strokeGroups.size() + texturedStrokeGroups.size();
597}
598
599// Build a mesh object representing a group of stylized strokes
601{
602 using namespace blender;
603#if 0
604 Object *object_mesh = BKE_object_add(
607#else
608 Object *object_mesh = NewMesh();
609#endif
610 Mesh *mesh = (Mesh *)object_mesh->data;
611
612 mesh->verts_num = group->totvert;
613 mesh->edges_num = group->totedge;
614 mesh->faces_num = group->faces_num;
615 mesh->corners_num = group->totloop;
616 mesh->totcol = group->materials.size();
618 blender::bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
619 MutableSpan<int> face_offsets = mesh->face_offsets_for_write();
621 "position", bke::AttrDomain::Point);
622 bke::SpanAttributeWriter edge_verts_attr = attributes.lookup_or_add_for_write_span<int2>(
623 ".edge_verts", bke::AttrDomain::Edge);
624 bke::SpanAttributeWriter corner_vert_attr = attributes.lookup_or_add_for_write_span<int>(
625 ".corner_vert", bke::AttrDomain::Corner);
626 bke::SpanAttributeWriter corner_edge_attr = attributes.lookup_or_add_for_write_span<int>(
627 ".corner_edge", bke::AttrDomain::Corner);
628 bke::SpanAttributeWriter material_index_attr = attributes.lookup_or_add_for_write_span<int>(
629 "material_index", bke::AttrDomain::Face);
630 float3 *vert_positions = position_attr.span.data();
631 int2 *edges = edge_verts_attr.span.data();
632 int *corner_verts = corner_vert_attr.span.data();
633 int *corner_edges = corner_edge_attr.span.data();
634 int *material_indices = material_index_attr.span.data();
635
636 std::array<bke::SpanAttributeWriter<float2>, 2> uv_map_attrs;
637 blender::float2 *loopsuv[2] = {nullptr};
638
639 if (hasTex) {
640 // First UV layer
641 uv_map_attrs[0] = attributes.lookup_or_add_for_write_span<float2>(uvNames[0],
643 loopsuv[0] = uv_map_attrs[0].span.data();
644 mesh->uv_maps_active_set(uvNames[0]);
645
646 // Second UV layer
647 uv_map_attrs[1] = attributes.lookup_or_add_for_write_span<float2>(uvNames[1],
649 loopsuv[1] = uv_map_attrs[1].span.data();
650 mesh->uv_maps_active_set(uvNames[1]);
651 }
652
653 // colors and transparency (the latter represented by grayscale colors)
656 ColorGeometry4b *colors = colors_attr.span.data();
659 ColorGeometry4b *transp = transp_attr.span.data();
661
662 mesh->mat = MEM_new_array_uninitialized<Material *>(size_t(mesh->totcol), "MaterialList");
663 for (const auto item : group->materials.items()) {
664 Material *material = item.key;
665 const int matnr = item.value;
666 mesh->mat[matnr] = material;
667 if (material) {
668 id_us_plus(&material->id);
669 }
670 }
671
673 // Data copy
675
676 int vertex_index = 0, edge_index = 0, loop_index = 0, face_index = 0;
677 int visible_faces, visible_segments;
678 bool visible;
679 Strip::vertex_container::iterator v[3];
680 StrokeVertexRep *svRep[3];
681 Vec2r p;
682
683 for (vector<StrokeRep *>::const_iterator it = group->strokes.begin(),
684 itend = group->strokes.end();
685 it != itend;
686 ++it)
687 {
688 const int matnr = group->materials.lookup_default((*it)->getMaterial(), 0);
689
690 vector<Strip *> &strips = (*it)->getStrips();
691 for (vector<Strip *>::const_iterator s = strips.begin(), send = strips.end(); s != send; ++s) {
692 Strip::vertex_container &strip_vertices = (*s)->vertices();
693 int strip_vertex_count = strip_vertices.size();
694
695 // count visible faces and strip segments
696 test_strip_visibility(strip_vertices, &visible_faces, &visible_segments);
697 if (visible_faces == 0) {
698 continue;
699 }
700
701 v[0] = strip_vertices.begin();
702 v[1] = v[0] + 1;
703 v[2] = v[0] + 2;
704
705 visible = false;
706
707 // NOTE: Mesh generation in the following loop assumes stroke strips
708 // to be triangle strips.
709 for (int n = 2; n < strip_vertex_count; n++, v[0]++, v[1]++, v[2]++) {
710 svRep[0] = *(v[0]);
711 svRep[1] = *(v[1]);
712 svRep[2] = *(v[2]);
713 if (!test_triangle_visibility(svRep)) {
714 visible = false;
715 }
716 else {
717 if (!visible) {
718 // first vertex
719 vert_positions[vertex_index][0] = svRep[0]->point2d()[0];
720 vert_positions[vertex_index][1] = svRep[0]->point2d()[1];
721 vert_positions[vertex_index][2] = get_stroke_vertex_z();
722
723 ++vertex_index;
724
725 // second vertex
726 vert_positions[vertex_index][0] = svRep[1]->point2d()[0];
727 vert_positions[vertex_index][1] = svRep[1]->point2d()[1];
728 vert_positions[vertex_index][2] = get_stroke_vertex_z();
729
730 ++vertex_index;
731
732 // first edge
733 edges[edge_index][0] = vertex_index - 2;
734 edges[edge_index][1] = vertex_index - 1;
735 ++edge_index;
736 }
737 visible = true;
738
739 // vertex
740 vert_positions[vertex_index][0] = svRep[2]->point2d()[0];
741 vert_positions[vertex_index][1] = svRep[2]->point2d()[1];
742 vert_positions[vertex_index][2] = get_stroke_vertex_z();
743 ++vertex_index;
744
745 // edges
746 edges[edge_index][0] = vertex_index - 1;
747 edges[edge_index][1] = vertex_index - 3;
748 ++edge_index;
749
750 edges[edge_index][0] = vertex_index - 1;
751 edges[edge_index][1] = vertex_index - 2;
752 ++edge_index;
753
754 // poly
755 face_offsets[face_index] = loop_index;
756 *material_indices = matnr;
757 ++material_indices;
758 ++face_index;
759
760 // Even and odd loops connect triangles vertices differently
761 bool is_odd = n % 2;
762 // loops
763 if (is_odd) {
764 corner_verts[0] = vertex_index - 1;
765 corner_edges[0] = edge_index - 2;
766
767 corner_verts[1] = vertex_index - 3;
768 corner_edges[1] = edge_index - 3;
769
770 corner_verts[2] = vertex_index - 2;
771 corner_edges[2] = edge_index - 1;
772 }
773 else {
774 corner_verts[0] = vertex_index - 1;
775 corner_edges[0] = edge_index - 1;
776
777 corner_verts[1] = vertex_index - 2;
778 corner_edges[1] = edge_index - 3;
779
780 corner_verts[2] = vertex_index - 3;
781 corner_edges[2] = edge_index - 2;
782 }
783 corner_verts += 3;
784 corner_edges += 3;
785 loop_index += 3;
786
787 // UV
788 if (hasTex) {
789 // First UV layer (loopsuv[0]) has no tips (texCoord(0)).
790 // Second UV layer (loopsuv[1]) has tips: (texCoord(1)).
791 for (int L = 0; L < 2; L++) {
792 if (is_odd) {
793 loopsuv[L][0][0] = svRep[2]->texCoord(L).x();
794 loopsuv[L][0][1] = svRep[2]->texCoord(L).y();
795
796 loopsuv[L][1][0] = svRep[0]->texCoord(L).x();
797 loopsuv[L][1][1] = svRep[0]->texCoord(L).y();
798
799 loopsuv[L][2][0] = svRep[1]->texCoord(L).x();
800 loopsuv[L][2][1] = svRep[1]->texCoord(L).y();
801 }
802 else {
803 loopsuv[L][0][0] = svRep[2]->texCoord(L).x();
804 loopsuv[L][0][1] = svRep[2]->texCoord(L).y();
805
806 loopsuv[L][1][0] = svRep[1]->texCoord(L).x();
807 loopsuv[L][1][1] = svRep[1]->texCoord(L).y();
808
809 loopsuv[L][2][0] = svRep[0]->texCoord(L).x();
810 loopsuv[L][2][1] = svRep[0]->texCoord(L).y();
811 }
812 loopsuv[L] += 3;
813 }
814 }
815
816 // colors and alpha transparency. vertex colors are in sRGB
817 // space by convention, so convert from linear
818 float rgba[3][4];
819
820 for (int i = 0; i < 3; i++) {
821 copy_v3fl_v3db(rgba[i], &svRep[i]->color()[0]);
822 rgba[i][3] = svRep[i]->alpha();
823 }
824
825 if (is_odd) {
826 linearrgb_to_srgb_uchar4(&colors[0].r, rgba[2]);
827 linearrgb_to_srgb_uchar4(&colors[1].r, rgba[0]);
828 linearrgb_to_srgb_uchar4(&colors[2].r, rgba[1]);
829 }
830 else {
831 linearrgb_to_srgb_uchar4(&colors[0].r, rgba[2]);
832 linearrgb_to_srgb_uchar4(&colors[1].r, rgba[1]);
833 linearrgb_to_srgb_uchar4(&colors[2].r, rgba[0]);
834 }
835 transp[0].r = transp[0].g = transp[0].b = colors[0].a;
836 transp[1].r = transp[1].g = transp[1].b = colors[1].a;
837 transp[2].r = transp[2].g = transp[2].b = colors[2].a;
838 colors += 3;
839 transp += 3;
840 }
841 } // loop over strip vertices
842 } // loop over strips
843 } // loop over strokes
844
846
847 position_attr.finish();
848 edge_verts_attr.finish();
849 corner_vert_attr.finish();
850 corner_edge_attr.finish();
851 material_index_attr.finish();
852 uv_map_attrs[0].finish();
853 uv_map_attrs[1].finish();
854 colors_attr.finish();
855 transp_attr.finish();
856}
857
858// A replacement of BKE_object_add() for better performance.
860{
861 using namespace blender;
862 Object *ob;
863 char name[MAX_ID_NAME];
864 uint mesh_id = get_stroke_mesh_id();
865
866 SNPRINTF(name, "0%08xOB", mesh_id);
868 SNPRINTF(name, "0%08xME", mesh_id);
869 ob->data = blender::id_cast<ID *>(BKE_mesh_add(freestyle_bmain, name));
870
871 Collection *collection_master = freestyle_scene->master_collection;
872 BKE_collection_object_add(freestyle_bmain, collection_master, ob);
874
877 &ob->id,
879
880 return ob;
881}
882
884{
885 using namespace blender;
886#if 0
888 const Camera *camera = (const Camera *)freestyle_scene->camera->data;
889 cout << "clip_start " << camera->clip_start << ", clip_end " << camera->clip_end << endl;
890 }
891#endif
892
893 Render *freestyle_render = RE_NewSceneRender(freestyle_scene);
895
896 freestyle_render->pipeline_depsgraph = re->pipeline_depsgraph;
897 freestyle_render->pipeline_scene_eval = re->pipeline_scene_eval;
898
899 RE_RenderFreestyleStrokes(
900 freestyle_render, freestyle_bmain, freestyle_scene, render && get_stroke_count() > 0);
901
902 freestyle_render->pipeline_depsgraph = nullptr;
903 freestyle_render->pipeline_scene_eval = nullptr;
904
905 return freestyle_render;
906}
907
908} /* namespace Freestyle */
Configuration file.
Generic geometry attributes built on CustomData.
CustomData interface, see also DNA_customdata_types.h.
General operations, lookup, etc. for materials.
#define SH_NODE_MIX_SHADER
#define SH_NODE_MIX_RGB_LEGACY
#define SH_NODE_UVMAP
#define SH_NODE_EMISSION
#define SH_NODE_UVALONGSTROKE
#define SH_NODE_BSDF_TRANSPARENT
#define SH_NODE_OUTPUT_MATERIAL
#define SH_NODE_OUTPUT_LINESTYLE
#define SH_NODE_ATTRIBUTE
#define SH_NODE_LIGHT_PATH
General operations, lookup, etc. for blender objects.
#define SNPRINTF(dst, format,...)
Class to define a canvas designed to draw style modules.
#define MAX_ID_NAME
Definition DNA_ID.h:367
Object groups, one object can be in many groups at once.
These structs are the foundation for all linked lists in the library system.
#define MAXMAT
#define MESH_MAX_VERTS
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
btScalar max
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
Definition btQuadWord.h:117
BlenderStrokeRenderer(blender::Render *re, int render_count)
static blender::Material * GetStrokeShader(blender::Main *bmain, blender::bNodeTree *iNodeTree, bool do_id_user)
bool test_triangle_visibility(StrokeVertexRep *svRep[3]) const
vector< StrokeGroup * > texturedStrokeGroups
void test_strip_visibility(Strip::vertex_container &strip_vertices, int *visible_faces, int *visible_segments) const
void GenerateStrokeMesh(StrokeGroup *group, bool hasTex)
virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const
blender::Map< blender::bNodeTree *, blender::Material * > _nodetree_hash
blender::Render * RenderScene(blender::Render *re, bool render)
virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const
std::vector< StrokeVertexRep * > vertex_container
Definition StrokeRep.h:123
bool hasTex() const
Definition StrokeRep.h:214
blender::bNodeTree * getNodeTree() const
Definition StrokeRep.h:209
vector< Strip * > & getStrips()
Definition StrokeRep.h:219
void setMaterial(blender::Material *mat)
Definition StrokeRep.h:245
Vec2r & texCoord(bool tips=false)
Definition StrokeRep.h:66
value_type x() const
Definition VecMat.h:292
value_type y() const
Definition VecMat.h:302
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
#define printf
#define offsetof(t, d)
#define storage(slot, qualifiers)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str)
Definition mallocn.cc:129
#define L
VecMat::Vec2< real > Vec2r
Definition Geom.h:24
inherits from class Rep
Definition AppCanvas.cpp:20
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:4283
bNodeTree * node_tree_copy_tree_ex(const bNodeTree &ntree, Main *bmain, bool do_id_user)
Definition node.cc:5013
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
void node_remove_socket_links(bNodeTree &ntree, bNodeSocket &sock)
Definition node.cc:4702
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:5484
void node_tree_free_embedded_tree(bNodeTree *ntree)
Definition node.cc:5231
BMesh Iterators.
void DEG_graph_tag_relations_update(Depsgraph *graph)
void * BLI_findptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:710
void RNA_float_set_array(PointerRNA *ptr, const char *name, const float *values)
Object * BKE_object_add(Main *bmain, Scene *scene, ViewLayer *view_layer, ObjectType type, const char *name) ATTR_NONNULL(1
Definition object.cc:2296
char * STRNCPY(char(&dst)[N], const char *src)
unsigned int uint
Definition BKE_text.h:55
void DEG_graph_free(Depsgraph *graph)
Definition depsgraph.cc:307
void id_us_plus(ID *id)
Definition lib_id.cc:433
void BKE_mesh_face_offsets_ensure_alloc(Mesh *mesh)
void DEG_graph_id_tag_update(Main *bmain, Depsgraph *depsgraph, ID *id, unsigned int flags)
Main * BKE_main_new()
Definition main.cc:93
Depsgraph * DEG_graph_new(Main *bmain, Scene *scene, ViewLayer *view_layer, eEvaluationMode mode)
Definition depsgraph.cc:279
ATTR_WARN_UNUSED_RESULT const BMVert * v
@ G_DEBUG_FREESTYLE
Global G
Definition blender.cc:57
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
int BKE_render_num_threads(const RenderData *r)
Definition scene.cc:3141
VecBase< float, 2 > float2
void BKE_object_materials_sync_length(Main *bmain, Object *ob, ID *id)
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
Scene * BKE_scene_add(Main *bmain, const char *name)
Definition scene.cc:2200
bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
MINLINE void copy_v3fl_v3db(float r[3], const double a[3])
void BKE_main_free(Main *bmain)
Definition main.cc:202
void BKE_scene_set_background(Main *bmain, Scene *sce)
Definition scene.cc:2233
void BKE_id_attributes_active_color_set(struct ID *id, std::optional< StringRef > name)
Render * RE_NewSceneRender(const Scene *scene)
@ ID_RECALC_ANIMATION
Definition DNA_ID.h:1077
@ ID_RECALC_TRANSFORM
Definition DNA_ID.h:1054
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
void DEG_graph_relations_update(Depsgraph *graph)
void DEG_relations_tag_update(Main *bmain)
void BKE_scene_copy_data_eevee(Scene *sce_dst, const Scene *sce_src)
Definition scene.cc:1911
Material * BKE_material_add(Main *bmain, const char *name)
VecBase< float, 3 > float3
Object * BKE_object_add_only_object(Main *bmain, ObjectType type, const char *name) ATTR_RETURNS_NONNULL
Definition object.cc:2265
Mesh * BKE_mesh_add(Main *bmain, const char *name)
IDProperty * IDP_CopyProperty_ex(const IDProperty *prop, int flag) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:968
MINLINE void linearrgb_to_srgb_uchar4(unsigned char srgb[4], const float linear[4])
void id_us_min(ID *id)
Definition lib_id.cc:441
float RNA_float_get(PointerRNA *ptr, const char *name)
ColorSceneLinearByteEncoded4b< eAlpha::Premultiplied > ColorGeometry4b
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
blender::Map< blender::Material *, int > materials
char name[258]
Definition DNA_ID.h:433
IDProperty * system_properties
Definition DNA_ID.h:490
IDProperty * properties
Definition DNA_ID.h:481
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ImageFormatData im_format
struct Main * main
Scene * pipeline_scene_eval
struct Depsgraph * pipeline_depsgraph
ListBaseT< ViewLayer > view_layers
struct Collection * master_collection
struct Object * camera
struct RenderData r
ListBaseT< bNodeLink > links
ListBaseT< bNode > nodes
ListBaseT< bNodeSocket > outputs
ListBaseT< bNodeSocket > inputs