intern/cycles/render/graph.h

   1 /*
   2  * Copyright 2011-2016 Blender Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __GRAPH_H__
  18 #define __GRAPH_H__
  19
  20 #include "graph/node.h"
  21 #include "graph/node_type.h"
  22
  23 #include "kernel/kernel_types.h"
  24
  25 #include "util/util_list.h"
  26 #include "util/util_map.h"
  27 #include "util/util_param.h"
  28 #include "util/util_set.h"
  29 #include "util/util_types.h"
  30 #include "util/util_vector.h"
  31
  32 CCL_NAMESPACE_BEGIN
  33
  34 class AttributeRequestSet;
  35 class Scene;
  36 class Shader;
  37 class ShaderInput;
  38 class ShaderOutput;
  39 class ShaderNode;
  40 class ShaderGraph;
  41 class SVMCompiler;
  42 class OSLCompiler;
  43 class OutputNode;
  44 class ConstantFolder;
  45 class MD5Hash;
  46
  47 /* Bump
  48  *
  49  * For bump mapping, a node may be evaluated multiple times, using different
  50  * samples to reconstruct the normal, this indicates the sample position */
  51
  52 enum ShaderBump {
  53         SHADER_BUMP_NONE,
  54         SHADER_BUMP_CENTER,
  55         SHADER_BUMP_DX,
  56         SHADER_BUMP_DY
  57 };
  58
  59 /* Identifiers for some special node types.
  60  *
  61  * The graph needs to identify these in the clean function.
  62  * Cannot use dynamic_cast, as this is disabled for OSL. */
  63
  64 enum ShaderNodeSpecialType {
  65         SHADER_SPECIAL_TYPE_NONE,
  66         SHADER_SPECIAL_TYPE_PROXY,
  67         SHADER_SPECIAL_TYPE_AUTOCONVERT,
  68         SHADER_SPECIAL_TYPE_GEOMETRY,
  69         SHADER_SPECIAL_TYPE_SCRIPT,
  70         SHADER_SPECIAL_TYPE_IMAGE_SLOT,
  71         SHADER_SPECIAL_TYPE_CLOSURE,
  72         SHADER_SPECIAL_TYPE_COMBINE_CLOSURE,
  73         SHADER_SPECIAL_TYPE_OUTPUT,
  74         SHADER_SPECIAL_TYPE_BUMP,
  75 };
  76
  77 /* Input
  78  *
  79  * Input socket for a shader node. May be linked to an output or not. If not
  80  * linked, it will either get a fixed default value, or e.g. a texture
  81  * coordinate. */
  82
  83 class ShaderInput {
  84 public:
  85         ShaderInput(const SocketType& socket_type_, ShaderNode* parent_)
  86         : socket_type(socket_type_), parent(parent_), link(NULL), stack_offset(SVM_STACK_INVALID)
  87         {}
  88
  89         ustring name() { return socket_type.ui_name; }
  90         int flags() { return socket_type.flags; }
  91         SocketType::Type type() { return socket_type.type; }
  92
  93         void set(float f) { ((Node*)parent)->set(socket_type, f); }
  94         void set(float3 f) { ((Node*)parent)->set(socket_type, f); }
  95
  96         const SocketType& socket_type;
  97         ShaderNode *parent;
  98         ShaderOutput *link;
  99         int stack_offset; /* for SVM compiler */
 100 };
 101
 102 /* Output
 103  *
 104  * Output socket for a shader node. */
 105
 106 class ShaderOutput {
 107 public:
 108         ShaderOutput(const SocketType& socket_type_, ShaderNode* parent_)
 109         : socket_type(socket_type_), parent(parent_), stack_offset(SVM_STACK_INVALID)
 110         {}
 111
 112         ustring name() { return socket_type.ui_name; }
 113         SocketType::Type type() { return socket_type.type; }
 114
 115         const SocketType& socket_type;
 116         ShaderNode *parent;
 117         vector<ShaderInput*> links;
 118         int stack_offset; /* for SVM compiler */
 119 };
 120
 121 /* Node
 122  *
 123  * Shader node in graph, with input and output sockets. This is the virtual
 124  * base class for all node types. */
 125
 126 class ShaderNode : public Node {
 127 public:
 128         explicit ShaderNode(const NodeType *type);
 129         virtual ~ShaderNode();
 130
 131         void create_inputs_outputs(const NodeType *type);
 132
 133         ShaderInput *input(const char *name);
 134         ShaderOutput *output(const char *name);
 135         ShaderInput *input(ustring name);
 136         ShaderOutput *output(ustring name);
 137
 138         virtual ShaderNode *clone() const = 0;
 139         virtual void attributes(Shader *shader, AttributeRequestSet *attributes);
 140         virtual void compile(SVMCompiler& compiler) = 0;
 141         virtual void compile(OSLCompiler& compiler) = 0;
 142
 143         /* ** Node optimization ** */
 144         /* Check whether the node can be replaced with single constant. */
 145         virtual void constant_fold(const ConstantFolder& /*folder*/) {}
 146
 147         /* Simplify settings used by artists to the ones which are simpler to
 148          * evaluate in the kernel but keep the final result unchanged.
 149          */
 150         virtual void simplify_settings(Scene * /*scene*/) {};
 151
 152         virtual bool has_surface_emission() { return false; }
 153         virtual bool has_surface_transparent() { return false; }
 154         virtual bool has_surface_bssrdf() { return false; }
 155         virtual bool has_bump() { return false; }
 156         virtual bool has_bssrdf_bump() { return false; }
 157         virtual bool has_spatial_varying() { return false; }
 158         virtual bool has_object_dependency() { return false; }
 159         virtual bool has_attribute_dependency() { return false; }
 160         virtual bool has_integrator_dependency() { return false; }
 161         virtual bool has_volume_support() { return false; }
 162         virtual bool has_raytrace() { return false; }
 163         vector<ShaderInput*> inputs;
 164         vector<ShaderOutput*> outputs;
 165
 166         int id; /* index in graph node array */
 167         ShaderBump bump; /* for bump mapping utility */
 168
 169         ShaderNodeSpecialType special_type;     /* special node type */
 170
 171         /* ** Selective nodes compilation ** */
 172
 173         /* TODO(sergey): More explicitly mention in the function names
 174          * that those functions are for selective compilation only?
 175          */
 176
 177         /* Nodes are split into several groups, group of level 0 contains
 178          * nodes which are most commonly used, further levels are extension
 179          * of previous one and includes less commonly used nodes.
 180          */
 181         virtual int get_group() { return NODE_GROUP_LEVEL_0; }
 182
 183         /* Node feature are used to disable huge nodes inside the group,
 184          * so it's possible to disable huge nodes inside of the required
 185          * nodes group.
 186          */
 187         virtual int get_feature() { return bump == SHADER_BUMP_NONE ? 0 : NODE_FEATURE_BUMP; }
 188
 189         /* Get closure ID to which the node compiles into. */
 190         virtual ClosureType get_closure_type() { return CLOSURE_NONE_ID; }
 191
 192         /* Check whether settings of the node equals to another one.
 193          *
 194          * This is mainly used to check whether two nodes can be merged
 195          * together. Meaning, runtime stuff like node id and unbound slots
 196          * will be ignored for comparison.
 197          *
 198          * NOTE: If some node can't be de-duplicated for whatever reason it
 199          * is to be handled in the subclass.
 200          */
 201         virtual bool equals(const ShaderNode& other);
 202 };
 203
 204
 205 /* Node definition utility macros */
 206
 207 #define SHADER_NODE_CLASS(type) \
 208         NODE_DECLARE \
 209         type(); \
 210         virtual ShaderNode *clone() const { return new type(*this); } \
 211         virtual void compile(SVMCompiler& compiler); \
 212         virtual void compile(OSLCompiler& compiler); \
 213
 214 #define SHADER_NODE_NO_CLONE_CLASS(type) \
 215         NODE_DECLARE \
 216         type(); \
 217         virtual void compile(SVMCompiler& compiler); \
 218         virtual void compile(OSLCompiler& compiler); \
 219
 220 #define SHADER_NODE_BASE_CLASS(type) \
 221         virtual ShaderNode *clone() const { return new type(*this); } \
 222         virtual void compile(SVMCompiler& compiler); \
 223         virtual void compile(OSLCompiler& compiler); \
 224
 225 class ShaderNodeIDComparator
 226 {
 227 public:
 228         bool operator()(const ShaderNode *n1, const ShaderNode *n2) const
 229         {
 230                 return n1->id < n2->id;
 231         }
 232 };
 233
 234 typedef set<ShaderNode*, ShaderNodeIDComparator> ShaderNodeSet;
 235 typedef map<ShaderNode*, ShaderNode*, ShaderNodeIDComparator> ShaderNodeMap;
 236
 237 /* Graph
 238  *
 239  * Shader graph of nodes. Also does graph manipulations for default inputs,
 240  * bump mapping from displacement, and possibly other things in the future. */
 241
 242 class ShaderGraph {
 243 public:
 244         list<ShaderNode*> nodes;
 245         size_t num_node_ids;
 246         bool finalized;
 247         bool simplified;
 248         string displacement_hash;
 249
 250         ShaderGraph();
 251         ~ShaderGraph();
 252
 253         ShaderNode *add(ShaderNode *node);
 254         OutputNode *output();
 255
 256         void connect(ShaderOutput *from, ShaderInput *to);
 257         void disconnect(ShaderOutput *from);
 258         void disconnect(ShaderInput *to);
 259         void relink(ShaderNode *node, ShaderOutput *from, ShaderOutput *to);
 260
 261         void remove_proxy_nodes();
 262         void compute_displacement_hash();
 263         void simplify(Scene *scene);
 264         void finalize(Scene *scene,
 265                       bool do_bump = false,
 266                       bool do_simplify = false,
 267                       bool bump_in_object_space = false);
 268
 269         int get_num_closures();
 270
 271         void dump_graph(const char *filename);
 272
 273 protected:
 274         typedef pair<ShaderNode* const, ShaderNode*> NodePair;
 275
 276         void find_dependencies(ShaderNodeSet& dependencies, ShaderInput *input);
 277         void clear_nodes();
 278         void copy_nodes(ShaderNodeSet& nodes, ShaderNodeMap& nnodemap);
 279
 280         void break_cycles(ShaderNode *node, vector<bool>& visited, vector<bool>& on_stack);
 281         void bump_from_displacement(bool use_object_space);
 282         void refine_bump_nodes();
 283         void default_inputs(bool do_osl);
 284         void transform_multi_closure(ShaderNode *node, ShaderOutput *weight_out, bool volume);
 285
 286         /* Graph simplification routines. */
 287         void clean(Scene *scene);
 288         void constant_fold(Scene *scene);
 289         void simplify_settings(Scene *scene);
 290         void deduplicate_nodes();
 291         void verify_volume_output();
 292 };
 293
 294 CCL_NAMESPACE_END
 295
 296 #endif  /* __GRAPH_H__ */