griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
964a2dd73f687cbc293434eb3cbaa1b45ede20c5
test/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
Ton Roosendaal 51b796ff15 Remove Blender Internal and legacy viewport from Blender 2.8. 
Brecht authored this commit, but he gave me the honours to actually
do it. Here it goes; Blender Internal. Bye bye, you did great!

* Point density, voxel data, ocean, environment map textures were removed,
  as these only worked within BI rendering. Note that the ocean modifier
  and the Cycles point density shader node continue to work.
* Dynamic paint using material shading was removed, as this only worked
  with BI. If we ever wanted to support this again probably it should go
  through the baking API.
* GPU shader export through the Python API was removed. This only worked
  for the old BI GLSL shaders, which no longer exists. Doing something
  similar for Eevee would be significantly more complicated because it
  uses a lot of multiplass rendering and logic outside the shader, it's
  probably impractical.
* Collada material import / export code is mostly gone, as it only worked
  for BI materials. We need to add Cycles / Eevee material support at some
  point.
* The mesh noise operator was removed since it only worked with BI
  material texture slots. A displacement modifier can be used instead.
* The delete texture paint slot operator was removed since it only worked
  for BI material texture slots. Could be added back with node support.

* Not all legacy viewport features are supported in the new viewport, but
  their code was removed. If we need to bring anything back we can look at
  older git revisions.
* There is some legacy viewport code that I could not remove yet, and some
  that I probably missed.
* Shader node execution code was left mostly intact, even though it is not
  used anywhere now. We may eventually use this to replace the texture
  nodes with Cycles / Eevee shader nodes.

* The Cycles Bake panel now includes settings for baking multires normal
  and displacement maps. The underlying code needs to be merged properly,
  and we plan to add back support for multires AO baking and add support
  to Cycles baking for features like vertex color, displacement, and other
  missing baking features.

* This commit removes DNA and the Python API for BI material, lamp, world
  and scene settings. This breaks a lot of addons.
* There is more DNA that can be removed or renamed, where Cycles or Eevee
  are reusing some old BI properties but the names are not really correct
  anymore.
* Texture slots for materials, lamps and world were removed. They remain
  for brushes, particles and freestyle linestyles.
* 'BLENDER_RENDER' remains in the COMPAT_ENGINES of UI panels. Cycles and
  other renderers use this to find all panels to show, minus a few panels
  that they have their own replacement for.
2018-04-19 17:35:25 +02:00

1459 lines
43 KiB
C++
Raw Blame History

