archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
be3e09ecec5372f87b3e9779adb821867b062be1
blender-archive/source/blender/nodes/CMakeLists.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

552 lines
19 KiB
CMake
Raw Normal View History

Patch to change license to GPL only, from GSR.
2008-01-07 19:13:47 +00:00
# ***** BEGIN GPL LICENSE BLOCK *****
patch to get cmake working with nodes now. Provided by Genscher. I still have linking issues with it but it is better as is so I'm commiting it. Hopefully will have it fixed fully shortly. Kent
2007-03-27 18:34:57 +00:00
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
Patch to change license to GPL only, from GSR.
2008-01-07 19:13:47 +00:00
# of the License, or (at your option) any later version.
patch to get cmake working with nodes now. Provided by Genscher. I still have linking issues with it but it is better as is so I'm commiting it. Hopefully will have it fixed fully shortly. Kent
2007-03-27 18:34:57 +00:00
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
correct fsf address
2010-02-12 13:34:04 +00:00
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
patch to get cmake working with nodes now. Provided by Genscher. I still have linking issues with it but it is better as is so I'm commiting it. Hopefully will have it fixed fully shortly. Kent
2007-03-27 18:34:57 +00:00
#
# The Original Code is Copyright (C) 2006, Blender Foundation
# All rights reserved.
Patch to change license to GPL only, from GSR.
2008-01-07 19:13:47 +00:00
# ***** END GPL LICENSE BLOCK *****
patch to get cmake working with nodes now. Provided by Genscher. I still have linking issues with it but it is better as is so I'm commiting it. Hopefully will have it fixed fully shortly. Kent
2007-03-27 18:34:57 +00:00
Adding a pixelate node. This makes it possible to create pixelized scale in the Tile compositor. Just append the node in front of a scale node or where you want the pixelization to take place. There were some bugs on this subject, but they used the work around to add a blur size of 0 in the place where they need the pixelization.
2012-10-24 08:36:10 +00:00
set(INC
- use list append in more places (preferred method since its faster) - remove some unused include paths - remove unused linux path define
2010-09-06 10:15:41 +00:00
.
code cleanup: - move object_iterators.c --> view3d_iterators. (ED_object.h had to include ED_view3d.h which isn't so nice) - move projection functions from view3d_view.c --> view3d_project.c (view3d_view was becoming a mishmash of utility functions and operators). - some some cmake includes as system-includes.
2012-10-17 04:13:03 +00:00
composite
Simulations: Add Boolean Math, Switch and Float Compare node UI Reviewers: brecht Differential Revision: https://developer.blender.org/D7424
2020-04-20 15:27:12 +02:00
function
Cleanup: sort cmake file lists
2020-12-11 15:00:22 +11:00
geometry
code cleanup: - move object_iterators.c --> view3d_iterators. (ED_object.h had to include ED_view3d.h which isn't so nice) - move projection functions from view3d_view.c --> view3d_project.c (view3d_view was becoming a mishmash of utility functions and operators). - some some cmake includes as system-includes.
2012-10-17 04:13:03 +00:00
intern
shader
texture
Cleanup: Register node property layout callbacks in files This commit moves the property layout callbacks for node types to their implementation files from `drawnode.c`. This was proposed a while ago in T75724. **Benefits** - Fewer files need to be changed when adding a new node. - Makes it possible to reuse functions from the node's implementation in the layout code. - Except for RNA, all of the node "inputs" are in the same place. - Code gets shorter overall, avoids the large switch statements. **Downsides** - Requires including two UI headers. - Requires adding an editors dependency to the nodes folder. This commit only changes function nodes and geometry nodes, more can be moved later. Differential Revision: https://developer.blender.org/D10352
2021-02-08 15:09:49 -06:00
../editors/include
- use list append in more places (preferred method since its faster) - remove some unused include paths - remove unused linux path define
2010-09-06 10:15:41 +00:00
../blenkernel
../blenlib
Refactor translation code out of blenfont - Add blentranslation `BLT_*` module. - moved & split `BLF_translation.h` into (`BLT_translation.h`, `BLT_lang.h`). - moved `BLF_*_unifont` functions from `blf_translation.c` to new source file `blf_font_i18n.c`.
2015-08-16 17:32:01 +10:00
../blentranslation
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
../bmesh
Object Mode: use eval_ctx for context/screen code
2018-02-06 17:28:00 +11:00
../depsgraph
Nodes: Generate multi-function network from node tree This adds new callbacks to `bNodeSocketType` and `bNodeType`. Those are used to generate a multi-function network from a node tree. Later, this network is evaluated on e.g. particle data. Reviewers: brecht Differential Revision: https://developer.blender.org/D8169
2020-07-07 18:23:33 +02:00
../functions
Geometry Nodes: Field version of mesh to curve node This commit adds a fields version of the mesh to curve node, with a field for the input selection. In order to reduce code duplication, it adds the mesh to curve conversion to the new geometry module and calls that implementation from both places. More details on the geometry module can be found here: T86869 Differential Revision: https://developer.blender.org/D12579
2021-10-14 12:06:48 -05:00
../geometry
- use list append in more places (preferred method since its faster) - remove some unused include paths - remove unused linux path define
2010-09-06 10:15:41 +00:00
../gpu
../imbuf
../makesdna
../makesrna
Cleanup: Render Module: move header files to main directory Move headers files from `render/extern/` to `render/` Part of T73586
2020-11-06 10:10:18 -05:00
../render
Ghost Context Refactor https://developer.blender.org/D643 Separates graphics context creation from window code in Ghost so that they can vary separately.
2014-10-07 15:46:19 -05:00
../../../intern/glew-mx
Cleanup: sort CMake include paths
2019-04-24 14:39:31 +10:00
../../../intern/guardedalloc
EEVEE: Implement the missing Sky texture I'm not sure if the Sky was deliberately left out or was just waiting for a better moment, but so many I was disappointed that Sky in EEVEE is completely white. There are already 2 implementations (osl and gpu) so this is the third one. Looking at other cases it seems that we are not supposed to share sources between cycles and the rest? So the new util_sky_model files are just copies of what is already in cycles, except that the data file uses the RGB variant of the Hosek/Wilkie model, because we output RGB anyway (but can be easily changed to XYZ if desired - the results are nearly identical). I am not sure if it is okay to pass 3*9 float values as 3 mat4 uniforms (I wanted to use mat3 but it does not work). Also, should I cache the sky model data between renders if the parameters do not change? Reviewed By: fclem, brecht Differential Revision: https://developer.blender.org/D7108
2020-07-09 17:19:52 +02:00
../../../intern/sky/include
cmake maintenance blender_add_lib now takes a separate include argument to suppress warnings in system includes (mostly ffmpeg & python). also only build wm_apple.c on apple+carbon configuration.
2011-05-31 01:15:44 +00:00
)
patch to get cmake working with nodes now. Provided by Genscher. I still have linking issues with it but it is better as is so I'm commiting it. Hopefully will have it fixed fully shortly. Kent
2007-03-27 18:34:57 +00:00
use explicit file paths for CMake rather then globing, This is recommended by cmake devs. globbing vs explicit is discussed here. http://www.cmake.org/pipermail/cmake/2008-December/025694.html Practical implications are: - developers need to keep CMakeLists.txt files up to date. - Users wont get strange linking errors if they build after a file is added, since CMake detects CMakeLists.txt is modified and automatically reconfigure.
2010-10-23 04:05:55 +00:00
set(SRC
Cleanup: convert compositor nodes to c++ - Many cleanups of to use list base - Some variable changes These change is needed to migrate to the new socket builder API Reviewed By: manzanilla Differential Revision: https://developer.blender.org/D12366
2021-09-28 15:29:16 -04:00
composite/nodes/node_composite_alphaOver.cc
composite/nodes/node_composite_antialiasing.cc
composite/nodes/node_composite_bilateralblur.cc
composite/nodes/node_composite_blur.cc
composite/nodes/node_composite_bokehblur.cc
composite/nodes/node_composite_bokehimage.cc
composite/nodes/node_composite_boxmask.cc
composite/nodes/node_composite_brightness.cc
composite/nodes/node_composite_channelMatte.cc
composite/nodes/node_composite_chromaMatte.cc
composite/nodes/node_composite_colorMatte.cc
composite/nodes/node_composite_colorSpill.cc
composite/nodes/node_composite_colorbalance.cc
composite/nodes/node_composite_colorcorrection.cc
composite/nodes/node_composite_common.cc
composite/nodes/node_composite_composite.cc
composite/nodes/node_composite_cornerpin.cc
composite/nodes/node_composite_crop.cc
Cleanup: Make node_composite_cryptomatte CPP. Core API of cryptomatte is also CPP.
2021-03-03 12:34:03 +01:00
composite/nodes/node_composite_cryptomatte.cc
Cleanup: convert compositor nodes to c++ - Many cleanups of to use list base - Some variable changes These change is needed to migrate to the new socket builder API Reviewed By: manzanilla Differential Revision: https://developer.blender.org/D12366
2021-09-28 15:29:16 -04:00
composite/nodes/node_composite_curves.cc
composite/nodes/node_composite_defocus.cc
composite/nodes/node_composite_denoise.cc
composite/nodes/node_composite_despeckle.cc
composite/nodes/node_composite_diffMatte.cc
composite/nodes/node_composite_dilate.cc
composite/nodes/node_composite_directionalblur.cc
composite/nodes/node_composite_displace.cc
composite/nodes/node_composite_distanceMatte.cc
composite/nodes/node_composite_doubleEdgeMask.cc
composite/nodes/node_composite_ellipsemask.cc
composite/nodes/node_composite_exposure.cc
composite/nodes/node_composite_filter.cc
composite/nodes/node_composite_flip.cc
composite/nodes/node_composite_gamma.cc
composite/nodes/node_composite_glare.cc
composite/nodes/node_composite_hueSatVal.cc
composite/nodes/node_composite_huecorrect.cc
composite/nodes/node_composite_idMask.cc
composite/nodes/node_composite_image.cc
composite/nodes/node_composite_inpaint.cc
composite/nodes/node_composite_invert.cc
composite/nodes/node_composite_keying.cc
composite/nodes/node_composite_keyingscreen.cc
composite/nodes/node_composite_lensdist.cc
composite/nodes/node_composite_levels.cc
composite/nodes/node_composite_lummaMatte.cc
composite/nodes/node_composite_mapRange.cc
composite/nodes/node_composite_mapUV.cc
composite/nodes/node_composite_mapValue.cc
composite/nodes/node_composite_mask.cc
composite/nodes/node_composite_math.cc
composite/nodes/node_composite_mixrgb.cc
composite/nodes/node_composite_movieclip.cc
composite/nodes/node_composite_moviedistortion.cc
composite/nodes/node_composite_normal.cc
composite/nodes/node_composite_normalize.cc
composite/nodes/node_composite_outputFile.cc
composite/nodes/node_composite_pixelate.cc
composite/nodes/node_composite_planetrackdeform.cc
composite/nodes/node_composite_posterize.cc
composite/nodes/node_composite_premulkey.cc
composite/nodes/node_composite_rgb.cc
composite/nodes/node_composite_rotate.cc
composite/nodes/node_composite_scale.cc
composite/nodes/node_composite_sepcombHSVA.cc
composite/nodes/node_composite_sepcombRGBA.cc
composite/nodes/node_composite_sepcombYCCA.cc
composite/nodes/node_composite_sepcombYUVA.cc
composite/nodes/node_composite_setalpha.cc
composite/nodes/node_composite_splitViewer.cc
composite/nodes/node_composite_stabilize2d.cc
composite/nodes/node_composite_sunbeams.cc
composite/nodes/node_composite_switch.cc
composite/nodes/node_composite_switchview.cc
composite/nodes/node_composite_texture.cc
composite/nodes/node_composite_tonemap.cc
composite/nodes/node_composite_trackpos.cc
composite/nodes/node_composite_transform.cc
composite/nodes/node_composite_translate.cc
composite/nodes/node_composite_valToRgb.cc
composite/nodes/node_composite_value.cc
composite/nodes/node_composite_vecBlur.cc
composite/nodes/node_composite_viewer.cc
composite/nodes/node_composite_zcombine.cc
Adding a pixelate node. This makes it possible to create pixelized scale in the Tile compositor. Just append the node in front of a scale node or where you want the pixelization to take place. There were some bugs on this subject, but they used the work around to add a blur size of 0 in the place where they need the pixelization.
2012-10-24 08:36:10 +00:00
Cleanup: convert compositor nodes to c++ - Many cleanups of to use list base - Some variable changes These change is needed to migrate to the new socket builder API Reviewed By: manzanilla Differential Revision: https://developer.blender.org/D12366
2021-09-28 15:29:16 -04:00
composite/node_composite_tree.cc
composite/node_composite_util.cc
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
Geometry Nodes: Random Value Node This node replaces the deprecated Attribute Randomize node, populating a vector, float, integer or boolean field with random values. Vector, float, and integer have min/max settings, which are also field aware. The boolean type has a probability value for controlling what portion of the output should be true. All four types have a field seed input which is implicitly driven by the index, otherwise, all values would be the same "random" value. The Random Float node is now deprecated like other nodes, since it is redundant with this node. Differential Revision: https://developer.blender.org/D12603
2021-09-24 14:03:42 -05:00
function/nodes/legacy/node_fn_random_float.cc
Geometry Nodes: Align Euler to Vector Node This commit introduces the Align Euler to Vector function node which rotates to a body into a given direction. The node replaces the legacy "Align Rotation to Vector" node, which only worked on an attribute named `rotation` internally. The "Euler" in the name is meant to make it clearer that the rotation isn't interchangeable with a regular vector. Addresses T91374. Differential Revision: https://developer.blender.org/D12726
2021-10-09 14:40:37 -05:00
function/nodes/node_fn_align_euler_to_vector.cc
Simulations: Add Boolean Math, Switch and Float Compare node UI Reviewers: brecht Differential Revision: https://developer.blender.org/D7424
2020-04-20 15:27:12 +02:00
function/nodes/node_fn_boolean_math.cc
function/nodes/node_fn_float_compare.cc
Geometry Nodes: Add explicit Float to Int conversion node This patch adds a very simple node that explicitly converts a float to an int. While this may seem redundant, it would offer 2 benefits to the current requirement to use implicit float conversions: 1. It makes the node tree's intent more clear and self-documenting (especially if changes in the future require integer inputs). 2. It eliminates undefined behavior in current/future nodes from float inputs by guaranteeing that the input is an integer. The node offers a variety of rounding techniques to make it more flexible. Differential Revision: https://developer.blender.org/D11700
2021-07-05 11:52:10 -05:00
function/nodes/node_fn_float_to_int.cc
Geometry Nodes: add Boolean and Integer Input nodes These nodes just output a single value of their respective types, making it possible to control multiple inputs with the same value. Differential Revision: https://developer.blender.org/D12932
2021-10-22 14:59:15 +02:00
function/nodes/node_fn_input_bool.cc
Cleanup: sort cmake file lists
2021-10-20 09:17:46 +11:00
function/nodes/node_fn_input_color.cc
Geometry Nodes: add Boolean and Integer Input nodes These nodes just output a single value of their respective types, making it possible to control multiple inputs with the same value. Differential Revision: https://developer.blender.org/D12932
2021-10-22 14:59:15 +02:00
function/nodes/node_fn_input_int.cc
Geometry Nodes: Special string characters node This patch adds a new node called "Special Characters" with two string outputs: "Line Break" and "Tab". This is necessary because the newline character cannot be easily typed with a keyboard, but is necessary for the string to curve node. Differential Revision: https://developer.blender.org/D12620
2021-09-24 10:59:52 -05:00
function/nodes/node_fn_input_special_characters.cc
Geometry Nodes: Add string input node This commit adds a simple string input node, intended for use in the attribute workflow to make using the same attribute name in multiple places easier. The node is function node similar to the existing vector input node. Ref T84971 Differential Revision: https://developer.blender.org/D10316
2021-02-19 16:03:14 -06:00
function/nodes/node_fn_input_string.cc
Function Nodes: Input Vector Ref: T82651 Normally people use "Combine XYZ" to input a vector, but it is more interesting to have an explicit vector input. So this is basically "Combine XYZ" without any input sockets, the values are stored in the node itself. Differential Revision: https://developer.blender.org/D9885
2020-12-17 18:37:04 +01:00
function/nodes/node_fn_input_vector.cc
Geometry Nodes: Random Value Node This node replaces the deprecated Attribute Randomize node, populating a vector, float, integer or boolean field with random values. Vector, float, and integer have min/max settings, which are also field aware. The boolean type has a probability value for controlling what portion of the output should be true. All four types have a field seed input which is implicitly driven by the index, otherwise, all values would be the same "random" value. The Random Float node is now deprecated like other nodes, since it is redundant with this node. Differential Revision: https://developer.blender.org/D12603
2021-09-24 14:03:42 -05:00
function/nodes/node_fn_random_value.cc
Geometry Nodes: Replace String node This commit adds a node that can be used to find and replace strings inside of the input string. One initial use case is to have an easier way to add line breaks to strings to the string to curves node. Differential Revision: https://developer.blender.org/D12721
2021-10-19 15:27:47 -05:00
function/nodes/node_fn_replace_string.cc
Geometry Nodes: Add Rotate Euler Node This commit introduces the Rotate Euler function node which modifies an input euler rotation. The node replaces the "Point Rotate" node. Addresses T91375. Differential Revision: https://developer.blender.org/D12531
2021-10-02 20:04:45 -05:00
function/nodes/node_fn_rotate_euler.cc
Geometry Nodes: Rename node "String Substring" This patch renames the node "String Substring" to "Slice String" to conform to the "verb first" naming convention. Default length is also changed to 10 to make it easier for users to understand what the node does. Reviewed By: HooglyBoogly Differential Revision: https://developer.blender.org/D12931
2021-10-24 11:19:10 +02:00
function/nodes/node_fn_slice_string.cc
Geometry Nodes: String manipulation nodes This patch adds four new nodes to a new "Text" category: - String Length: Outputs length of a string - String Substring: Outputs part of a string - Value to String: Converts a value to a string - String Join: Concatenates multiple strings with a delimiter The initial use case of these nodes is the upcoming string to curve node. However, they could also be used to calculate dynamic attribute names, or with string attributes in the future. Differential Revision: https://developer.blender.org/D12532
2021-09-21 14:11:32 -05:00
function/nodes/node_fn_string_length.cc
function/nodes/node_fn_value_to_string.cc
Simulations: Add Boolean Math, Switch and Float Compare node UI Reviewers: brecht Differential Revision: https://developer.blender.org/D7424
2020-04-20 15:27:12 +02:00
function/node_function_util.cc
Geometry Nodes: move legacy nodes to separate folder Previously, we were moving them one by one. It's a lot easier to just move all files at the same time.
2021-09-28 11:31:35 +02:00
geometry/nodes/legacy/node_geo_align_rotation_to_vector.cc
geometry/nodes/legacy/node_geo_attribute_clamp.cc
geometry/nodes/legacy/node_geo_attribute_color_ramp.cc
geometry/nodes/legacy/node_geo_attribute_combine_xyz.cc
geometry/nodes/legacy/node_geo_attribute_compare.cc
geometry/nodes/legacy/node_geo_attribute_convert.cc
geometry/nodes/legacy/node_geo_attribute_curve_map.cc
geometry/nodes/legacy/node_geo_attribute_fill.cc
geometry/nodes/legacy/node_geo_attribute_map_range.cc
geometry/nodes/legacy/node_geo_attribute_math.cc
geometry/nodes/legacy/node_geo_attribute_mix.cc
geometry/nodes/legacy/node_geo_attribute_proximity.cc
Geometry Nodes: Random Value Node This node replaces the deprecated Attribute Randomize node, populating a vector, float, integer or boolean field with random values. Vector, float, and integer have min/max settings, which are also field aware. The boolean type has a probability value for controlling what portion of the output should be true. All four types have a field seed input which is implicitly driven by the index, otherwise, all values would be the same "random" value. The Random Float node is now deprecated like other nodes, since it is redundant with this node. Differential Revision: https://developer.blender.org/D12603
2021-09-24 14:03:42 -05:00
geometry/nodes/legacy/node_geo_attribute_randomize.cc
Geometry Nodes: move legacy nodes to separate folder Previously, we were moving them one by one. It's a lot easier to just move all files at the same time.
2021-09-28 11:31:35 +02:00
geometry/nodes/legacy/node_geo_attribute_sample_texture.cc
geometry/nodes/legacy/node_geo_attribute_separate_xyz.cc
geometry/nodes/legacy/node_geo_attribute_transfer.cc
geometry/nodes/legacy/node_geo_attribute_vector_math.cc
geometry/nodes/legacy/node_geo_attribute_vector_rotate.cc
Geometry Nodes: Move more nodes to legacy - Curve to Points: Needs output sockets - Curve Endpoitns: Needs the same output sockets - Edge Split: Should have a selection input instead - Subdivision Surface: Should not use "crease" implicitly All new versions of these nodes should also not implicitly realize instances.
2021-09-28 11:03:12 -05:00
geometry/nodes/legacy/node_geo_curve_endpoints.cc
Geometry Nodes: move legacy nodes to separate folder Previously, we were moving them one by one. It's a lot easier to just move all files at the same time.
2021-09-28 11:31:35 +02:00
geometry/nodes/legacy/node_geo_curve_reverse.cc
geometry/nodes/legacy/node_geo_curve_select_by_handle_type.cc
geometry/nodes/legacy/node_geo_curve_set_handles.cc
geometry/nodes/legacy/node_geo_curve_spline_type.cc
geometry/nodes/legacy/node_geo_curve_subdivide.cc
Geometry Nodes: Move more nodes to legacy - Curve to Points: Needs output sockets - Curve Endpoitns: Needs the same output sockets - Edge Split: Should have a selection input instead - Subdivision Surface: Should not use "crease" implicitly All new versions of these nodes should also not implicitly realize instances.
2021-09-28 11:03:12 -05:00
geometry/nodes/legacy/node_geo_curve_to_points.cc
Geometry Nodes: move legacy nodes to separate folder Previously, we were moving them one by one. It's a lot easier to just move all files at the same time.
2021-09-28 11:31:35 +02:00
geometry/nodes/legacy/node_geo_delete_geometry.cc
Geometry Nodes: Move more nodes to legacy - Curve to Points: Needs output sockets - Curve Endpoitns: Needs the same output sockets - Edge Split: Should have a selection input instead - Subdivision Surface: Should not use "crease" implicitly All new versions of these nodes should also not implicitly realize instances.
2021-09-28 11:03:12 -05:00
geometry/nodes/legacy/node_geo_edge_split.cc
Geometry Nodes: Add fields version of material nodes This commit moves the old material nodes to a "legacy" folder and adds versions of the nodes that work with fields. The "Select by Material" node is a field node now, so it doesn't have a geometry output. This is an improvement because there are fewer links to connect, and it's more easily usable in different situations. It's also called "Material Selection", since it's more of an input than an action now. It's sometimes necessary to use the attribute capture node to get a more predictable interpolation to mesh faces. This is because the selection field input is always evaluated on the face domain, so attribute inputs are interpolated before they are booleans, so they cannot use the new interpolations from rB5841f8656d9580d7b9. Differential Revision: https://developer.blender.org/D12456
2021-09-15 10:51:52 -05:00
geometry/nodes/legacy/node_geo_material_assign.cc
Geometry Nodes: move legacy nodes to separate folder Previously, we were moving them one by one. It's a lot easier to just move all files at the same time.
2021-09-28 11:31:35 +02:00
geometry/nodes/legacy/node_geo_mesh_to_curve.cc
Geometry Nodes: new Distribute Points on Faces node This adds a replacement for the deprecated Point Distribute node. Arguments for the name change can be found in T91155. Descriptions of the sockets are available in D12536. Thanks to Jarrett Johnson for the initial patch! Differential Revision: https://developer.blender.org/D12536
2021-09-24 11:50:02 +02:00
geometry/nodes/legacy/node_geo_point_distribute.cc
Geometry Nodes: new Instance on Points node This adds a new Instance on Points node that is a replacement for the old Point Instance node. Contrary to the old node, it does not have a mode to instance objects or collections directly. Instead, the node has to be used with an Object/ Collection Info to achieve the same effect. Rotation and scale of the instances can be adjusted in the node directly or can be controlled with a field to get some variation between instances. The node supports placing different instances on different points. The user has control over which instance is placed on which point using an Instance Index input. If that functionality is used, the Instance Geometry has to contain multiple instances that can are instanced separately. Differential Revision: https://developer.blender.org/D12478
2021-09-27 10:16:38 +02:00
geometry/nodes/legacy/node_geo_point_instance.cc
Geometry Nodes: move legacy nodes to separate folder Previously, we were moving them one by one. It's a lot easier to just move all files at the same time.
2021-09-28 11:31:35 +02:00
geometry/nodes/legacy/node_geo_point_rotate.cc
geometry/nodes/legacy/node_geo_point_scale.cc
geometry/nodes/legacy/node_geo_point_separate.cc
geometry/nodes/legacy/node_geo_point_translate.cc
geometry/nodes/legacy/node_geo_points_to_volume.cc
geometry/nodes/legacy/node_geo_raycast.cc
geometry/nodes/legacy/node_geo_select_by_material.cc
Geometry Nodes: Move more nodes to legacy - Curve to Points: Needs output sockets - Curve Endpoitns: Needs the same output sockets - Edge Split: Should have a selection input instead - Subdivision Surface: Should not use "crease" implicitly All new versions of these nodes should also not implicitly realize instances.
2021-09-28 11:03:12 -05:00
geometry/nodes/legacy/node_geo_subdivision_surface.cc
Geometry Nodes: Handle multiple grids in the volume to mesh node In future use cases, a volume can contain many grids that represent the density information. In this case, it's better if the volume to mesh node creates a mesh based on all of the grids in the volume. This is also a benefit to share-ability, since one doesn't have to specify the grid name in the node. Instead, in the future we can have a way to split particular grids into separate volumes, if only one grid should be considered. The code changes are relatively simple: - Move the old volume to mesh node to the legacy folder. - Run the volume to mesh node on all instance geometry, like elsewhere. - Make the blenkernel's volume to mesh API a bit more specific. Differential Revision: https://developer.blender.org/D12997
2021-10-26 11:25:44 -05:00
geometry/nodes/legacy/node_geo_volume_to_mesh.cc
Geometry Nodes: fields and anonymous attributes This implements the initial core framework for fields and anonymous attributes (also see T91274). The new functionality is hidden behind the "Geometry Nodes Fields" feature flag. When enabled in the user preferences, the following new nodes become available: `Position`, `Index`, `Normal`, `Set Position` and `Attribute Capture`. Socket inspection has not been updated to work with fields yet. Besides these changes at the user level, this patch contains the ground work for: * building and evaluating fields at run-time (`FN_fields.hh`) and * creating and accessing anonymous attributes on geometry (`BKE_anonymous_attribute.h`). For evaluating fields we use a new so called multi-function procedure (`FN_multi_function_procedure.hh`). It allows composing multi-functions in arbitrary ways and supports efficient evaluation as is required by fields. See `FN_multi_function_procedure.hh` for more details on how this evaluation mechanism can be used. A new `AttributeIDRef` has been added which allows handling named and anonymous attributes in the same way in many places. Hans and I worked on this patch together. Differential Revision: https://developer.blender.org/D12414
2021-09-09 12:54:20 +02:00
geometry/nodes/node_geo_attribute_capture.cc
CMake: add headers to source lists, sort file-lists
2021-03-26 12:23:21 +11:00
geometry/nodes/node_geo_attribute_remove.cc
Geometry Nodes: Attribute Statistic Node This nodes evaluates a field on a geometry and outputs various statistics about the entire data set, like min, max, or even the standard deviation. It works for float and vector types currently, though more types could be supported in the future. - All statistics are calculated element-wise for vectors. - "Product" was not added since the result could very easily overflow. - The "Size" output was not added since it isn't specific to an attribute and would fit better in another node. The implementation shares work as much as possible when multiple statistics are needed. This node has been in development since the beginning of this year, with additions from Johnny Matthews and Hans Goudey. Differential Revision: https://developer.blender.org/D10202
2021-09-20 18:39:39 -05:00
geometry/nodes/node_geo_attribute_statistic.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/nodes/node_geo_boolean.cc
Geometry Nodes: Bounding Box Node This commit adds a simple node to output the min and max of an axis-aligned bounding box for the input geometry, as well a rectangular prism mesh created from these values for convenience. The initial use case for this node is a "bounding box boolean", where doing the boolean with just a bounding box could be signigicantly faster, for cases like cutting a hole in a wall for a window. But it's easy to imagine other cases where it could be useful. This node supports mesh and point cloud data right now, volume support will come as a separate patch. Also note that there is plenty of room to improve the performance of this node through parallelization. Differential Revision: https://developer.blender.org/D10420
2021-04-06 16:02:55 -05:00
geometry/nodes/node_geo_bounding_box.cc
Geometry Nodes: Add Collection Info Node Implements a node to get collection objects. These objects are then passed along as instances in the node tree. Follow up tasks: Multiple nodes does not support instancing yet: T85159 Changing collection offset does not trigger a refresh: T85274 Reviewed By: Jacques, Dalai, Hans Differential Revision: http://developer.blender.org/D10151
2021-02-03 17:47:46 +01:00
geometry/nodes/node_geo_collection_info.cc
Cleanup: sort cmake file lists
2020-12-11 15:00:22 +11:00
geometry/nodes/node_geo_common.cc
Geometry Nodes: Add Convex Hull Node This commit adds a node to output the convex hull of any input geometry as a mesh, which is an enclosing geometry around a set of points. All geometry types are supported, besides volumes. The code supports operating on instances to avoid copying all input geometry before the operation. The implementation uses the same backend as the operation in edit mode, but uses Mesh directly instead of BMesh. Attribute transfer is not supported currently, but would be a point of improvement for the future if it can work in a predictable way on different geometry input types. Differential Revision: https://developer.blender.org/D10925
2021-06-09 11:58:08 -05:00
geometry/nodes/node_geo_convex_hull.cc
Geometry Nodes: Endpoint Selection Nodes The Endpoint Selection node allows for the Selection of an aribitrary number of endpoints from each spline in a curve. The start and end inputs are evaluated on the spline domain. The result is outputted as a boolean field on the point domain. Differential Revision: https://developer.blender.org/D12846
2021-10-18 06:45:16 -05:00
geometry/nodes/node_geo_curve_endpoint_selection.cc
Geometry Nodes: Curve Fill Node This node takes a curve geometry input and creates a filled mesh at Z=0 using a constrained Delaunay triangulation algorithm. Because of the choice of algorithm, the results should be higher quality than the filling for 2D curve objects. This commit adds an initial fairly simple version of the node, but more features may be added in the future, like transferring attributes when necessary, or an index attribute input to break up the calculations into smaller chunks to improve performance. Differential Revision: https://developer.blender.org/D11846
2021-08-29 23:27:35 -05:00
geometry/nodes/node_geo_curve_fill.cc
Cleanup: Sort node types alphabetically
2021-09-28 14:20:29 -05:00
geometry/nodes/node_geo_curve_fillet.cc
Geometry Nodes: Handle Type Selection Node Update This node creates a boolean field selection of bezier spline points that have a handle of the given type on the selected 'side' of the contol point. This is evaluated on the point domain. Differential Revision: https://developer.blender.org/D12559
2021-10-03 15:00:28 -05:00
geometry/nodes/node_geo_curve_handle_type_selection.cc
Geometry Nodes: refactor logging during geometry nodes evaluation Many ui features for geometry nodes need access to information generated during evaluation: * Node warnings. * Attribute search. * Viewer node. * Socket inspection (not in master yet). The way we logged the required information before had some disadvantages: * Viewer node used a completely separate system from node warnings and attribute search. * Most of the context of logged information is lost when e.g. the same node group is used multiple times. * A global lock was needed every time something is logged. This new implementation solves these problems: * All four mentioned ui features use the same underlying logging system. * All context information for logged values is kept intact. * Every thread has its own local logger. The logged informatiton is combined in the end. Differential Revision: https://developer.blender.org/D11785
2021-07-07 11:20:19 +02:00
geometry/nodes/node_geo_curve_length.cc
Geometry Nodes: Curve Parameter Node This commit adds a field input node that outputs the fraction of the total length of the spline on each control point. This is useful for anything that involves varying a value depending on how far along the spline it is. It also works when evaluated on the spline domain, where it outputs the fraction of the total length of all of the splines at the start. The operation isn't as well defined for NURB splines for the reasons noted in the code comment. That can be said explicitly in the docs. Differential Revision: https://developer.blender.org/D12548
2021-09-21 17:37:16 -05:00
geometry/nodes/node_geo_curve_parameter.cc
Geometry Nodes: Curve Primitive Bezier Segment Creates a Curve with 1 Bezier Spline from four positions (start, start handle, end handle, end) and a resolution. The handles are aligned and mirrored automatically. An "Offset" mode is also included to allow specifying the handles relative to the control points. The default settings recreate the existing default Bezier Curve in the 3D viewport add menu. Differential Revision: https://developer.blender.org/D11648
2021-06-30 00:03:55 -05:00
geometry/nodes/node_geo_curve_primitive_bezier_segment.cc
Geometry Nodes: Curve Primitive Circle This node has two modes: the first mode computes a circle from three locations and a resolution. The second takes radius and resolution. The first mode also outputs the center of the computed circle as a vector. Differential Revision: https://developer.blender.org/D11650
2021-06-30 19:17:28 -05:00
geometry/nodes/node_geo_curve_primitive_circle.cc
Geometry Nodes: Curve Primitive Line This node creates a poly spline line in one of 2 modes: - Line between two points - Start Point, Direction, and Length Both modes create splines with only start and endpoints. A resample node can be used afterward to increase the point count. Differential Revision: https://developer.blender.org/D11769
2021-07-05 12:27:12 -05:00
geometry/nodes/node_geo_curve_primitive_line.cc
Geometry Nodes: Curve Primitive Quadratic Bezier Segment This patch is for a node that creates a poly spline from a 3 point quadratic Bezier. Resolution is also specified. Curve primitives design task: T89220 Differential Revision: https://developer.blender.org/D11649
2021-06-29 22:39:08 -05:00
geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc
Geometry Nodes: Curve Primitive Quadrilateral This commit adds a curve primitive node for creating squares, rectangles, trapezoids, kites, and parallelograms. It also includes a mode where the four points are just vector inputs. Differential Revision: https://developer.blender.org/D11665
2021-07-12 13:10:56 -04:00
geometry/nodes/node_geo_curve_primitive_quadrilateral.cc
Geometry Nodes: Curve Primitive Spiral This node creates a curve spline and gives control for the number of rotations, the number of points per rotation, start and end radius, height, and direction. The "Reverse" input produces a visual change, it doesn't just change the order of the control points. Differential Revision: https://developer.blender.org/D11609
2021-06-29 22:20:54 -05:00
geometry/nodes/node_geo_curve_primitive_spiral.cc
Geometry Nodes: Curve Primitive Spiral This patch adds a Curve Primitives menu in Geometry nodes with an initial entry of a star primitive. The node is a basic star pattern node that outputs a poly spline. Options control the inner and outer radius, the number of points, and the twist of the valleys. Differential Revision: https://developer.blender.org/D11653
2021-06-29 22:00:29 -05:00
geometry/nodes/node_geo_curve_primitive_star.cc
Geometry Noes: Curve Resample Node This node generates a naturally parametarized (even length edge) poly spline version of every spline in the input. There are two modes, "Count", and "Length". These are similar to the same options for the line primitive node in end points mode. I implemented this instead of a "Sample Points" node, because for this operation it's trivial to keep the result as a curve, which is nice since it increases flexibility, and because it can make instancing simpler, i.e. using the transforms of each evaluated point rather than requiring the construction of a "rotation" attribute. Differential Revision: https://developer.blender.org/D11173
2021-05-07 15:37:06 -05:00
geometry/nodes/node_geo_curve_resample.cc
Geometry Nodes: Field version of curve reverse node The updated version has a selection input as a field and does not realize instances implicitly. Differential Revision: https://developer.blender.org/D12506
2021-09-28 13:53:20 -05:00
geometry/nodes/node_geo_curve_reverse.cc
Cleanup: Sort node types alphabetically
2021-09-28 14:20:29 -05:00
geometry/nodes/node_geo_curve_sample.cc
Geometry Nodes: Set Handle Type Node Field Update This update of the Set Handle Type node allows for a bool field to be used as the selection of the affected control point handles for bezier splines. If no bezier splines are provided a info message is shown. Differential Revision: https://developer.blender.org/D12526
2021-10-01 14:22:24 -05:00
geometry/nodes/node_geo_curve_set_handles.cc
Geometry Nodes: Set Spline Type Node Field Update This update of the Set Spline Type node allows for a bool field to be used as the selection of the affected splines. Differential Revision: https://developer.blender.org/D12522
2021-10-01 11:59:29 -05:00
geometry/nodes/node_geo_curve_spline_type.cc
Geometry Nodes: Curve Subdivide Node with Fields The curve subdivide node can now take an int field to specify the number of subdivisions to make at each curve segment. Reviewed by: Hans Goudey Differential Revision: https://developer.blender.org/D12534
2021-10-01 09:40:57 -05:00
geometry/nodes/node_geo_curve_subdivide.cc
Cleanup: Sort nodes alphabetically
2021-07-06 23:33:02 -05:00
geometry/nodes/node_geo_curve_to_mesh.cc
Geometry Nodes: Fields version of Curve to Points node This commit adds an updated version of the curve to points that supports fields. Only the position and radius are transferred by default now, which should improve performance. The other outputs like tangent and rotation are outputted with anonymous attributes. I took the opportunity to change a few other small things: - Name geometry sockets "Curve" and "Points" like other nodes. - Remove the radius multiple of 0.1, which was confusing. Thanks to @Johnny Matthews (guitargeek) for an initial patch. Differential Revision: https://developer.blender.org/D12887
2021-10-20 10:25:49 -05:00
geometry/nodes/node_geo_curve_to_points.cc
Geometry Nodes: Curve Trim Node This node implements shortening each spline in the curve based on either a length from the start of each spline, or a factor of the total length of each spline, similar to the "Start & End Mapping" panel of curve properties. For Bezier curves, the first and last control points are adjusted to maintain the shape of the curve, but NURB splines are currently implicitly converted to poly splines. The node is implemented to avoid copying where possible, so it outputs a changed version of the input curve rather than a new one. Differential Revision: https://developer.blender.org/D11901
2021-07-18 14:05:57 -04:00
geometry/nodes/node_geo_curve_trim.cc
Geometry Nodes: Separate and Delete Geometry for fields Delete Geometry: This adds a copy of the old node in the legacy folder and updates the node to work with fields. The invert option is removed, because it is something that should be very easy with fields, and to be consistent with other nodes which have a selection. There is also a dropdown to select the domain, because the domain can't be determined from the field input. When the domain does not belong on any of the components an info message is displayed. Separate Geometry: A more general version of the old Point Separate node. The "inverted" output is the same as using the delete geometry node. Differential Revision: https://developer.blender.org/D12574
2021-10-11 08:38:02 -05:00
geometry/nodes/node_geo_delete_geometry.cc
Geometry Nodes: new Distribute Points on Faces node This adds a replacement for the deprecated Point Distribute node. Arguments for the name change can be found in T91155. Descriptions of the sockets are available in D12536. Thanks to Jarrett Johnson for the initial patch! Differential Revision: https://developer.blender.org/D12536
2021-09-24 11:50:02 +02:00
geometry/nodes/node_geo_distribute_points_on_faces.cc
Geometry Nodes: Fields version of edge split node This changes the edge split node to have a selection input, which is more aligned with the other design changes. This loses the ability to split edges based on an angle, but the edge angle can be added as a field input node in the future, which will make for a much more flexible system. Differential Revision: https://developer.blender.org/D12829
2021-10-13 11:34:29 -05:00
geometry/nodes/node_geo_edge_split.cc
Geometry Nodes: new Image Texture node This adds a new image texture node for geometry nodes. It does not reuse the same node that is used in shading, because we want to be able to expose the image and frame as sockets. There is a known update issue when a movie or image sequence is used. That will be fixed separately (also see D12957). Currently, the image socket is just a pointer to an Image ID data block. This can contain single images but also movies and image sequences. In the future, the definition of an image socket can be expanded to include images that are generated from scratch in the node tree. For more details read the discussion in D12827. Some of the code is a direct port from cycles and should be cleaned up a bit in the future. For example `image_cubic_texture_lookup`. For still images, the frame input is ignored. Otherwise, the frame has to be in a valid range for the node to work. In the future we may add e.g. automatic looping functionality. Differential Revision: https://developer.blender.org/D12827
2021-10-25 13:02:43 +02:00
geometry/nodes/node_geo_image_texture.cc
Geometry Nodes: Add Nodes to Get/Set Built-in Attributes This commit implements T91780, adding nodes to get and set builtin attributes. Individual set nodes are used so that the values can be exposed for direct editing, which is useful for attributes like shade smooth and spline resolution. Individual input nodes are used to allow reusing nodes for multiple components, and to allow grouping multiple outputs conceptually in the same node in the future. Input Nodes - Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic 'Set' Nodes - Curve Radius - Point Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic Using hardcoded categories is necessary to add separators to the node menu. Differential Revision: https://developer.blender.org/D12687
2021-10-11 11:03:57 -05:00
geometry/nodes/node_geo_input_curve_handles.cc
Cleanup: trailing space, use single quotes for enums
2021-10-20 09:13:38 +11:00
geometry/nodes/node_geo_input_curve_tilt.cc
Cleanup: Sort node types alphabetically
2021-09-28 14:20:29 -05:00
geometry/nodes/node_geo_input_index.cc
Geometry Nodes: new Material input node This node is similar to the Value and Vector node. It just provides a way to use the same material in multiple nodes without exposing it outside of a node group. Differential Revision: https://developer.blender.org/D11305
2021-05-20 12:29:06 +02:00
geometry/nodes/node_geo_input_material.cc
Geometry Nodes: Material Index, Set Material Add Get/Set Nodes for Material Index Rename Assign Material to Set Material Differential Revision: https://developer.blender.org/D12837
2021-10-13 08:39:54 -05:00
geometry/nodes/node_geo_input_material_index.cc
Geometry Nodes: fields and anonymous attributes This implements the initial core framework for fields and anonymous attributes (also see T91274). The new functionality is hidden behind the "Geometry Nodes Fields" feature flag. When enabled in the user preferences, the following new nodes become available: `Position`, `Index`, `Normal`, `Set Position` and `Attribute Capture`. Socket inspection has not been updated to work with fields yet. Besides these changes at the user level, this patch contains the ground work for: * building and evaluating fields at run-time (`FN_fields.hh`) and * creating and accessing anonymous attributes on geometry (`BKE_anonymous_attribute.h`). For evaluating fields we use a new so called multi-function procedure (`FN_multi_function_procedure.hh`). It allows composing multi-functions in arbitrary ways and supports efficient evaluation as is required by fields. See `FN_multi_function_procedure.hh` for more details on how this evaluation mechanism can be used. A new `AttributeIDRef` has been added which allows handling named and anonymous attributes in the same way in many places. Hans and I worked on this patch together. Differential Revision: https://developer.blender.org/D12414
2021-09-09 12:54:20 +02:00
geometry/nodes/node_geo_input_normal.cc
geometry/nodes/node_geo_input_position.cc
Geometry Nodes: Add Nodes to Get/Set Built-in Attributes This commit implements T91780, adding nodes to get and set builtin attributes. Individual set nodes are used so that the values can be exposed for direct editing, which is useful for attributes like shade smooth and spline resolution. Individual input nodes are used to allow reusing nodes for multiple components, and to allow grouping multiple outputs conceptually in the same node in the future. Input Nodes - Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic 'Set' Nodes - Curve Radius - Point Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic Using hardcoded categories is necessary to add separators to the node menu. Differential Revision: https://developer.blender.org/D12687
2021-10-11 11:03:57 -05:00
geometry/nodes/node_geo_input_radius.cc
geometry/nodes/node_geo_input_shade_smooth.cc
geometry/nodes/node_geo_input_spline_cyclic.cc
Geometry Nodes: Spline Length Input Node The Spline Length Input node provides a field containing the length of the current evaluated spline to the Point and Spline domains. Differential Revision: https://developer.blender.org/D12706
2021-10-01 09:58:49 -05:00
geometry/nodes/node_geo_input_spline_length.cc
Geometry Nodes: Add Nodes to Get/Set Built-in Attributes This commit implements T91780, adding nodes to get and set builtin attributes. Individual set nodes are used so that the values can be exposed for direct editing, which is useful for attributes like shade smooth and spline resolution. Individual input nodes are used to allow reusing nodes for multiple components, and to allow grouping multiple outputs conceptually in the same node in the future. Input Nodes - Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic 'Set' Nodes - Curve Radius - Point Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic Using hardcoded categories is necessary to add separators to the node menu. Differential Revision: https://developer.blender.org/D12687
2021-10-11 11:03:57 -05:00
geometry/nodes/node_geo_input_spline_resolution.cc
Geometry Nodes: Curve tangent node This node outputs the direction vector, or tangent of a curve at every control point. For poly splines this is simply the evaluated tangents, so it all works very simply. For Bezier splines it uses the tangent at the evaluated point corresponding to each control point, and NURBS are interpereted as poly splines built from their control points. Internally the node is called "Input Tangent" to simplify using it for mesh tangents as well in the future like the "Normal" node. Differential Revision: https://developer.blender.org/D12581
2021-09-21 13:11:39 -05:00
geometry/nodes/node_geo_input_tangent.cc
Cleanup: Sort node types alphabetically
2021-09-28 14:20:29 -05:00
geometry/nodes/node_geo_instance_on_points.cc
Geometry Nodes: Add Instances to Points Node This node takes a geometry set with instances as input and outputs points located on the origins of the top level of instances in the geometry set (not nested instances). It also has position and radius inputs to allow overriding the default, and a selection input to only generate points for some instances. The use case for this node is a method to use geometry proximity on instance origins, but in a more generic way that is flexible and useful in other situations. Differential Revision: https://developer.blender.org/D12893
2021-10-23 00:01:59 -05:00
geometry/nodes/node_geo_instances_to_points.cc
Geometry Nodes: new Is Viewport node This node outputs true when geometry nodes is currently evaluated for the viewport and false for final renders. Ref T85277. Differential Revision: https://developer.blender.org/D10302
2021-02-04 16:36:34 +01:00
geometry/nodes/node_geo_is_viewport.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/nodes/node_geo_join_geometry.cc
Geometry Nodes: new Material Replace node This node can change all faces that use a specific material to use a different material. Using this node is significantly more efficient than creating a selection from all faces with a specific material index and then using the Material Assign node. Ref T88055. Differential Revision: https://developer.blender.org/D11325
2021-05-21 09:43:55 +02:00
geometry/nodes/node_geo_material_replace.cc
Geometry Nodes: Add fields version of material nodes This commit moves the old material nodes to a "legacy" folder and adds versions of the nodes that work with fields. The "Select by Material" node is a field node now, so it doesn't have a geometry output. This is an improvement because there are fewer links to connect, and it's more easily usable in different situations. It's also called "Material Selection", since it's more of an input than an action now. It's sometimes necessary to use the attribute capture node to get a more predictable interpolation to mesh faces. This is because the selection field input is always evaluated on the face domain, so attribute inputs are interpolated before they are booleans, so they cannot use the new interpolations from rB5841f8656d9580d7b9. Differential Revision: https://developer.blender.org/D12456
2021-09-15 10:51:52 -05:00
geometry/nodes/node_geo_material_selection.cc
Geometry Nodes: Add initial version of mesh primitives This commit includes nodes to build the following primitives: - Cone - Cylinder - Circle - Cube - UV Sphere - Ico Sphere - Line - Plane/Grid In general the inputs are the same as the corresponding operators in the 3D view. **Line Primitive** The line primitive has two modes-- adding vertices between two end points, or adding vertices each at an offset from the start point. For the former mode, there is a choice between a vertex count and a distance between each point. **Plane Primitive** This commit includes the "Plane" and "Grid" primitives as one node. Generally primitives are named after the simpler form of the shape they create (i.e. "Cone" can make some more complex shapes). Also, generally you want to tweak the number of subdivisions anyway, so defaulting to plane is not an inconvenience. And generally having fewer redundant base primitives is better. **Future Improvements** A following patch proposes to improve the speed of the cylinder, cone, and sphere primitives: D10730. Additional possible future improvements would be adding subdivisions to the cube node and rings to the cone and cylinder nodes. Differential Revision: https://developer.blender.org/D10715
2021-03-16 17:35:12 -04:00
geometry/nodes/node_geo_mesh_primitive_circle.cc
geometry/nodes/node_geo_mesh_primitive_cone.cc
geometry/nodes/node_geo_mesh_primitive_cube.cc
geometry/nodes/node_geo_mesh_primitive_cylinder.cc
Geometry Nodes: Rename "Plane" primitive to "Grid" Although "Grid" may not be techincally correct since a grid could be 3D, it was decided to rename the "Plane" primtive to "Grid". The primitive node allows subdivisions, so the name is more consistent with the operator in the 3D view. Ref T86819 This commit includes a file subversion bump for the versioning.
2021-03-26 13:09:35 -04:00
geometry/nodes/node_geo_mesh_primitive_grid.cc
Geometry Nodes: Add initial version of mesh primitives This commit includes nodes to build the following primitives: - Cone - Cylinder - Circle - Cube - UV Sphere - Ico Sphere - Line - Plane/Grid In general the inputs are the same as the corresponding operators in the 3D view. **Line Primitive** The line primitive has two modes-- adding vertices between two end points, or adding vertices each at an offset from the start point. For the former mode, there is a choice between a vertex count and a distance between each point. **Plane Primitive** This commit includes the "Plane" and "Grid" primitives as one node. Generally primitives are named after the simpler form of the shape they create (i.e. "Cone" can make some more complex shapes). Also, generally you want to tweak the number of subdivisions anyway, so defaulting to plane is not an inconvenience. And generally having fewer redundant base primitives is better. **Future Improvements** A following patch proposes to improve the speed of the cylinder, cone, and sphere primitives: D10730. Additional possible future improvements would be adding subdivisions to the cube node and rings to the cone and cylinder nodes. Differential Revision: https://developer.blender.org/D10715
2021-03-16 17:35:12 -04:00
geometry/nodes/node_geo_mesh_primitive_ico_sphere.cc
geometry/nodes/node_geo_mesh_primitive_line.cc
geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc
Cleanup: Sort nodes alphabetically
2021-07-06 23:33:02 -05:00
geometry/nodes/node_geo_mesh_subdivide.cc
Geometry Nodes: Field version of mesh to curve node This commit adds a fields version of the mesh to curve node, with a field for the input selection. In order to reduce code duplication, it adds the mesh to curve conversion to the new geometry module and calls that implementation from both places. More details on the geometry module can be found here: T86869 Differential Revision: https://developer.blender.org/D12579
2021-10-14 12:06:48 -05:00
geometry/nodes/node_geo_mesh_to_curve.cc
Geometry Nodes: Mesh Point Cloud Conversion Nodes This commit adds nodes to do direct conversion between meshes and point clouds in geometry nodes. The conversion from mesh to points is helpful to instance once per face, or once per edge, which was previously only possibly with ugly work-arounds. Fields can be evaluated on the mesh to pass them to the points with the attribute capture node. The other conversion, point cloud to mesh vertices, is a bit less obvious, though it is still a common request from users. It's helpful for flexibility when passing data around, better visualization in the viewport (and in the future, cycles), and the simplicity of points. This is a step towards T91754, where point clouds are currently combined with meshes when outputing to the next modifier after geometry nodes. Since we're removing the implicit behavior for realizing instances, it feels natural to use an explicit node to convert points to vertices too. Differential Revision: https://developer.blender.org/D12657
2021-09-28 12:14:13 -05:00
geometry/nodes/node_geo_mesh_to_points.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/nodes/node_geo_object_info.cc
Geometry Nodes: Mesh Point Cloud Conversion Nodes This commit adds nodes to do direct conversion between meshes and point clouds in geometry nodes. The conversion from mesh to points is helpful to instance once per face, or once per edge, which was previously only possibly with ugly work-arounds. Fields can be evaluated on the mesh to pass them to the points with the attribute capture node. The other conversion, point cloud to mesh vertices, is a bit less obvious, though it is still a common request from users. It's helpful for flexibility when passing data around, better visualization in the viewport (and in the future, cycles), and the simplicity of points. This is a step towards T91754, where point clouds are currently combined with meshes when outputing to the next modifier after geometry nodes. Since we're removing the implicit behavior for realizing instances, it feels natural to use an explicit node to convert points to vertices too. Differential Revision: https://developer.blender.org/D12657
2021-09-28 12:14:13 -05:00
geometry/nodes/node_geo_points_to_vertices.cc
Geometry Nodes: Points to Volume Fields Update This update of the Points to Volume node allows a field to populate the radius input of the node and removes the implicit realization of instances. Differential Revision: https://developer.blender.org/D12531
2021-10-03 07:54:05 -05:00
geometry/nodes/node_geo_points_to_volume.cc
Geometry Nodes: Fields version of attribute proximity node Add a fields-aware implementation of the attribute proximity node. The Source position is an implicit position field, but can be connected with a position input node with alterations before use. The target input and mode function the same as the original node. Patch by Johnny Matthews with edits from Hans Goudey (@HooglyBoogly). Differential Revision: https://developer.blender.org/D12635
2021-09-28 15:21:36 -05:00
geometry/nodes/node_geo_proximity.cc
Geometry Nodes: Fields version of the raycast node This patch includes an updated version of the raycast node that uses fields instead of attributes for inputs instead of outputs. This makes the node's UI much clearer. It should be faster too, since the evaluation system for fields provides multi-threading. The source position replaces the input geometry (since this node is evaluated in the context of a geometry like the other field nodes). Thanks to @guitargeek for an initial version of this patch. Differential Revision: https://developer.blender.org/D12638
2021-10-19 09:01:39 -05:00
geometry/nodes/node_geo_raycast.cc
Geometry Nodes: new Realize Instances node This node has a simple geometry input and output. If the input geometry contains instances, they will be realized into actual geometry. When there are many instances, this can be very slow and memory intensive. Generally, instances should only be made real when necessary, e.g. when every instance should be deformed independently. Differential Revision: https://developer.blender.org/D12556
2021-09-20 12:37:52 +02:00
geometry/nodes/node_geo_realize_instances.cc
Geometry Nodes: Rotate Instances Node Adds a node that can rotate each of a geometry's instances in global (to the modifier object) or local space (of each point) by a specified angle around a pivot point. In the future, separating the local-global choice for the pivot and the rotation might be useful. However, for now the node is kept simple. Differential Revision: https://developer.blender.org/D12682
2021-10-13 09:42:10 -05:00
geometry/nodes/node_geo_rotate_instances.cc
Geometry Nodes: Scale Instances Node Adds a node that can scale a geometry's instances. With "Local" turned on, the instance is scaled individually from the center point input, while when local space is turned off, it's more like the transform node, except it scales outward from the center point instead of only from the origin. Differential Revision: https://developer.blender.org/D12681
2021-10-13 09:08:02 -05:00
geometry/nodes/node_geo_scale_instances.cc
Geometry Nodes: Separate Components Node Implementation of T86970. This node takes a geometry input with multiple components and outputs them by component type. Meshes, Curves, and Point Clouds support combining multiple input instances, while volumes will only output the first volume component input until suitable instance realization for multiple volumes is finished. When direct geometry instancing is implemented it will be possible to avoid realizing instances in this node. Differential Revision: https://developer.blender.org/D11577
2021-06-15 22:31:57 -05:00
geometry/nodes/node_geo_separate_components.cc
Geometry Nodes: Separate and Delete Geometry for fields Delete Geometry: This adds a copy of the old node in the legacy folder and updates the node to work with fields. The invert option is removed, because it is something that should be very easy with fields, and to be consistent with other nodes which have a selection. There is also a dropdown to select the domain, because the domain can't be determined from the field input. When the domain does not belong on any of the components an info message is displayed. Separate Geometry: A more general version of the old Point Separate node. The "inverted" output is the same as using the delete geometry node. Differential Revision: https://developer.blender.org/D12574
2021-10-11 08:38:02 -05:00
geometry/nodes/node_geo_separate_geometry.cc
Geometry Nodes: Add Nodes to Get/Set Built-in Attributes This commit implements T91780, adding nodes to get and set builtin attributes. Individual set nodes are used so that the values can be exposed for direct editing, which is useful for attributes like shade smooth and spline resolution. Individual input nodes are used to allow reusing nodes for multiple components, and to allow grouping multiple outputs conceptually in the same node in the future. Input Nodes - Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic 'Set' Nodes - Curve Radius - Point Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic Using hardcoded categories is necessary to add separators to the node menu. Differential Revision: https://developer.blender.org/D12687
2021-10-11 11:03:57 -05:00
geometry/nodes/node_geo_set_curve_handles.cc
geometry/nodes/node_geo_set_curve_radius.cc
Cleanup: trailing space, use single quotes for enums
2021-10-20 09:13:38 +11:00
geometry/nodes/node_geo_set_curve_tilt.cc
Geometry Nodes: Material Index, Set Material Add Get/Set Nodes for Material Index Rename Assign Material to Set Material Differential Revision: https://developer.blender.org/D12837
2021-10-13 08:39:54 -05:00
geometry/nodes/node_geo_set_material.cc
geometry/nodes/node_geo_set_material_index.cc
Geometry Nodes: Add Nodes to Get/Set Built-in Attributes This commit implements T91780, adding nodes to get and set builtin attributes. Individual set nodes are used so that the values can be exposed for direct editing, which is useful for attributes like shade smooth and spline resolution. Individual input nodes are used to allow reusing nodes for multiple components, and to allow grouping multiple outputs conceptually in the same node in the future. Input Nodes - Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic 'Set' Nodes - Curve Radius - Point Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic Using hardcoded categories is necessary to add separators to the node menu. Differential Revision: https://developer.blender.org/D12687
2021-10-11 11:03:57 -05:00
geometry/nodes/node_geo_set_point_radius.cc
Geometry Nodes: fields and anonymous attributes This implements the initial core framework for fields and anonymous attributes (also see T91274). The new functionality is hidden behind the "Geometry Nodes Fields" feature flag. When enabled in the user preferences, the following new nodes become available: `Position`, `Index`, `Normal`, `Set Position` and `Attribute Capture`. Socket inspection has not been updated to work with fields yet. Besides these changes at the user level, this patch contains the ground work for: * building and evaluating fields at run-time (`FN_fields.hh`) and * creating and accessing anonymous attributes on geometry (`BKE_anonymous_attribute.h`). For evaluating fields we use a new so called multi-function procedure (`FN_multi_function_procedure.hh`). It allows composing multi-functions in arbitrary ways and supports efficient evaluation as is required by fields. See `FN_multi_function_procedure.hh` for more details on how this evaluation mechanism can be used. A new `AttributeIDRef` has been added which allows handling named and anonymous attributes in the same way in many places. Hans and I worked on this patch together. Differential Revision: https://developer.blender.org/D12414
2021-09-09 12:54:20 +02:00
geometry/nodes/node_geo_set_position.cc
Geometry Nodes: Add Nodes to Get/Set Built-in Attributes This commit implements T91780, adding nodes to get and set builtin attributes. Individual set nodes are used so that the values can be exposed for direct editing, which is useful for attributes like shade smooth and spline resolution. Individual input nodes are used to allow reusing nodes for multiple components, and to allow grouping multiple outputs conceptually in the same node in the future. Input Nodes - Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic 'Set' Nodes - Curve Radius - Point Radius - Curve Tilt - Curve Handle Positions - Is Shade Smooth - Spline Resolution - Is Spline Cyclic Using hardcoded categories is necessary to add separators to the node menu. Differential Revision: https://developer.blender.org/D12687
2021-10-11 11:03:57 -05:00
geometry/nodes/node_geo_set_shade_smooth.cc
geometry/nodes/node_geo_set_spline_cyclic.cc
geometry/nodes/node_geo_set_spline_resolution.cc
Geometry Nodes: String manipulation nodes This patch adds four new nodes to a new "Text" category: - String Length: Outputs length of a string - String Substring: Outputs part of a string - Value to String: Converts a value to a string - String Join: Concatenates multiple strings with a delimiter The initial use case of these nodes is the upcoming string to curve node. However, they could also be used to calculate dynamic attribute names, or with string attributes in the future. Differential Revision: https://developer.blender.org/D12532
2021-09-21 14:11:32 -05:00
geometry/nodes/node_geo_string_join.cc
Geometry Nodes: String to Curves Node This commit adds a node that generates a text paragraph as curve instances. The inputs on the node control the overall shape of the paragraph, and other nodes can be used to move the individual instances afterwards. To output more than one line, the "Special Characters" node can be used. The node outputs instances instead of real geometry so that it doesn't have to duplicate work for every character afterwards. This is much more efficient, because all of the curve evaluation and nodes like fill curve don't have to repeat the same calculation for every instance of the same character. In the future, the instances component will support attributes, and the node can output attribute fields like "Word Index" and "Line Index". Differential Revision: https://developer.blender.org/D11522
2021-09-24 12:41:49 -05:00
geometry/nodes/node_geo_string_to_curves.cc
Cleanup: sort cmake file lists
2021-10-20 09:17:46 +11:00
geometry/nodes/node_geo_subdivision_surface.cc
Geometry Nodes: new Switch node This is a first iteration of a switch node. It can only switch between two inputs values based on a boolean. A more sophisticated switch node that has an integer selector will probably come later. Currently, the geometry nodes evaluator does not support lazy evaluation of individual inputs. Therefore, all inputs will be computed currently. An improvement to the evaluator will be worked on separately. Ref: T85374 Differential Revision: https://developer.blender.org/D10460
2021-04-19 10:38:50 +02:00
geometry/nodes/node_geo_switch.cc
Geometry Nodes: Fields transfer attribute node This commit adds an updated version of the old attribute transfer node. It works like a function node, so it works in the context of a geometry, with a simple data output. The "Nearest" mode finds the nearest element of the specified domain on the target geometry and copies the value directly from the target input. The "Nearest Face Interpolated" finds the nearest point on anywhere on the surface of the target mesh and linearly interpolates the value on the target from the face's corners. The node also has a new "Index" mode, which can pick data from specific indices on the target geometry. The implicit default is to do a simple copy from the target geometry, but any indices could be used. It is also possible to use a single value for the index to to retrieve a single value from an attribute at a certain index. Differential Revision: https://developer.blender.org/D12785
2021-10-15 14:08:52 -05:00
geometry/nodes/node_geo_transfer_attribute.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/nodes/node_geo_transform.cc
Geometry Nodes: Translate Instances Node Adds a node that can translate instances in the transform space of the modifier object, or the local space of their original transform. One reason to have a special node for instances is that they always have the existing transform, unlike mesh or point cloud points. Differential Revision: https://developer.blender.org/D12679
2021-10-13 09:02:05 -05:00
geometry/nodes/node_geo_translate_instances.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/nodes/node_geo_triangulate.cc
Geometry Nodes: new Viewer node This adds a viewer node similar to the one in the compositor. The icon in the headers of nodes is removed because it served the same purpose and is not necessary anymore. Node outputs can be connected to the active viewer using ctrl+shift+LMB, just like in the compositor. Right now this collides with the shortcut used in the node wrangler addon, which will be changed separately. As of now, the viewed geometry is only visible in the spreadsheet. Viewport visualization will be added separately. There are a couple of benefits of using a viewer node compared to the old approach with the icon in the node header: * Better support for nodes that have more than one geometry output. * It's more consistent with the compositor. * If attributes become decoupled from geometry in the future, the viewer can have a separate input for the attribute to visualize. * The viewer node could potentially have visualization settings. * Allows to keep "visualization points" around by having multiple viewer nodes. * Less visual clutter in node headers. Differential Revision: https://developer.blender.org/D11470
2021-07-05 10:46:00 +02:00
geometry/nodes/node_geo_viewer.cc
Geometry Nodes: add Volume to Mesh node This node takes a volume and generates a mesh on it's "surface". The surface is defined by a threshold value. Currently, the node only works on volumes generated by the Points to Volume node. This limitation will be resolved soonish. Ref T84605. Differential Revision: https://developer.blender.org/D10243
2021-02-05 16:20:14 +01:00
geometry/nodes/node_geo_volume_to_mesh.cc
Cleanup: Sort node types alphabetically
2021-09-28 14:20:29 -05:00
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/node_geometry_exec.cc
geometry/node_geometry_tree.cc
geometry/node_geometry_util.cc
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_add_shader.c
shader/nodes/node_shader_ambient_occlusion.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_attribute.c
shader/nodes/node_shader_background.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_bevel.c
shader/nodes/node_shader_blackbody.c
shader/nodes/node_shader_brightness.c
Cycles: Anisotropic BSDF enabled, with tangents now computed from the active UV map. It's using the Ward BSDF currently, which has some energy loss so might be a bit dark. More/better BSDF options can be implemented later. Patch by Mike Farnsworth, some modifications by me. Currently it's not possible yet to set a custom tangent, that will follow as part of per-bsdf normals patch.
2012-10-10 13:02:20 +00:00
shader/nodes/node_shader_bsdf_anisotropic.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_bsdf_diffuse.c
shader/nodes/node_shader_bsdf_glass.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_bsdf_glossy.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_bsdf_hair.c
shader/nodes/node_shader_bsdf_hair_principled.c
shader/nodes/node_shader_bsdf_principled.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_bsdf_refraction.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_bsdf_toon.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_bsdf_translucent.c
shader/nodes/node_shader_bsdf_transparent.c
shader/nodes/node_shader_bsdf_velvet.c
Cycles: per-BSDF normal input and new Bump node. Each BSDF node now has a Normal input, which can be used to set a custom normal for the BSDF, for example if you want to have only bump on one of the layers in a multilayer material. The Bump node can be used to generate a normal from a scalar value, the same as what happens when you connect a scalar value to the displacement output. Documentation has been updated with the latest changes: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes Patch by Agustin Benavidez, some implementation tweaks by me.
2012-10-10 15:56:43 +00:00
shader/nodes/node_shader_bump.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_camera.c
Particles: support Clamp node
2020-07-27 17:12:01 +02:00
shader/nodes/node_shader_clamp.cc
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_common.c
Nodes: move shader curves node to C++ Prepare node for conversion to Geometry Nodes. There should be no functional changes. Reviewed By: JacquesLucke, LazyDodo Differential Revision: https://developer.blender.org/D11226
2021-05-24 12:02:45 +01:00
shader/nodes/node_shader_curves.cc
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_displacement.c
shader/nodes/node_shader_eevee_specular.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_emission.c
shader/nodes/node_shader_fresnel.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_gamma.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_geometry.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_hair_info.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_holdout.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_hueSatVal.c
Cycles: Add Support for IES files as textures for light strength This patch adds support for IES files, a file format that is commonly used to store the directional intensity distribution of light sources. The new IES node is supposed to be plugged into the Strength input of the Emission node of the lamp. Since people generating IES files do not really seem to care about the standard, the parser is flexible enough to accept all test files I have tried. Some common weirdnesses are distributing values over multiple lines that should go into one line, using commas instead of spaces as delimiters and adding various useless stuff at the end of the file. The user interface of the node is similar to the script node, the user can either select an internal Text or load a file. Internally, IES files are handled similar to Image textures: They are stored in slots by the LightManager and each unique IES is assigned to one slot. The local coordinate system of the lamp is used, so that the direction of the light can be changed. For UI reasons, it's usually best to add an area light, rotate it and then change its type, since especially the point light does not immediately show its local coordinate system in the viewport. Reviewers: #cycles, dingto, sergey, brecht Reviewed By: #cycles, dingto, brecht Subscribers: OgDEV, crazyrobinhood, secundar, cardboard, pisuke, intrah, swerner, micah_denn, harvester, gottfried, disnel, campbellbarton, duarteframos, Lapineige, brecht, juicyfruit, dingto, marek, rickyblender, bliblubli, lockal, sergey Differential Revision: https://developer.blender.org/D1543
2018-05-27 00:46:37 +02:00
shader/nodes/node_shader_ies_light.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_invert.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_layer_weight.c
Cycles: add light falloff node, with quadratic/linear/constant falloff and a smoothing factor to reduce high values near the light. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Light_Falloff Note that this was already possible to do manually with the Ray Length, but this adds a convenient node for it. This commit also makes the mapping node min/max option work, fixing #31348.
2012-05-07 20:24:38 +00:00
shader/nodes/node_shader_light_falloff.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_light_path.c
Particles: support Map Range node Only linear interpolation mode is supported for now.
2020-07-16 13:25:57 +02:00
shader/nodes/node_shader_map_range.cc
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_mapping.c
Nodes: move Math, Vector Math and Value shader nodes to c++ files This required a little bit of refactoring, because we were using c-only syntax for the gpu shader names. All tests are still passing.
2020-07-11 16:24:53 +02:00
shader/nodes/node_shader_math.cc
Nodes: move mix rgb node to C++ Prepare node for conversion to Geometry Nodes. There should be no functional changes. Reviewed By: HooglyBoogly Differential Revision: https://developer.blender.org/D11506
2021-06-11 00:01:10 +01:00
shader/nodes/node_shader_mixRgb.cc
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_mix_shader.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_normal.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_normal_map.c
shader/nodes/node_shader_object_info.c
Cleanup: sort file lists
2019-12-17 10:07:44 +11:00
shader/nodes/node_shader_output_aov.c
Cleanup: file rename lamp -> light
2019-02-27 12:34:56 +11:00
shader/nodes/node_shader_output_light.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_output_linestyle.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_output_material.c
shader/nodes/node_shader_output_world.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_particle_info.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_rgb.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_script.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_sepcombHSV.c
Particles: support Separate/Combine RGB nodes
2020-07-16 16:08:18 +02:00
shader/nodes/node_shader_sepcombRGB.cc
Nodes: Generate multi-function network from node tree This adds new callbacks to `bNodeSocketType` and `bNodeType`. Those are used to generate a multi-function network from a node tree. Later, this network is evaluated on e.g. particle data. Reviewers: brecht Differential Revision: https://developer.blender.org/D8169
2020-07-07 18:23:33 +02:00
shader/nodes/node_shader_sepcombXYZ.cc
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_shaderToRgb.c
shader/nodes/node_shader_squeeze.c
Cycles: initial subsurface multiple scattering support. It's not working as well as I would like, but it works, just add a subsurface scattering node and you can use it like any other BSDF. It is using fully raytraced sampling compatible with progressive rendering and other more advanced rendering algorithms we might used in the future, and it uses no extra memory so it's suitable for complex scenes. Disadvantage is that it can be quite noisy and slow. Two limitations that will be solved are that it does not work with bump mapping yet, and that the falloff function used is a simple cubic function, it's not using the real BSSRDF falloff function yet. The node has a color input, along with a scattering radius for each RGB color channel along with an overall scale factor for the radii. There is also no GPU support yet, will test if I can get that working later. Node Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#BSSRDF Implementation notes: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/Cycles/Subsurface_Scattering
2013-04-01 20:26:52 +00:00
shader/nodes/node_shader_subsurface_scattering.c
Cycles: 4 new nodes. * Tangent: generate a tangent direction for anisotropic shading. Can be either radial around X/Y/Z axis, or from a UV map. The default tangent for the anisotropic BSDF and geometry node is now always radial Z, for UV tangent use this node now. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Tangent * Normal Map: generate a perturbed normal from an RGB normal map image. This is usually chained with an Image Texture node in the color input, to specify the normal map image. For tangent space normal maps, the UV coordinates for the image must match, and the image texture should be set to Non-Color mode to give correct results. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Normal_Map * Refraction BSDF: for best results this node should be considered as a building block and not be used on its own, but rather mixed with a glossy node using a fresnel type factor. Otherwise it will give quite dark results at the edges for glossy refraction. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Refraction * Ambient Occlusion: controls the amount of AO a surface receives, rather than having just a global factor in the world. Note that this outputs a shader and not a color, that's for another time. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Shaders#Ambient_Occlusion
2012-11-06 19:59:02 +00:00
shader/nodes/node_shader_tangent.c
Nodes: Move texture nodes to C++ Move texture nodes to C++ and use new socket declaration Brick, Checker, Image, Magic and Wave Differential Revision: https://developer.blender.org/D12778
2021-10-07 15:04:20 +01:00
shader/nodes/node_shader_tex_brick.cc
shader/nodes/node_shader_tex_checker.cc
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_tex_coord.c
shader/nodes/node_shader_tex_environment.c
Nodes: move some texture nodes to c++ This is necessary to be able to use them in geometry nodes.
2021-09-13 11:54:05 +02:00
shader/nodes/node_shader_tex_gradient.cc
Nodes: Move texture nodes to C++ Move texture nodes to C++ and use new socket declaration Brick, Checker, Image, Magic and Wave Differential Revision: https://developer.blender.org/D12778
2021-10-07 15:04:20 +01:00
shader/nodes/node_shader_tex_image.cc
shader/nodes/node_shader_tex_magic.cc
Nodes: move some texture nodes to c++ This is necessary to be able to use them in geometry nodes.
2021-09-13 11:54:05 +02:00
shader/nodes/node_shader_tex_musgrave.cc
shader/nodes/node_shader_tex_noise.cc
Cycles: Point density texture support This commit implements point density texture for Cycles shading nodes. It's done via creating voxel texture at shader compilation time, Not totally memory efficient, but avoids adding sampling code to kernel (which keeps render time as low as possible), In the future this will be compensated by using OpenVDB for more efficient storage of sparse volume data. Sampling of the voxel texture is happening at blender side and the same code is used as for Blender Internal's renderer. This texture is controlled by only object, particle system and radius. Linear falloff is used and there's no turbulence. This is because falloff is expected to happen using Curve Mapping node. Turbulence will be done as a distortion on the input coordinate. It's already possible to fake it using nose textures and in the future we can add more proper turbulence distortion node, which then could also be used for 2D texture mapping. Particle color support is done by Lukas, thanks!
2015-07-18 22:36:09 +02:00
shader/nodes/node_shader_tex_pointdensity.c
Nodes: add cycles shader nodes, these will only be available to render engines that use the new shading nodes system. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes
2011-11-08 11:38:16 +00:00
shader/nodes/node_shader_tex_sky.c
Nodes: move some texture nodes to c++ This is necessary to be able to use them in geometry nodes.
2021-09-13 11:54:05 +02:00
shader/nodes/node_shader_tex_voronoi.cc
Nodes: Move texture nodes to C++ Move texture nodes to C++ and use new socket declaration Brick, Checker, Image, Magic and Wave Differential Revision: https://developer.blender.org/D12778
2021-10-07 15:04:20 +01:00
shader/nodes/node_shader_tex_wave.cc
Nodes: move some texture nodes to c++ This is necessary to be able to use them in geometry nodes.
2021-09-13 11:54:05 +02:00
shader/nodes/node_shader_tex_white_noise.cc
Freestyle: Added new UV Along Stroke shader node.
2014-07-20 12:14:31 +09:00
shader/nodes/node_shader_uvAlongStroke.c
Cycles: add dedicated UV Map node, easier to find and has convenient auto complete. Fixes T37954. Reviewed By: brecht, dingto Differential Revision: https://developer.blender.org/D230
2014-04-02 11:40:29 +02:00
shader/nodes/node_shader_uvmap.c
Particles: support Color Ramp node
2020-07-16 15:49:56 +02:00
shader/nodes/node_shader_valToRgb.cc
Nodes: move Math, Vector Math and Value shader nodes to c++ files This required a little bit of refactoring, because we were using c-only syntax for the gpu shader names. All tests are still passing.
2020-07-11 16:24:53 +02:00
shader/nodes/node_shader_value.cc
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_vectTransform.c
shader/nodes/node_shader_vector_displacement.c
Nodes: move Math, Vector Math and Value shader nodes to c++ files This required a little bit of refactoring, because we were using c-only syntax for the gpu shader names. All tests are still passing.
2020-07-11 16:24:53 +02:00
shader/nodes/node_shader_vector_math.cc
Nodes: move vector rotate node to C++ This makes it easier to add an implementation that can be used in Geometry Nodes. There should be no functional changes.
2021-03-05 16:09:19 +01:00
shader/nodes/node_shader_vector_rotate.cc
Cleanup: structs, cmake file lists
2019-09-27 12:45:54 +10:00
shader/nodes/node_shader_vertex_color.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_volume_absorption.c
Shading: Add Volume Info node. The Volume Info node provides the Color, Desnity, Flame, and Temperature of smoke domains. Reviewers: brecht Differential Revision: https://developer.blender.org/D5551
2019-08-21 20:22:24 +02:00
shader/nodes/node_shader_volume_info.c
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
shader/nodes/node_shader_volume_principled.c
shader/nodes/node_shader_volume_scatter.c
shader/nodes/node_shader_wavelength.c
shader/nodes/node_shader_wireframe.c
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
shader/node_shader_tree.c
shader/node_shader_util.c
texture/nodes/node_texture_at.c
texture/nodes/node_texture_bricks.c
texture/nodes/node_texture_checker.c
texture/nodes/node_texture_common.c
texture/nodes/node_texture_compose.c
texture/nodes/node_texture_coord.c
texture/nodes/node_texture_curves.c
texture/nodes/node_texture_decompose.c
texture/nodes/node_texture_distance.c
texture/nodes/node_texture_hueSatVal.c
texture/nodes/node_texture_image.c
texture/nodes/node_texture_invert.c
texture/nodes/node_texture_math.c
texture/nodes/node_texture_mixRgb.c
texture/nodes/node_texture_output.c
texture/nodes/node_texture_proc.c
texture/nodes/node_texture_rotate.c
texture/nodes/node_texture_scale.c
texture/nodes/node_texture_texture.c
texture/nodes/node_texture_translate.c
texture/nodes/node_texture_valToNor.c
texture/nodes/node_texture_valToRgb.c
texture/nodes/node_texture_viewer.c
texture/node_texture_tree.c
texture/node_texture_util.c
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
intern/derived_node_tree.cc
Nodes: use extern templates for socket declarations The new socket declaration api generates a surprising amount of symbols in each translation unit where it is used. This resulted in a measurable compile time increase. This commit reduces the number of symbols that are generated in each translation unit significantly. For example, in `node_geo_distribute_points_on_faces.cc` the number of symbols decreased from 1930 to 1335. In my tests, this results in a 5-20% compile time speedup when this and similar files are compiled in isolation (measured by executing the command in `compile_commands.json`). Compiling the distribute points on faces node sped up from ~2.65s to ~2.4s.
2021-10-03 16:05:19 +02:00
intern/extern_implementations.cc
Geometry Nodes: refactor logging during geometry nodes evaluation Many ui features for geometry nodes need access to information generated during evaluation: * Node warnings. * Attribute search. * Viewer node. * Socket inspection (not in master yet). The way we logged the required information before had some disadvantages: * Viewer node used a completely separate system from node warnings and attribute search. * Most of the context of logged information is lost when e.g. the same node group is used multiple times. * A global lock was needed every time something is logged. This new implementation solves these problems: * All four mentioned ui features use the same underlying logging system. * All context information for logged values is kept intact. * Every thread has its own local logger. The logged informatiton is combined in the end. Differential Revision: https://developer.blender.org/D11785
2021-07-07 11:20:19 +02:00
intern/geometry_nodes_eval_log.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
intern/math_functions.cc
Cleanup: move node_common.c to c++ Buildbot compiled without problems.
2021-09-30 15:44:08 +02:00
intern/node_common.cc
Cleanup: sort cmake file lists
2021-09-29 07:29:19 +10:00
intern/node_declaration.cc
Cleanup: move node_exec.c to c++ Doing this, because it might make it easier to replace the implementation of `bNodeInstanceHash`.
2021-04-01 15:14:53 +02:00
intern/node_exec.cc
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
intern/node_geometry_exec.cc
Functions: remove multi-function network The multi-function network system was able to compose multiple multi-functions into a new one and to evaluate that efficiently. This functionality was heavily used by the particle nodes prototype a year ago. However, since then we only used multi-functions without the need to compose them in geometry nodes. The upcoming "fields" in geometry nodes will need a way to compose multi-functions again. Unfortunately, the code removed in this commit was not ideal for this different kind of function composition. I've been working on an alternative that will be added separately when it becomes needed. I've had to update all the function nodes, because their interface depended on the multi-function network data structure a bit. The actual multi-function implementations are still the same though.
2021-08-20 13:14:39 +02:00
intern/node_multi_function.cc
Nodes: rename node_socket.c to node_socket.cc I have to add some C++ code in callbacks for socket types for the new particle system.
2020-06-29 17:36:06 +02:00
intern/node_socket.cc
Cleanup: sort cmake file lists
2021-09-29 07:29:19 +10:00
intern/node_socket_declarations.cc
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
intern/node_tree_ref.cc
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
intern/node_util.c
Cleanup: move type conversions to separate file
2021-04-15 09:35:56 +02:00
intern/type_conversions.cc
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
Cleanup: convert compositor nodes to c++ - Many cleanups of to use list base - Some variable changes These change is needed to migrate to the new socket builder API Reviewed By: manzanilla Differential Revision: https://developer.blender.org/D12366
2021-09-28 15:29:16 -04:00
composite/node_composite_util.hh
Nodes: Generate multi-function network from node tree This adds new callbacks to `bNodeSocketType` and `bNodeType`. Those are used to generate a multi-function network from a node tree. Later, this network is evaluated on e.g. particle data. Reviewers: brecht Differential Revision: https://developer.blender.org/D8169
2020-07-07 18:23:33 +02:00
function/node_function_util.hh
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
shader/node_shader_util.h
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
geometry/node_geometry_util.hh
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
texture/node_texture_util.h
include headers in cmake source, added a script to check for consistency, reporting missing headers & C files. this is important so IDE's using CMake integration always get blender headers. - QtCreator & MSVC for eg, probably others too.
2010-11-29 04:35:56 +00:00
Merge of the PyNodes branch (aka "custom nodes") into trunk. PyNodes opens up the node system in Blender to scripters and adds a number of UI-level improvements. === Dynamic node type registration === Node types can now be added at runtime, using the RNA registration mechanism from python. This enables addons such as render engines to create a complete user interface with nodes. Examples of how such nodes can be defined can be found in my personal wiki docs atm [1] and as a script template in release/scripts/templates_py/custom_nodes.py [2]. === Node group improvements === Each node editor now has a tree history of edited node groups, which allows opening and editing nested node groups. The node editor also supports pinning now, so that different spaces can be used to edit different node groups simultaneously. For more ramblings and rationale see (really old) blog post on code.blender.org [3]. The interface of node groups has been overhauled. Sockets of a node group are no longer displayed in columns on either side, but instead special input/output nodes are used to mirror group sockets inside a node tree. This solves the problem of long node lines in groups and allows more adaptable node layout. Internal sockets can be exposed from a group by either connecting to the extension sockets in input/output nodes (shown as empty circle) or by adding sockets from the node property bar in the "Interface" panel. Further details such as the socket name can also be changed there. [1] http://wiki.blender.org/index.php/User:Phonybone/Python_Nodes [2] http://projects.blender.org/scm/viewvc.php/trunk/blender/release/scripts/templates_py/custom_nodes.py?view=markup&root=bf-blender [3] http://code.blender.org/index.php/2012/01/improving-node-group-interface-editing/
2013-03-18 16:34:57 +00:00
NOD_common.h
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
NOD_composite.h
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
NOD_derived_node_tree.hh
Simulations: Add Boolean Math, Switch and Float Compare node UI Reviewers: brecht Differential Revision: https://developer.blender.org/D7424
2020-04-20 15:27:12 +02:00
NOD_function.h
Cleanup: sort cmake file lists
2020-12-11 15:00:22 +11:00
NOD_geometry.h
CMake: add missing headers Resolves 'cmake_consistency_check' reports.
2021-01-20 16:08:52 +11:00
NOD_geometry_exec.hh
Geometry Nodes: refactor logging during geometry nodes evaluation Many ui features for geometry nodes need access to information generated during evaluation: * Node warnings. * Attribute search. * Viewer node. * Socket inspection (not in master yet). The way we logged the required information before had some disadvantages: * Viewer node used a completely separate system from node warnings and attribute search. * Most of the context of logged information is lost when e.g. the same node group is used multiple times. * A global lock was needed every time something is logged. This new implementation solves these problems: * All four mentioned ui features use the same underlying logging system. * All context information for logged values is kept intact. * Every thread has its own local logger. The logged informatiton is combined in the end. Differential Revision: https://developer.blender.org/D11785
2021-07-07 11:20:19 +02:00
NOD_geometry_nodes_eval_log.hh
Cleanup: sort cmake file lists
2020-12-11 15:00:22 +11:00
NOD_math_functions.hh
Functions: remove multi-function network The multi-function network system was able to compose multiple multi-functions into a new one and to evaluate that efficiently. This functionality was heavily used by the particle nodes prototype a year ago. However, since then we only used multi-functions without the need to compose them in geometry nodes. The upcoming "fields" in geometry nodes will need a way to compose multi-functions again. Unfortunately, the code removed in this commit was not ideal for this different kind of function composition. I've been working on an alternative that will be added separately when it becomes needed. I've had to update all the function nodes, because their interface depended on the multi-function network data structure a bit. The actual multi-function implementations are still the same though.
2021-08-20 13:14:39 +02:00
NOD_multi_function.hh
Nodes: add more flexible method to declare sockets of a node Previously, built-in nodes had to implement "socket templates" (`bNodeSocketTemplate`) to tell Blender which sockets they have. It was nice that this was declarative, but this approach was way too rigid and was cumbersome to use in many cases. This commit starts to move us away from this rigid structure by letting nodes implement a function that declares the sockets the node has. Right now this is used as a direct replacement of the "socket template" approach to keep the refactor smaller. It's just a bit easier to read and write. In the future we want to support more complex features like dynamic numbers of sockets and type inferencing. Those features will be easier to build on this new approach. This new approach can live side by side with `bNodeSocketTemplate` for a while. That makes it easier to update nodes one by one. Note: In `bNodeSocketTemplate` socket identifiers were made unique automatically. In this new approach, one has to specify unique identifiers manually (unless the name is unique already). Differential Revision: https://developer.blender.org/D12335
2021-08-30 17:13:46 +02:00
NOD_node_declaration.hh
Nodes: move some code from blenkernel directory to nodes This also introduces the `blender::nodes` namespace. Eventually, we want to move most/all of the node implementation files into this namespace. The reason for this file-move is that the code fits much better into the `nodes` directory than in the `blenkernel` directory.
2020-07-17 11:36:59 +02:00
NOD_node_tree_ref.hh
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
NOD_shader.h
NOD_socket.h
Cleanup: sort cmake file lists
2021-09-29 07:29:19 +10:00
NOD_socket_declarations.hh
Merge of the PyNodes branch (aka "custom nodes") into trunk. PyNodes opens up the node system in Blender to scripters and adds a number of UI-level improvements. === Dynamic node type registration === Node types can now be added at runtime, using the RNA registration mechanism from python. This enables addons such as render engines to create a complete user interface with nodes. Examples of how such nodes can be defined can be found in my personal wiki docs atm [1] and as a script template in release/scripts/templates_py/custom_nodes.py [2]. === Node group improvements === Each node editor now has a tree history of edited node groups, which allows opening and editing nested node groups. The node editor also supports pinning now, so that different spaces can be used to edit different node groups simultaneously. For more ramblings and rationale see (really old) blog post on code.blender.org [3]. The interface of node groups has been overhauled. Sockets of a node group are no longer displayed in columns on either side, but instead special input/output nodes are used to mirror group sockets inside a node tree. This solves the problem of long node lines in groups and allows more adaptable node layout. Internal sockets can be exposed from a group by either connecting to the extension sockets in input/output nodes (shown as empty circle) or by adding sockets from the node property bar in the "Interface" panel. Further details such as the socket name can also be changed there. [1] http://wiki.blender.org/index.php/User:Phonybone/Python_Nodes [2] http://projects.blender.org/scm/viewvc.php/trunk/blender/release/scripts/templates_py/custom_nodes.py?view=markup&root=bf-blender [3] http://code.blender.org/index.php/2012/01/improving-node-group-interface-editing/
2013-03-18 16:34:57 +00:00
NOD_static_types.h
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
NOD_texture.h
Cleanup: move type conversions to separate file
2021-04-15 09:35:56 +02:00
NOD_type_conversions.hh
Merged the particles-2010 branch with node improvements into trunk. This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too. Detailed information can be found on the wiki page: http://wiki.blender.org/index.php/User:Phonybone/Particles2010
2011-09-05 21:01:50 +00:00
intern/node_common.h
Cleanup: sort cmake file lists
2019-01-25 08:30:33 +11:00
intern/node_exec.h
intern/node_util.h
use explicit file paths for CMake rather then globing, This is recommended by cmake devs. globbing vs explicit is discussed here. http://www.cmake.org/pipermail/cmake/2008-December/025694.html Practical implications are: - developers need to keep CMakeLists.txt files up to date. - Users wont get strange linking errors if they build after a file is added, since CMake detects CMakeLists.txt is modified and automatically reconfigure.
2010-10-23 04:05:55 +00:00
)
CMake: prepare for BLENDER_SORTED_LIBS removal No functional change, this adds LIB definition and args to cmake files. Without this it's difficult to migrate away from 'BLENDER_SORTED_LIBS' since there are many platforms/configurations that could break when changing linking order. Manually add and enable WITHOUT_SORTED_LIBS to try building without sorted libs (currently fails since all variables are empty). This check will eventually be removed. See T46725.
2019-04-14 15:18:44 +02:00
set(LIB
Cleanup: sort cmake file lists
2020-12-11 15:00:22 +11:00
bf_bmesh
Nodes: Generate multi-function network from node tree This adds new callbacks to `bNodeSocketType` and `bNodeType`. Those are used to generate a multi-function network from a node tree. Later, this network is evaluated on e.g. particle data. Reviewers: brecht Differential Revision: https://developer.blender.org/D8169
2020-07-07 18:23:33 +02:00
bf_functions
Geometry Nodes: Field version of mesh to curve node This commit adds a fields version of the mesh to curve node, with a field for the input selection. In order to reduce code duplication, it adds the mesh to curve conversion to the new geometry module and calls that implementation from both places. More details on the geometry module can be found here: T86869 Differential Revision: https://developer.blender.org/D12579
2021-10-14 12:06:48 -05:00
bf_geometry
EEVEE: Implement the missing Sky texture I'm not sure if the Sky was deliberately left out or was just waiting for a better moment, but so many I was disappointed that Sky in EEVEE is completely white. There are already 2 implementations (osl and gpu) so this is the third one. Looking at other cases it seems that we are not supposed to share sources between cycles and the rest? So the new util_sky_model files are just copies of what is already in cycles, except that the data file uses the RGB variant of the Hosek/Wilkie model, because we output RGB anyway (but can be easily changed to XYZ if desired - the results are nearly identical). I am not sure if it is okay to pass 3*9 float values as 3 mat4 uniforms (I wanted to use mat3 but it does not work). Also, should I cache the sky model data between renders if the parameters do not change? Reviewed By: fclem, brecht Differential Revision: https://developer.blender.org/D7108
2020-07-09 17:19:52 +02:00
bf_intern_sky
CMake: prepare for BLENDER_SORTED_LIBS removal No functional change, this adds LIB definition and args to cmake files. Without this it's difficult to migrate away from 'BLENDER_SORTED_LIBS' since there are many platforms/configurations that could break when changing linking order. Manually add and enable WITHOUT_SORTED_LIBS to try building without sorted libs (currently fails since all variables are empty). This check will eventually be removed. See T46725.
2019-04-14 15:18:44 +02:00
)
Geometry Nodes: Add Convex Hull Node This commit adds a node to output the convex hull of any input geometry as a mesh, which is an enclosing geometry around a set of points. All geometry types are supported, besides volumes. The code supports operating on instances to avoid copying all input geometry before the operation. The implementation uses the same backend as the operation in edit mode, but uses Mesh directly instead of BMesh. Attribute transfer is not supported currently, but would be a point of improvement for the future if it can work in a predictable way on different geometry input types. Differential Revision: https://developer.blender.org/D10925
2021-06-09 11:58:08 -05:00
if(WITH_BULLET)
list(APPEND INC_SYS
${BULLET_INCLUDE_DIRS}
"../../../intern/rigidbody/"
)
if(NOT WITH_SYSTEM_BULLET)
list(APPEND LIB
extern_bullet
)
endif()
list(APPEND LIB
${BULLET_LIBRARIES}
)
add_definitions(-DWITH_BULLET)
endif()
Added WITH_PYTHON as a cmake option
2008-12-31 05:20:35 +00:00
if(WITH_PYTHON)
cmake source definitions: remove missing includes and use more strict formatting.
2011-07-16 23:01:14 +00:00
list(APPEND INC
../python
)
list(APPEND INC_SYS
${PYTHON_INCLUDE_DIRS}
)
CMake: Refactor external dependencies handling This is a more correct fix to the issue Brecht was fixing in D6600. While the fix in that patch worked fine for linking it broke ASAN runtime under some circumstances. For example, `make full debug developer` would compile, but trying to start blender will cause assert failure in ASAN (related on check that ASAN is not running already). Top-level idea: leave it to CMake to keep track of dependency graph. The root of the issue comes to the fact that target like "blender" is configured to use a lot of static libraries coming from Blender sources and to use external static libraries. There is nothing which ensures order between blender's and external libraries. Only order of blender libraries is guaranteed. It was possible that due to a cycle or other circumstances some of blender libraries would have been passed to linker after libraries it uses, causing linker errors. For example, this order will likely fail: libbf_blenfont.a libfreetype6.a libbf_blenfont.a This change makes it so blender libraries are explicitly provided their dependencies to an external libraries, which allows CMake to ensure they are always linked against them. General rule here: if bf_foo depends on an external library it is to be provided to LIBS for bf_foo. For example, if bf_blenkernel depends on opensubdiv then LIBS in blenkernel's CMakeLists.txt is to include OPENSUBDIB_LIBRARIES. The change is made based on searching for used include folders such as OPENSUBDIV_INCLUDE_DIRS and adding corresponding libraries to LIBS ion that CMakeLists.txt. Transitive dependencies are not simplified by this approach, but I am not aware of any downside of this: CMake should be smart enough to simplify them on its side. And even if not, this shouldn't affect linking time. Benefit of not relying on transitive dependencies is that build system is more robust towards future changes. For example, if bf_intern_opensubiv is no longer depends on OPENSUBDIV_LIBRARIES and all such code is moved to bf_blenkernel this will not break linking. The not-so-trivial part is change to blender_add_lib (and its version in Cycles). The complexity is caused by libraries being provided as a single list argument which doesn't allow to use different release and debug libraries on Windows. The idea is: - Have every library prefixed as "optimized" or "debug" if separation is needed (non-prefixed libraries will be considered "generic"). - Loop through libraries passed to function and do simple parsing which will look for "optimized" and "debug" words and specify following library to corresponding category. This isn't something particularly great. Alternative would be to use target_link_libraries() directly, which sounds like more code but which is more explicit and allows to have more flexibility and control comparing to wrapper approach. Tested the following configurations on Linux, macOS and Windows: - make full debug developer - make full release developer - make lite debug developer - make lite release developer NOTE: Linux libraries needs to be compiled with D6641 applied, otherwise, depending on configuration, it's possible to run into duplicated zlib symbols error. Differential Revision: https://developer.blender.org/D6642
2020-01-20 18:36:19 +01:00
list(APPEND LIB
${PYTHON_LINKFLAGS}
${PYTHON_LIBRARIES}
)
rename and negate DISABLE_PYTHON --> WITH_PYTHON
2010-10-31 04:11:39 +00:00
add_definitions(-DWITH_PYTHON)
Added WITH_PYTHON as a cmake option
2008-12-31 05:20:35 +00:00
endif()
Fix for yesterday i18n own commit (r44924): we now need to define WITH_INTERNATIONAL everywhere TIP_/IFACE_ macros are used (else, we get non-international, dummy NOP macros instead!). Also fixed in main CMakeList file, when no addon dir found, we want to disable WITH_PYTHON (I guess, certainly not WITH_INTERNATIONAL ;) ).
2012-03-17 12:07:58 +00:00
if(WITH_INTERNATIONAL)
add_definitions(-DWITH_INTERNATIONAL)
endif()
Geometry Nodes: Add Attribute Proximity Node This node calculates a distance from each point to the closest position on a target geometry, similar to the vertex weight proximity modifier. Mapping the output distance to a different range can be done with an attribute math node after this node. A drop-down changes whether to calculate distances from points, edges, or faces. In points mode, the node also calculates distances from point cloud points. Design task and use cases: T84842 Differential Revision: https://developer.blender.org/D10154
2021-02-05 08:28:31 -06:00
if(WITH_TBB)
Fix geometry nodes build error with TBB enabled and OpenVDB disabled Don't rely on TBB includes coming along with OpenVDB.
2021-02-12 20:08:43 +01:00
list(APPEND INC_SYS
${TBB_INCLUDE_DIRS}
)
Geometry Nodes: Add Attribute Proximity Node This node calculates a distance from each point to the closest position on a target geometry, similar to the vertex weight proximity modifier. Mapping the output distance to a different range can be done with an attribute math node after this node. A drop-down changes whether to calculate distances from points, edges, or faces. In points mode, the node also calculates distances from point cloud points. Design task and use cases: T84842 Differential Revision: https://developer.blender.org/D10154
2021-02-05 08:28:31 -06:00
add_definitions(-DWITH_TBB)
MSVC: Fix build issue with TBB TBB includes in windows.h which will by default define min/max macro's by default, which collide with stl's min/mac functions. this change instructs windows.h not to add the offending macros
2021-07-07 10:55:27 -06:00
if(WIN32)
# TBB includes Windows.h which will define min/max macros
# that will collide with the stl versions.
add_definitions(-DNOMINMAX)
endif()
Geometry Nodes: Add Attribute Proximity Node This node calculates a distance from each point to the closest position on a target geometry, similar to the vertex weight proximity modifier. Mapping the output distance to a different range can be done with an attribute math node after this node. A drop-down changes whether to calculate distances from points, edges, or faces. In points mode, the node also calculates distances from point cloud points. Design task and use cases: T84842 Differential Revision: https://developer.blender.org/D10154
2021-02-05 08:28:31 -06:00
endif()
A number of improvements for the file output node(s). 1) Old CMP_NODE_OUTPUT_FILE and CMP_NODE_OUTPUT_MULTI_FILE have been merged, only CMP_NODE_OUTPUT_FILE remains. All functions renamed accordingly. 2) do_versions code for converting single-file output nodes into multi-file output nodes. If a Z buffer input is used, the node is made into a multilayer exr with two inputs. (see below). Also re-identifies multi-file output nodes with the CMP_NODE_OUTPUT_FILE type. 3) "Global" format is stored in node now. By default this overrides any per-socket settings. 4) Multilayer EXR output implemented. When M.EXR format is selected for node format, all socket format details are ignored. Socket names are used for layer names. 5) Input buffer types are used as-is when possible, i.e. stored as B/W, RGB or RGBA. In regular file output the format dictates the number of actual channels, so the CompBuf is typechecked to the right type first. For multilayer EXR the number of channels is more flexible, so an input buffer will store only the channels it actually uses. 6) The editor socket type is updated from linked sockets as an indicator of the actual data written to files. This may not be totally accurate for regular file output though, due to restrictions of format setting.
2012-03-01 07:56:15 +00:00
if(WITH_IMAGE_OPENEXR)
add_definitions(-DWITH_OPENEXR)
endif()
the compositor optional for cmake: WITH_COMPOSITOR
2012-06-30 14:14:22 +00:00
if(WITH_COMPOSITOR)
list(APPEND INC
../compositor
)
add_definitions(-DWITH_COMPOSITOR)
endif()
Implemented a basic framework for node-based shaders. Shader nodes will be used to define materials for stroke rendering, so as to allow users to interactively configure textures.
2014-07-11 16:51:04 +09:00
if(WITH_FREESTYLE)
add_definitions(-DWITH_FREESTYLE)
endif()
Geometry Nodes: initial scattering and geometry nodes This is the initial merge from the geometry-nodes branch. Nodes: * Attribute Math * Boolean * Edge Split * Float Compare * Object Info * Point Distribute * Point Instance * Random Attribute * Random Float * Subdivision Surface * Transform * Triangulate It includes the initial evaluation of geometry node groups in the Geometry Nodes modifier. Notes on the Generic attribute access API The API adds an indirection for attribute access. That has the following benefits: * Most code does not have to care about how an attribute is stored internally. This is mainly necessary, because we have to deal with "legacy" attributes such as vertex weights and attributes that are embedded into other structs such as vertex positions. * When reading from an attribute, we generally don't care what domain the attribute is stored on. So we want to abstract away the interpolation that that adapts attributes from one domain to another domain (this is not actually implemented yet). Other possible improvements for later iterations include: * Actually implement interpolation between domains. * Don't use inheritance for the different attribute types. A single class for read access and one for write access might be enough, because we know all the ways in which attributes are stored internally. We don't want more different internal structures in the future. On the contrary, ideally we can consolidate the different storage formats in the future to reduce the need for this indirection. * Remove the need for heap allocations when creating attribute accessors. It includes commits from: * Dalai Felinto * Hans Goudey * Jacques Lucke * Léo Depoix
2020-12-02 13:25:25 +01:00
if(WITH_OPENSUBDIV)
add_definitions(-DWITH_OPENSUBDIV)
endif()
Cleanup: Nodes: Use consistent errors for nodes built without features
2021-04-12 17:43:36 -05:00
if(WITH_GMP)
add_definitions(-DWITH_GMP)
Fix compile error: Missing include paths rB8d9fd0427dd6 added the `WITH_GMP` definition but did not append the include paths.
2021-04-13 09:47:52 +02:00
list(APPEND INC_SYS
${GMP_INCLUDE_DIRS}
)
list(APPEND LIB
${GMP_LIBRARIES}
)
Cleanup: Nodes: Use consistent errors for nodes built without features
2021-04-12 17:43:36 -05:00
endif()
Geometry Nodes: initial support for volumes For the most part, this just adds boilerplate code for volume support in geometry nodes: * Add `VolumeComponent` next to `MeshComponent`, etc. * Support `VolumeComponent` in depsgraph object iterator. Furthermore, I added initial volume support in a few nodes: * The Object Info node outputs an object instance when the input is a volume object (that will be the same for mesh objects soonish, to avoid copies). * Support transforming a `VolumeComponent` in the Transform node. * Support the `VolumeComponent` in Join Geometry nodes, but only when just one of the inputs has a volume component for now. Right now, there is no way to create a `VolumeComponent`, because the Object Info node outputs an object instance. The `VolumeComponent` will be necessary for upcoming nodes, which will generate volumes on the fly. Viewport selection does not work correctly with `VolumeComponent`s currently. I don't know why that is. That can be figured out a bit later, once we can actually create new volumes in geometry nodes. Ref T84604. Differential Revision: https://developer.blender.org/D10147
2021-01-21 10:32:42 +01:00
if(WITH_OPENVDB)
list(APPEND INC_SYS
${OPENVDB_INCLUDE_DIRS}
)
add_definitions(-DWITH_OPENVDB ${OPENVDB_DEFINITIONS})
endif()
CMake: prepare for BLENDER_SORTED_LIBS removal No functional change, this adds LIB definition and args to cmake files. Without this it's difficult to migrate away from 'BLENDER_SORTED_LIBS' since there are many platforms/configurations that could break when changing linking order. Manually add and enable WITHOUT_SORTED_LIBS to try building without sorted libs (currently fails since all variables are empty). This check will eventually be removed. See T46725.
2019-04-14 15:18:44 +02:00
blender_add_lib(bf_nodes "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
Copy Permalink