intern/cycles/graph/node_type.cpp

   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 #include "graph/node_type.h"
  18 #include "util/util_foreach.h"
  19 #include "util/util_transform.h"
  20
  21 CCL_NAMESPACE_BEGIN
  22
  23 /* Node Socket Type */
  24
  25 size_t SocketType::size() const
  26 {
  27         return size(type);
  28 }
  29
  30 bool SocketType::is_array() const
  31 {
  32         return (type >= BOOLEAN_ARRAY);
  33 }
  34
  35 size_t SocketType::size(Type type)
  36 {
  37         switch(type)
  38         {
  39                 case UNDEFINED: return 0;
  40
  41                 case BOOLEAN: return sizeof(bool);
  42                 case FLOAT: return sizeof(float);
  43                 case INT: return sizeof(int);
  44                 case UINT: return sizeof(uint);
  45                 case COLOR: return sizeof(float3);
  46                 case VECTOR: return sizeof(float3);
  47                 case POINT: return sizeof(float3);
  48                 case NORMAL: return sizeof(float3);
  49                 case POINT2: return sizeof(float2);
  50                 case CLOSURE: return 0;
  51                 case STRING: return sizeof(ustring);
  52                 case ENUM: return sizeof(int);
  53                 case TRANSFORM: return sizeof(Transform);
  54                 case NODE: return sizeof(void*);
  55
  56                 case BOOLEAN_ARRAY: return sizeof(array<bool>);
  57                 case FLOAT_ARRAY: return sizeof(array<float>);
  58                 case INT_ARRAY: return sizeof(array<int>);
  59                 case COLOR_ARRAY: return sizeof(array<float3>);
  60                 case VECTOR_ARRAY: return sizeof(array<float3>);
  61                 case POINT_ARRAY: return sizeof(array<float3>);
  62                 case NORMAL_ARRAY: return sizeof(array<float3>);
  63                 case POINT2_ARRAY: return sizeof(array<float2>);
  64                 case STRING_ARRAY: return sizeof(array<ustring>);
  65                 case TRANSFORM_ARRAY: return sizeof(array<Transform>);
  66                 case NODE_ARRAY: return sizeof(array<void*>);
  67         }
  68
  69         assert(0);
  70         return 0;
  71 }
  72
  73 size_t SocketType::max_size()
  74 {
  75         return sizeof(Transform);
  76 }
  77
  78 void *SocketType::zero_default_value()
  79 {
  80         static Transform zero_transform = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
  81         return &zero_transform;
  82 }
  83
  84 ustring SocketType::type_name(Type type)
  85 {
  86         static ustring names[] = {
  87                 ustring("undefined"),
  88
  89                 ustring("boolean"),
  90                 ustring("float"),
  91                 ustring("int"),
  92                 ustring("uint"),
  93                 ustring("color"),
  94                 ustring("vector"),
  95                 ustring("point"),
  96                 ustring("normal"),
  97                 ustring("point2"),
  98                 ustring("closure"),
  99                 ustring("string"),
 100                 ustring("enum"),
 101                 ustring("transform"),
 102                 ustring("node"),
 103
 104                 ustring("array_boolean"),
 105                 ustring("array_float"),
 106                 ustring("array_int"),
 107                 ustring("array_color"),
 108                 ustring("array_vector"),
 109                 ustring("array_point"),
 110                 ustring("array_normal"),
 111                 ustring("array_point2"),
 112                 ustring("array_string"),
 113                 ustring("array_transform"),
 114                 ustring("array_node")};
 115
 116         return names[(int)type];
 117 }
 118
 119 bool SocketType::is_float3(Type type)
 120 {
 121         return (type == COLOR || type == VECTOR || type == POINT || type == NORMAL);
 122 }
 123
 124 /* Node Type */
 125
 126 NodeType::NodeType(Type type_)
 127 : type(type_)
 128 {
 129 }
 130
 131 NodeType::~NodeType()
 132 {
 133 }
 134
 135 void NodeType::register_input(ustring name, ustring ui_name, SocketType::Type type, int struct_offset,
 136                               const void *default_value, const NodeEnum *enum_values,
 137                                                           const NodeType **node_type, int flags, int extra_flags)
 138 {
 139         SocketType socket;
 140         socket.name = name;
 141         socket.ui_name = ui_name;
 142         socket.type = type;
 143         socket.struct_offset = struct_offset;
 144         socket.default_value = default_value;
 145         socket.enum_values = enum_values;
 146         socket.node_type = node_type;
 147         socket.flags = flags | extra_flags;
 148         inputs.push_back(socket);
 149 }
 150
 151 void NodeType::register_output(ustring name, ustring ui_name, SocketType::Type type)
 152 {
 153         SocketType socket;
 154         socket.name = name;
 155         socket.ui_name = ui_name;
 156         socket.type = type;
 157         socket.struct_offset = 0;
 158         socket.default_value = NULL;
 159         socket.enum_values = NULL;
 160         socket.node_type = NULL;
 161         socket.flags = SocketType::LINKABLE;
 162         outputs.push_back(socket);
 163 }
 164
 165 const SocketType *NodeType::find_input(ustring name) const
 166 {
 167         foreach(const SocketType& socket, inputs) {
 168                 if(socket.name == name) {
 169                         return &socket;
 170                 }
 171         }
 172
 173         return NULL;
 174 }
 175
 176 const SocketType *NodeType::find_output(ustring name) const
 177 {
 178         foreach(const SocketType& socket, outputs) {
 179                 if(socket.name == name) {
 180                         return &socket;
 181                 }
 182         }
 183
 184         return NULL;
 185 }
 186
 187 /* Node Type Registry */
 188
 189 unordered_map<ustring, NodeType, ustringHash>& NodeType::types()
 190 {
 191         static unordered_map<ustring, NodeType, ustringHash> _types;
 192         return _types;
 193 }
 194
 195 NodeType *NodeType::add(const char *name_, CreateFunc create_, Type type_)
 196 {
 197         ustring name(name_);
 198
 199         if(types().find(name) != types().end()) {
 200                 fprintf(stderr, "Node type %s registered twice!\n", name_);
 201                 assert(0);
 202                 return NULL;
 203         }
 204
 205         types()[name] = NodeType(type_);
 206
 207         NodeType *type = &types()[name];
 208         type->name = name;
 209         type->create = create_;
 210         return type;
 211 }
 212
 213 const NodeType *NodeType::find(ustring name)
 214 {
 215         unordered_map<ustring, NodeType, ustringHash>::iterator it = types().find(name);
 216         return (it == types().end()) ? NULL : &it->second;
 217 }
 218
 219 CCL_NAMESPACE_END
 220