/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* 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
* of the License, or (at your option) any later version.
*
* 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,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2013 Blender Foundation.
* All rights reserved.
*
* Original Author: Joshua Leung
* Contributor(s): Based on original depsgraph.c code - Blender Foundation (2005-2013)
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/depsgraph/intern/builder/deg_builder_nodes.cc
* \ingroup depsgraph
*
* Methods for constructing depsgraph's nodes
*/
#include "intern/builder/deg_builder_nodes.h"
#include <stdio.h>
#include <stdlib.h>
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BLI_string.h"
#include "BLI_utildefines.h"
extern "C" {
#include "DNA_action_types.h"
#include "DNA_anim_types.h"
#include "DNA_armature_types.h"
#include "DNA_cachefile_types.h"
#include "DNA_camera_types.h"
#include "DNA_constraint_types.h"
#include "DNA_curve_types.h"
#include "DNA_effect_types.h"
#include "DNA_gpencil_types.h"
#include "DNA_group_types.h"
#include "DNA_key_types.h"
#include "DNA_lamp_types.h"
#include "DNA_material_types.h"
#include "DNA_mask_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meta_types.h"
#include "DNA_movieclip_types.h"
#include "DNA_node_types.h"
#include "DNA_particle_types.h"
#include "DNA_object_types.h"
#include "DNA_lightprobe_types.h"
#include "DNA_rigidbody_types.h"
#include "DNA_scene_types.h"
#include "DNA_texture_types.h"
#include "DNA_world_types.h"
#include "BKE_action.h"
#include "BKE_armature.h"
#include "BKE_animsys.h"
#include "BKE_constraint.h"
#include "BKE_curve.h"
#include "BKE_effect.h"
#include "BKE_fcurve.h"
#include "BKE_idcode.h"
#include "BKE_group.h"
#include "BKE_key.h"
#include "BKE_lattice.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BKE_mask.h"
#include "BKE_material.h"
#include "BKE_mesh.h"
#include "BKE_mball.h"
#include "BKE_modifier.h"
#include "BKE_movieclip.h"
#include "BKE_node.h"
#include "BKE_object.h"
#include "BKE_particle.h"
#include "BKE_pointcache.h"
#include "BKE_rigidbody.h"
#include "BKE_sound.h"
#include "BKE_tracking.h"
#include "BKE_world.h"
#include "RNA_access.h"
#include "RNA_types.h"
} /* extern "C" */
#include "DEG_depsgraph.h"
#include "DEG_depsgraph_build.h"
#include "intern/builder/deg_builder.h"
#include "intern/eval/deg_eval_copy_on_write.h"
#include "intern/nodes/deg_node.h"
#include "intern/nodes/deg_node_component.h"
#include "intern/nodes/deg_node_id.h"
#include "intern/nodes/deg_node_operation.h"
#include "intern/depsgraph_types.h"
#include "intern/depsgraph_intern.h"
#include "util/deg_util_foreach.h"
namespace DEG {
namespace {
void free_copy_on_write_datablock(void *id_v)
{
ID *id = (ID *)id_v;
deg_free_copy_on_write_datablock(id);
MEM_freeN(id);
}
} /* namespace */
/* ************ */
/* Node Builder */
/* **** General purpose functions **** */
DepsgraphNodeBuilder::DepsgraphNodeBuilder(Main *bmain, Depsgraph *graph)
: bmain_(bmain),
graph_(graph),
scene_(NULL),
view_layer_(NULL),
cow_id_hash_(NULL)
{
}
DepsgraphNodeBuilder::~DepsgraphNodeBuilder()
{
if (cow_id_hash_ != NULL) {
BLI_ghash_free(cow_id_hash_, NULL, free_copy_on_write_datablock);
}
}
IDDepsNode *DepsgraphNodeBuilder::add_id_node(ID *id)
{
if (!DEG_depsgraph_use_copy_on_write()) {
return graph_->add_id_node(id);
}
IDDepsNode *id_node = NULL;
ID *id_cow = (ID *)BLI_ghash_lookup(cow_id_hash_, id);
if (id_cow != NULL) {
/* TODO(sergey): Is it possible to lookup and pop element from GHash
* at the same time?
*/
BLI_ghash_remove(cow_id_hash_, id, NULL, NULL);
}
id_node = graph_->add_id_node(id, id_cow);
/* Currently all ID nodes are supposed to have copy-on-write logic.
*
* NOTE: Zero number of components indicates that ID node was just created.
*/
if (BLI_ghash_len(id_node->components) == 0) {
ComponentDepsNode *comp_cow =
id_node->add_component(DEG_NODE_TYPE_COPY_ON_WRITE);
OperationDepsNode *op_cow = comp_cow->add_operation(
function_bind(deg_evaluate_copy_on_write, _1, id_node),
DEG_OPCODE_COPY_ON_WRITE,
"", -1);
graph_->operations.push_back(op_cow);
}
return id_node;
}
IDDepsNode *DepsgraphNodeBuilder::find_id_node(ID *id)
{
return graph_->find_id_node(id);
}
TimeSourceDepsNode *DepsgraphNodeBuilder::add_time_source()
{
return graph_->add_time_source();
}
ComponentDepsNode *DepsgraphNodeBuilder::add_component_node(
ID *id,
eDepsNode_Type comp_type,
const char *comp_name)
{
IDDepsNode *id_node = add_id_node(id);
ComponentDepsNode *comp_node = id_node->add_component(comp_type, comp_name);
comp_node->owner = id_node;
return comp_node;
}
OperationDepsNode *DepsgraphNodeBuilder::add_operation_node(
ComponentDepsNode *comp_node,
const DepsEvalOperationCb& op,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
OperationDepsNode *op_node = comp_node->find_operation(opcode,
name,
name_tag);
if (op_node == NULL) {
op_node = comp_node->add_operation(op, opcode, name, name_tag);
graph_->operations.push_back(op_node);
}
else {
fprintf(stderr,
"add_operation: Operation already exists - %s has %s at %p\n",
comp_node->identifier().c_str(),
op_node->identifier().c_str(),
op_node);
BLI_assert(!"Should not happen!");
}
return op_node;
}
OperationDepsNode *DepsgraphNodeBuilder::add_operation_node(
ID *id,
eDepsNode_Type comp_type,
const char *comp_name,
const DepsEvalOperationCb& op,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
ComponentDepsNode *comp_node = add_component_node(id, comp_type, comp_name);
return add_operation_node(comp_node, op, opcode, name, name_tag);
}
OperationDepsNode *DepsgraphNodeBuilder::add_operation_node(
ID *id,
eDepsNode_Type comp_type,
const DepsEvalOperationCb& op,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
return add_operation_node(id,
comp_type,
"",
op,
opcode,
name,
name_tag);
}
OperationDepsNode *DepsgraphNodeBuilder::ensure_operation_node(
ID *id,
eDepsNode_Type comp_type,
const DepsEvalOperationCb& op,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
OperationDepsNode *operation =
find_operation_node(id, comp_type, opcode, name, name_tag);
if (operation != NULL) {
return operation;
}
return add_operation_node(id, comp_type, op, opcode, name, name_tag);
}
bool DepsgraphNodeBuilder::has_operation_node(ID *id,
eDepsNode_Type comp_type,
const char *comp_name,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
return find_operation_node(id,
comp_type,
comp_name,
opcode,
name,
name_tag) != NULL;
}
OperationDepsNode *DepsgraphNodeBuilder::find_operation_node(
ID *id,
eDepsNode_Type comp_type,
const char *comp_name,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
ComponentDepsNode *comp_node = add_component_node(id, comp_type, comp_name);
return comp_node->find_operation(opcode, name, name_tag);
}
OperationDepsNode *DepsgraphNodeBuilder::find_operation_node(
ID *id,
eDepsNode_Type comp_type,
eDepsOperation_Code opcode,
const char *name,
int name_tag)
{
return find_operation_node(id, comp_type, "", opcode, name, name_tag);
}
ID *DepsgraphNodeBuilder::get_cow_id(const ID *id_orig) const
{
return graph_->get_cow_id(id_orig);
}
ID *DepsgraphNodeBuilder::ensure_cow_id(ID *id_orig)
{
if (id_orig->tag & LIB_TAG_COPY_ON_WRITE) {
/* ID is already remapped to copy-on-write. */
return id_orig;
}
IDDepsNode *id_node = add_id_node(id_orig);
return id_node->id_cow;
}
/* **** Build functions for entity nodes **** */
void DepsgraphNodeBuilder::begin_build() {
if (DEG_depsgraph_use_copy_on_write()) {
/* Store existing copy-on-write versions of datablock, so we can re-use
* them for new ID nodes.
*/
cow_id_hash_ = BLI_ghash_ptr_new("Depsgraph id hash");
foreach (IDDepsNode *id_node, graph_->id_nodes) {
if (deg_copy_on_write_is_expanded(id_node->id_cow)) {
if (id_node->id_orig == id_node->id_cow) {
continue;
}
BLI_ghash_insert(cow_id_hash_,
id_node->id_orig,
id_node->id_cow);
id_node->id_cow = NULL;
}
}
}
GSET_FOREACH_BEGIN(OperationDepsNode *, op_node, graph_->entry_tags)
{
ComponentDepsNode *comp_node = op_node->owner;
IDDepsNode *id_node = comp_node->owner;
SavedEntryTag entry_tag;
entry_tag.id = id_node->id_orig;
entry_tag.component_type = comp_node->type;
entry_tag.opcode = op_node->opcode;
saved_entry_tags_.push_back(entry_tag);
};
GSET_FOREACH_END();
/* Make sure graph has no nodes left from previous state. */
graph_->clear_all_nodes();
graph_->operations.clear();
BLI_gset_clear(graph_->entry_tags, NULL);
}
void DepsgraphNodeBuilder::end_build()
{
foreach (const SavedEntryTag& entry_tag, saved_entry_tags_) {
IDDepsNode *id_node = find_id_node(entry_tag.id);
if (id_node == NULL) {
continue;
}
ComponentDepsNode *comp_node =
id_node->find_component(entry_tag.component_type);
if (comp_node == NULL) {
continue;
}
OperationDepsNode *op_node = comp_node->find_operation(entry_tag.opcode);
if (op_node == NULL) {
continue;
}
op_node->tag_update(graph_);
}
}
void DepsgraphNodeBuilder::build_id(ID* id) {
if (id == NULL) {
return;
}
switch (GS(id->name)) {
case ID_GR:
build_group((Group *)id);
break;
case ID_OB:
build_object(-1, (Object *)id, DEG_ID_LINKED_INDIRECTLY);
break;
case ID_NT:
build_nodetree((bNodeTree *)id);
break;
case ID_MA:
build_material((Material *)id);
break;
case ID_TE:
build_texture((Tex *)id);
break;
case ID_IM:
build_image((Image *)id);
break;
case ID_WO:
build_world((World *)id);
break;
case ID_MSK:
build_mask((Mask *)id);
break;
case ID_MC:
build_movieclip((MovieClip *)id);
break;
default:
fprintf(stderr, "Unhandled ID %s\n", id->name);
}
}
void DepsgraphNodeBuilder::build_group(Group *group)
{
if (built_map_.checkIsBuiltAndTag(group)) {
return;
}
/* Build group objects. */
LISTBASE_FOREACH (Base *, base, &group->view_layer->object_bases) {
build_object(-1, base->object, DEG_ID_LINKED_INDIRECTLY);
}
/* Operation to evaluate the whole view layer.
*
* NOTE: We re-use DONE opcode even though the function does everything.
* This way we wouldn't need to worry about possible relations from DONE,
* regardless whether it's a group or scene or something else.
*/
add_id_node(&group->id);
Group *group_cow = get_cow_datablock(group);
add_operation_node(&group->id,
DEG_NODE_TYPE_LAYER_COLLECTIONS,
function_bind(BKE_group_eval_view_layers,
_1,
group_cow),
DEG_OPCODE_VIEW_LAYER_EVAL);
}
void DepsgraphNodeBuilder::build_object(int base_index,
Object *object,
eDepsNode_LinkedState_Type linked_state)
{
const bool has_object = built_map_.checkIsBuiltAndTag(object);
/* Skip rest of components if the ID node was already there. */
if (has_object) {
IDDepsNode *id_node = find_id_node(&object->id);
/* We need to build some extra stuff if object becomes linked
* directly.
*/
if (id_node->linked_state == DEG_ID_LINKED_INDIRECTLY) {
build_object_flags(base_index, object, linked_state);
}
id_node->linked_state = max(id_node->linked_state, linked_state);
return;
}
/* Create ID node for object and begin init. */
IDDepsNode *id_node = add_id_node(&object->id);
id_node->linked_state = linked_state;
object->customdata_mask = 0;
/* Various flags, flushing from bases/collections. */
build_object_flags(base_index, object, linked_state);
/* Transform. */
build_object_transform(object);
/* Parent. */
if (object->parent != NULL) {
build_object(-1, object->parent, DEG_ID_LINKED_INDIRECTLY);
}
/* Modifiers. */
if (object->modifiers.first != NULL) {
BuilderWalkUserData data;
data.builder = this;
modifiers_foreachIDLink(object, modifier_walk, &data);
}
/* Constraints. */
if (object->constraints.first != NULL) {
BuilderWalkUserData data;
data.builder = this;
BKE_constraints_id_loop(&object->constraints, constraint_walk, &data);
}
/* Object data. */
build_object_data(object);
/* Build animation data,
*
* Do it now because it's possible object data will affect
* on object's level animation, for example in case of rebuilding
* pose for proxy.
*/
OperationDepsNode *op_node = add_operation_node(&object->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PARAMETERS_EVAL);
op_node->set_as_exit();
build_animdata(&object->id);
/* Particle systems. */
if (object->particlesystem.first != NULL) {
build_particles(object);
}
/* Grease pencil. */
if (object->gpd != NULL) {
build_gpencil(object->gpd);
}
/* Object that this is a proxy for. */
if (object->proxy) {
object->proxy->proxy_from = object;
build_object(-1, object->proxy, DEG_ID_LINKED_INDIRECTLY);
}
/* Object dupligroup. */
if (object->dup_group != NULL) {
build_group(object->dup_group);
}
}
void DepsgraphNodeBuilder::build_object_flags(
int base_index,
Object *object,
eDepsNode_LinkedState_Type linked_state)
{
if (base_index == -1) {
return;
}
Scene *scene_cow = get_cow_datablock(scene_);
Object *object_cow = get_cow_datablock(object);
const bool is_from_set = (linked_state == DEG_ID_LINKED_VIA_SET);
/* TODO(sergey): Is this really best component to be used? */
add_operation_node(&object->id,
DEG_NODE_TYPE_LAYER_COLLECTIONS,
function_bind(BKE_object_eval_flush_base_flags,
_1,
scene_cow,
view_layer_index_,
object_cow, base_index,
is_from_set),
DEG_OPCODE_OBJECT_BASE_FLAGS);
}
void DepsgraphNodeBuilder::build_object_data(Object *object)
{
if (object->data == NULL) {
return;
}
IDDepsNode *id_node = graph_->find_id_node(&object->id);
/* type-specific data. */
switch (object->type) {
case OB_MESH:
case OB_CURVE:
case OB_FONT:
case OB_SURF:
case OB_MBALL:
case OB_LATTICE:
build_obdata_geom(object);
/* TODO(sergey): Only for until we support granular
* update of curves.
*/
if (object->type == OB_FONT) {
Curve *curve = (Curve *)object->data;
if (curve->textoncurve) {
id_node->eval_flags |= DAG_EVAL_NEED_CURVE_PATH;
}
}
break;
case OB_ARMATURE:
if (ID_IS_LINKED(object) && object->proxy_from != NULL) {
build_proxy_rig(object);
}
else {
build_rig(object);
}
break;
case OB_LAMP:
build_lamp(object);
break;
case OB_CAMERA:
build_camera(object);
break;
case OB_LIGHTPROBE:
build_lightprobe(object);
break;
default:
{
ID *obdata = (ID *)object->data;
if (built_map_.checkIsBuilt(obdata) == 0) {
build_animdata(obdata);
}
break;
}
}
}
void DepsgraphNodeBuilder::build_object_transform(Object *object)
{
OperationDepsNode *op_node;
Scene *scene_cow = get_cow_datablock(scene_);
Object *ob_cow = get_cow_datablock(object);
/* local transforms (from transform channels - loc/rot/scale + deltas) */
op_node = add_operation_node(&object->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_object_eval_local_transform,
_1,
ob_cow),
DEG_OPCODE_TRANSFORM_LOCAL);
op_node->set_as_entry();
/* object parent */
if (object->parent != NULL) {
add_operation_node(&object->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_object_eval_parent,
_1,
scene_cow,
ob_cow),
DEG_OPCODE_TRANSFORM_PARENT);
}
/* object constraints */
if (object->constraints.first != NULL) {
build_object_constraints(object);
}
/* Rest of transformation update. */
add_operation_node(&object->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_object_eval_uber_transform,
_1,
ob_cow),
DEG_OPCODE_TRANSFORM_OBJECT_UBEREVAL);
/* object transform is done */
op_node = add_operation_node(&object->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_object_eval_done,
_1,
ob_cow),
DEG_OPCODE_TRANSFORM_FINAL);
op_node->set_as_exit();
}
/**
* Constraints Graph Notes
*
* For constraints, we currently only add a operation node to the Transform
* or Bone components (depending on whichever type of owner we have).
* This represents the entire constraints stack, which is for now just
* executed as a single monolithic block. At least initially, this should
* be sufficient for ensuring that the porting/refactoring process remains
* manageable.
*
* However, when the time comes for developing "node-based" constraints,
* we'll need to split this up into pre/post nodes for "constraint stack
* evaluation" + operation nodes for each constraint (i.e. the contents
* of the loop body used in the current "solve_constraints()" operation).
*
* -- Aligorith, August 2013
*/
void DepsgraphNodeBuilder::build_object_constraints(Object *object)
{
/* create node for constraint stack */
add_operation_node(&object->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_object_eval_constraints,
_1,
get_cow_datablock(scene_),
get_cow_datablock(object)),
DEG_OPCODE_TRANSFORM_CONSTRAINTS);
}
/**
* Build graph nodes for AnimData block
* \param id: ID-Block which hosts the AnimData
*/
void DepsgraphNodeBuilder::build_animdata(ID *id)
{
AnimData *adt = BKE_animdata_from_id(id);
if (adt == NULL) {
return;
}
/* animation */
if (adt->action || adt->nla_tracks.first || adt->drivers.first) {
(void) add_id_node(id);
ID *id_cow = get_cow_id(id);
// XXX: Hook up specific update callbacks for special properties which
// may need it...
/* actions and NLA - as a single unit for now, as it gets complicated to
* schedule otherwise.
*/
if ((adt->action) || (adt->nla_tracks.first)) {
/* create the node */
add_operation_node(id, DEG_NODE_TYPE_ANIMATION,
function_bind(BKE_animsys_eval_animdata,
_1,
id_cow),
DEG_OPCODE_ANIMATION,
id->name);
/* TODO: for each channel affected, we might also want to add some
* support for running RNA update callbacks on them
* (which will be needed for proper handling of drivers later)
*/
}
/* drivers */
LISTBASE_FOREACH (FCurve *, fcu, &adt->drivers) {
/* create driver */
build_driver(id, fcu);
}
}
}
/**
* Build graph node(s) for Driver
* \param id: ID-Block that driver is attached to
* \param fcu: Driver-FCurve
*/
void DepsgraphNodeBuilder::build_driver(ID *id, FCurve *fcurve)
{
ID *id_cow = get_cow_id(id);
/* Create data node for this driver */
/* TODO(sergey): Shall we use COW of fcu itself here? */
ensure_operation_node(id,
DEG_NODE_TYPE_PARAMETERS,
function_bind(BKE_animsys_eval_driver, _1, id_cow, fcurve),
DEG_OPCODE_DRIVER,
fcurve->rna_path ? fcurve->rna_path : "",
fcurve->array_index);
build_driver_variables(id, fcurve);
}
void DepsgraphNodeBuilder::build_driver_variables(ID * id, FCurve *fcurve)
{
build_driver_id_property(id, fcurve->rna_path);
LISTBASE_FOREACH (DriverVar *, dvar, &fcurve->driver->variables) {
DRIVER_TARGETS_USED_LOOPER(dvar)
{
build_id(dtar->id);
build_driver_id_property(dtar->id, dtar->rna_path);
}
DRIVER_TARGETS_LOOPER_END
}
}
void DepsgraphNodeBuilder::build_driver_id_property(ID *id,
const char *rna_path)
{
if (id == NULL || rna_path == NULL) {
return;
}
PointerRNA id_ptr, ptr;
PropertyRNA *prop;
RNA_id_pointer_create(id, &id_ptr);
if (!RNA_path_resolve_full(&id_ptr, rna_path, &ptr, &prop, NULL)) {
return;
}
if (prop == NULL) {
return;
}
if (!RNA_property_is_idprop(prop)) {
return;
}
const char *prop_identifier = RNA_property_identifier((PropertyRNA *)prop);
ensure_operation_node(id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_ID_PROPERTY,
prop_identifier);
}
/* Recursively build graph for world */
void DepsgraphNodeBuilder::build_world(World *world)
{
if (built_map_.checkIsBuiltAndTag(world)) {
return;
}
/* Animation. */
build_animdata(&world->id);
/* world itself */
add_operation_node(&world->id,
DEG_NODE_TYPE_SHADING,
function_bind(BKE_world_eval,
_1,
get_cow_datablock(world)),
DEG_OPCODE_WORLD_UPDATE);
/* world's nodetree */
if (world->nodetree != NULL) {
build_nodetree(world->nodetree);
}
}
/* Rigidbody Simulation - Scene Level */
void DepsgraphNodeBuilder::build_rigidbody(Scene *scene)
{
RigidBodyWorld *rbw = scene->rigidbody_world;
Scene *scene_cow = get_cow_datablock(scene);
/**
* Rigidbody Simulation Nodes
* ==========================
*
* There are 3 nodes related to Rigidbody Simulation:
* 1) "Initialize/Rebuild World" - this is called sparingly, only when the
* simulation needs to be rebuilt (mainly after file reload, or moving
* back to start frame)
* 2) "Do Simulation" - perform a simulation step - interleaved between the
* evaluation steps for clusters of objects (i.e. between those affected
* and/or not affected by the sim for instance).
*
* 3) "Pull Results" - grab the specific transforms applied for a specific
* object - performed as part of object's transform-stack building.
*/
/* Create nodes --------------------------------------------------------- */
/* XXX: is this the right component, or do we want to use another one
* instead?
*/
/* init/rebuild operation */
/*OperationDepsNode *init_node =*/ add_operation_node(
&scene->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_rigidbody_rebuild_sim, _1, scene_cow),
DEG_OPCODE_RIGIDBODY_REBUILD);
/* do-sim operation */
// XXX: what happens if we need to split into several groups?
OperationDepsNode *sim_node = add_operation_node(
&scene->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(BKE_rigidbody_eval_simulation, _1, scene_cow),
DEG_OPCODE_RIGIDBODY_SIM);
/* XXX: For now, the sim node is the only one that really matters here.
* If any other sims get added later, we may have to remove these hacks...
*/
sim_node->owner->entry_operation = sim_node;
sim_node->owner->exit_operation = sim_node;
/* objects - simulation participants */
if (rbw->group) {
LISTBASE_FOREACH (Base *, base, &rbw->group->view_layer->object_bases) {
Object *object = base->object;
if (!object || (object->type != OB_MESH))
continue;
/* 2) create operation for flushing results */
/* object's transform component - where the rigidbody operation
* lives. */
add_operation_node(&object->id, DEG_NODE_TYPE_TRANSFORM,
function_bind(
BKE_rigidbody_object_sync_transforms,
_1,
scene_cow,
get_cow_datablock(object)),
DEG_OPCODE_RIGIDBODY_TRANSFORM_COPY);
}
}
}
void DepsgraphNodeBuilder::build_particles(Object *object)
{
/**
* Particle Systems Nodes
* ======================
*
* There are two types of nodes associated with representing
* particle systems:
* 1) Component (EVAL_PARTICLES) - This is the particle-system
* evaluation context for an object. It acts as the container
* for all the nodes associated with a particular set of particle
* systems.
* 2) Particle System Eval Operation - This operation node acts as a
* blackbox evaluation step for one particle system referenced by
* the particle systems stack. All dependencies link to this operation.
*/
/* Component for all particle systems. */
ComponentDepsNode *psys_comp =
add_component_node(&object->id, DEG_NODE_TYPE_EVAL_PARTICLES);
/* TODO(sergey): Need to get COW of PSYS. */
Scene *scene_cow = get_cow_datablock(scene_);
Object *ob_cow = get_cow_datablock(object);
add_operation_node(psys_comp,
function_bind(BKE_particle_system_eval_init,
_1,
scene_cow,
ob_cow),
DEG_OPCODE_PARTICLE_SYSTEM_EVAL_INIT);
/* Build all particle systems. */
LISTBASE_FOREACH (ParticleSystem *, psys, &object->particlesystem) {
ParticleSettings *part = psys->part;
/* Build particle settings operations.
*
* NOTE: The call itself ensures settings are only build once.
*/
build_particle_settings(part);
/* Particle system evaluation. */
add_operation_node(psys_comp,
NULL,
DEG_OPCODE_PARTICLE_SYSTEM_EVAL,
psys->name);
/* Visualization of particle system. */
switch (part->ren_as) {
case PART_DRAW_OB:
if (part->dup_ob != NULL) {
build_object(-1,
part->dup_ob,
DEG_ID_LINKED_INDIRECTLY);
}
break;
case PART_DRAW_GR:
if (part->dup_group != NULL) {
build_group(part->dup_group);
}
break;
}
}
/* TODO(sergey): Do we need a point cache operations here? */
add_operation_node(&object->id,
DEG_NODE_TYPE_CACHE,
function_bind(BKE_ptcache_object_reset,
scene_cow,
ob_cow,
PTCACHE_RESET_DEPSGRAPH),
DEG_OPCODE_POINT_CACHE_RESET);
}
void DepsgraphNodeBuilder::build_particle_settings(ParticleSettings *part) {
if (built_map_.checkIsBuiltAndTag(part)) {
return;
}
/* Animation data. */
build_animdata(&part->id);
/* Parameters change. */
add_operation_node(&part->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PARTICLE_SETTINGS_EVAL);
}
void DepsgraphNodeBuilder::build_cloth(Object *object)
{
Scene *scene_cow = get_cow_datablock(scene_);
Object *object_cow = get_cow_datablock(object);
add_operation_node(&object->id,
DEG_NODE_TYPE_CACHE,
function_bind(BKE_object_eval_cloth,
_1,
scene_cow,
object_cow),
DEG_OPCODE_GEOMETRY_CLOTH_MODIFIER);
}
/* Shapekeys */
void DepsgraphNodeBuilder::build_shapekeys(Key *key)
{
build_animdata(&key->id);
add_operation_node(&key->id,
DEG_NODE_TYPE_GEOMETRY,
NULL,
DEG_OPCODE_GEOMETRY_SHAPEKEY);
}
/* ObData Geometry Evaluation */
// XXX: what happens if the datablock is shared!
void DepsgraphNodeBuilder::build_obdata_geom(Object *object)
{
OperationDepsNode *op_node;
Scene *scene_cow = get_cow_datablock(scene_);
Object *object_cow = get_cow_datablock(object);
/* Temporary uber-update node, which does everything.
* It is for the being we're porting old dependencies into the new system.
* We'll get rid of this node as soon as all the granular update functions
* are filled in.
*
* TODO(sergey): Get rid of this node.
*/
op_node = add_operation_node(&object->id,
DEG_NODE_TYPE_GEOMETRY,
function_bind(BKE_object_eval_uber_data,
_1,
scene_cow,
object_cow),
DEG_OPCODE_GEOMETRY_UBEREVAL);
op_node->set_as_exit();
op_node = add_operation_node(&object->id,
DEG_NODE_TYPE_GEOMETRY,
NULL,
DEG_OPCODE_PLACEHOLDER,
"Eval Init");
op_node->set_as_entry();
// TODO: "Done" operation
/* Cloth modifier. */
LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
if (md->type == eModifierType_Cloth) {
build_cloth(object);
}
}
/* materials */
if (object->totcol != 0) {
if (object->type == OB_MESH) {
add_operation_node(&object->id,
DEG_NODE_TYPE_SHADING,
function_bind(BKE_object_eval_update_shading,
_1,
object_cow),
DEG_OPCODE_SHADING);
}
for (int a = 1; a <= object->totcol; a++) {
Material *ma = give_current_material(object, a);
if (ma != NULL) {
build_material(ma);
}
}
}
/* geometry collision */
if (ELEM(object->type, OB_MESH, OB_CURVE, OB_LATTICE)) {
// add geometry collider relations
}
ID *obdata = (ID *)object->data;
if (built_map_.checkIsBuiltAndTag(obdata)) {
return;
}
/* Make sure we've got an ID node before requesting CoW pointer. */
(void) add_id_node((ID *)obdata);
ID *obdata_cow = get_cow_id(obdata);
/* ShapeKeys */
Key *key = BKE_key_from_object(object);
if (key) {
build_shapekeys(key);
}
build_animdata(obdata);
/* Nodes for result of obdata's evaluation, and geometry
* evaluation on object.
*/
switch (object->type) {
case OB_MESH:
{
//Mesh *me = (Mesh *)object->data;
/* evaluation operations */
op_node = add_operation_node(obdata,
DEG_NODE_TYPE_GEOMETRY,
function_bind(BKE_mesh_eval_geometry,
_1,
(Mesh *)obdata_cow),
DEG_OPCODE_PLACEHOLDER,
"Geometry Eval");
op_node->set_as_entry();
break;
}
case OB_MBALL:
{
Object *mom = BKE_mball_basis_find(scene_, object);
/* NOTE: Only the motherball gets evaluated, it's children are
* having empty placeholders for the correct relations being built.
*/
if (mom == object) {
/* metaball evaluation operations */
op_node = add_operation_node(obdata,
DEG_NODE_TYPE_GEOMETRY,
function_bind(
BKE_mball_eval_geometry,
_1,
(MetaBall *)obdata_cow),
DEG_OPCODE_PLACEHOLDER,
"Geometry Eval");
}
else {
op_node = add_operation_node(obdata,
DEG_NODE_TYPE_GEOMETRY,
NULL,
DEG_OPCODE_PLACEHOLDER,
"Geometry Eval");
op_node->set_as_entry();
}
break;
}
case OB_CURVE:
case OB_SURF:
case OB_FONT:
{
/* Curve/nurms evaluation operations. */
/* - calculate curve geometry (including path) */
op_node = add_operation_node(obdata,
DEG_NODE_TYPE_GEOMETRY,
function_bind(BKE_curve_eval_geometry,
_1,
(Curve *)obdata_cow),
DEG_OPCODE_PLACEHOLDER,
"Geometry Eval");
op_node->set_as_entry();
/* Make sure objects used for bevel.taper are in the graph.
* NOTE: This objects might be not linked to the scene.
*/
Curve *cu = (Curve *)obdata;
if (cu->bevobj != NULL) {
build_object(-1, cu->bevobj, DEG_ID_LINKED_INDIRECTLY);
}
if (cu->taperobj != NULL) {
build_object(-1, cu->taperobj, DEG_ID_LINKED_INDIRECTLY);
}
if (object->type == OB_FONT && cu->textoncurve != NULL) {
build_object(-1, cu->textoncurve, DEG_ID_LINKED_INDIRECTLY);
}
break;
}
case OB_LATTICE:
{
/* Lattice evaluation operations. */
op_node = add_operation_node(obdata,
DEG_NODE_TYPE_GEOMETRY,
function_bind(BKE_lattice_eval_geometry,
_1,
(Lattice *)obdata_cow),
DEG_OPCODE_PLACEHOLDER,
"Geometry Eval");
op_node->set_as_entry();
break;
}
}
op_node = add_operation_node(obdata, DEG_NODE_TYPE_GEOMETRY, NULL,
DEG_OPCODE_PLACEHOLDER, "Eval Done");
op_node->set_as_exit();
/* Parameters for driver sources. */
add_operation_node(obdata,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PARAMETERS_EVAL);
/* Batch cache. */
add_operation_node(obdata,
DEG_NODE_TYPE_BATCH_CACHE,
function_bind(BKE_object_data_select_update,
_1,
obdata_cow),
DEG_OPCODE_GEOMETRY_SELECT_UPDATE);
}
/* Cameras */
void DepsgraphNodeBuilder::build_camera(Object *object)
{
/* Object data. */
/* TODO: Link scene-camera links in somehow... */
Camera *camera = (Camera *)object->data;
if (built_map_.checkIsBuiltAndTag(camera)) {
return;
}
build_animdata(&camera->id);
add_operation_node(&camera->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PARAMETERS_EVAL);
}
/* Lamps */
void DepsgraphNodeBuilder::build_lamp(Object *object)
{
/* Object data. */
Lamp *lamp = (Lamp *)object->data;
if (built_map_.checkIsBuiltAndTag(lamp)) {
return;
}
build_animdata(&lamp->id);
add_operation_node(&lamp->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PARAMETERS_EVAL);
/* lamp's nodetree */
build_nodetree(lamp->nodetree);
}
void DepsgraphNodeBuilder::build_nodetree(bNodeTree *ntree)
{
if (ntree == NULL) {
return;
}
if (built_map_.checkIsBuiltAndTag(ntree)) {
return;
}
/* nodetree itself */
add_id_node(&ntree->id);
bNodeTree *ntree_cow = get_cow_datablock(ntree);
/* Animation, */
build_animdata(&ntree->id);
/* Shading update. */
add_operation_node(&ntree->id,
DEG_NODE_TYPE_SHADING,
NULL,
DEG_OPCODE_MATERIAL_UPDATE);
/* NOTE: We really pass original and CoW node trees here, this is how the
* callback works. Ideally we need to find a better way for that.
*/
add_operation_node(&ntree->id,
DEG_NODE_TYPE_SHADING_PARAMETERS,
function_bind(BKE_nodetree_shading_params_eval,
_1,
ntree_cow,
ntree),
DEG_OPCODE_MATERIAL_UPDATE);
/* nodetree's nodes... */
LISTBASE_FOREACH (bNode *, bnode, &ntree->nodes) {
ID *id = bnode->id;
if (id == NULL) {
continue;
}
ID_Type id_type = GS(id->name);
if (id_type == ID_MA) {
build_material((Material *)id);
}
else if (id_type == ID_TE) {
build_texture((Tex *)id);
}
else if (id_type == ID_IM) {
build_image((Image *)id);
}
else if (id_type == ID_OB) {
build_object(-1, (Object *)id, DEG_ID_LINKED_INDIRECTLY);
}
else if (id_type == ID_SCE) {
/* Scenes are used by compositor trees, and handled by render
* pipeline. No need to build dependencies for them here.
*/
}
else if (id_type == ID_TXT) {
/* Ignore script nodes. */
}
else if (bnode->type == NODE_GROUP) {
bNodeTree *group_ntree = (bNodeTree *)id;
build_nodetree(group_ntree);
}
else {
BLI_assert(!"Unknown ID type used for node");
}
}
// TODO: link from nodetree to owner_component?
}
/* Recursively build graph for material */
void DepsgraphNodeBuilder::build_material(Material *material)
{
if (built_map_.checkIsBuiltAndTag(material)) {
return;
}
/* Material itself. */
add_id_node(&material->id);
Material *material_cow = get_cow_datablock(material);
/* Shading update. */
add_operation_node(&material->id,
DEG_NODE_TYPE_SHADING,
function_bind(BKE_material_eval,
_1,
material_cow),
DEG_OPCODE_MATERIAL_UPDATE);
/* Material animation. */
build_animdata(&material->id);
/* Material's nodetree. */
build_nodetree(material->nodetree);
}
/* Recursively build graph for texture */
void DepsgraphNodeBuilder::build_texture(Tex *texture)
{
if (built_map_.checkIsBuiltAndTag(texture)) {
return;
}
/* Texture itself. */
build_animdata(&texture->id);
/* Texture's nodetree. */
build_nodetree(texture->nodetree);
/* Special cases for different IDs which texture uses. */
if (texture->type == TEX_IMAGE) {
if (texture->ima != NULL) {
build_image(texture->ima);
}
}
/* Placeholder so we can add relations and tag ID node for update. */
add_operation_node(&texture->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PLACEHOLDER);
}
void DepsgraphNodeBuilder::build_image(Image *image) {
if (built_map_.checkIsBuiltAndTag(image)) {
return;
}
/* Placeholder so we can add relations and tag ID node for update. */
add_operation_node(&image->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PLACEHOLDER,
"Image Eval");
}
void DepsgraphNodeBuilder::build_compositor(Scene *scene)
{
/* For now, just a plain wrapper? */
// TODO: create compositing component?
// XXX: component type undefined!
//graph->get_node(&scene->id, NULL, DEG_NODE_TYPE_COMPOSITING, NULL);
/* for now, nodetrees are just parameters; compositing occurs in internals
* of renderer...
*/
add_component_node(&scene->id, DEG_NODE_TYPE_PARAMETERS);
build_nodetree(scene->nodetree);
}
void DepsgraphNodeBuilder::build_gpencil(bGPdata *gpd)
{
ID *gpd_id = &gpd->id;
/* TODO(sergey): what about multiple users of same datablock? This should
* only get added once.
*/
/* The main reason Grease Pencil is included here is because the animation
* (and drivers) need to be hosted somewhere.
*/
build_animdata(gpd_id);
}
void DepsgraphNodeBuilder::build_cachefile(CacheFile *cache_file)
{
ID *cache_file_id = &cache_file->id;
/* Animation, */
build_animdata(cache_file_id);
/* Cache evaluation itself. */
add_operation_node(cache_file_id, DEG_NODE_TYPE_CACHE, NULL,
DEG_OPCODE_PLACEHOLDER, "Cache File Update");
}
void DepsgraphNodeBuilder::build_mask(Mask *mask)
{
ID *mask_id = &mask->id;
Mask *mask_cow = get_cow_datablock(mask);
/* F-Curve based animation. */
build_animdata(mask_id);
/* Animation based on mask's shapes. */
add_operation_node(mask_id,
DEG_NODE_TYPE_ANIMATION,
function_bind(BKE_mask_eval_animation, _1, mask_cow),
DEG_OPCODE_MASK_ANIMATION);
/* Final mask evaluation. */
add_operation_node(mask_id,
DEG_NODE_TYPE_PARAMETERS,
function_bind(BKE_mask_eval_update, _1, mask_cow),
DEG_OPCODE_MASK_EVAL);
}
void DepsgraphNodeBuilder::build_movieclip(MovieClip *clip)
{
ID *clip_id = &clip->id;
MovieClip *clip_cow = get_cow_datablock(clip);
/* Animation. */
build_animdata(clip_id);
/* Movie clip evaluation. */
add_operation_node(clip_id,
DEG_NODE_TYPE_PARAMETERS,
function_bind(BKE_movieclip_eval_update, _1, clip_cow),
DEG_OPCODE_MOVIECLIP_EVAL);
}
void DepsgraphNodeBuilder::build_lightprobe(Object *object)
{
LightProbe *probe = (LightProbe *)object->data;
if (built_map_.checkIsBuiltAndTag(probe)) {
return;
}
/* Placeholder so we can add relations and tag ID node for update. */
add_operation_node(&probe->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PLACEHOLDER,
"LightProbe Eval");
add_operation_node(&object->id,
DEG_NODE_TYPE_PARAMETERS,
NULL,
DEG_OPCODE_PLACEHOLDER,
"LightProbe Eval");
build_animdata(&probe->id);
}
/* **** ID traversal callbacks functions **** */
void DepsgraphNodeBuilder::modifier_walk(void *user_data,
struct Object * /*object*/,
struct ID **idpoin,
int /*cb_flag*/)
{
BuilderWalkUserData *data = (BuilderWalkUserData *)user_data;
ID *id = *idpoin;
if (id == NULL) {
return;
}
switch (GS(id->name)) {
case ID_OB:
data->builder->build_object(-1,
(Object *)id,
DEG_ID_LINKED_INDIRECTLY);
break;
case ID_TE:
data->builder->build_texture((Tex *)id);
break;
default:
/* pass */
break;
}
}
void DepsgraphNodeBuilder::constraint_walk(bConstraint * /*con*/,
ID **idpoin,
bool /*is_reference*/,
void *user_data)
{
BuilderWalkUserData *data = (BuilderWalkUserData *)user_data;
ID *id = *idpoin;
if (id == NULL) {
return;
}
switch (GS(id->name)) {
case ID_OB:
data->builder->build_object(-1,
(Object *)id,
DEG_ID_LINKED_INDIRECTLY);
break;
default:
/* pass */
break;
}
}
} // namespace DEG
Reference in New Issue View Git Blame Copy Permalink