diff options
Diffstat (limited to 'intern/cycles/render/nodes.cpp')
| -rw-r--r-- | intern/cycles/render/nodes.cpp | 7170 |
1 files changed, 0 insertions, 7170 deletions
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp deleted file mode 100644 index d775859d24d..00000000000 --- a/intern/cycles/render/nodes.cpp +++ /dev/null @@ -1,7170 +0,0 @@ -/* - * Copyright 2011-2013 Blender Foundation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "render/nodes.h" -#include "render/colorspace.h" -#include "render/constant_fold.h" -#include "render/film.h" -#include "render/image.h" -#include "render/image_sky.h" -#include "render/integrator.h" -#include "render/light.h" -#include "render/mesh.h" -#include "render/osl.h" -#include "render/scene.h" -#include "render/svm.h" - -#include "sky_model.h" - -#include "util/util_foreach.h" -#include "util/util_logging.h" -#include "util/util_transform.h" - -#include "kernel/svm/svm_color_util.h" -#include "kernel/svm/svm_mapping_util.h" -#include "kernel/svm/svm_math_util.h" -#include "kernel/svm/svm_ramp_util.h" - -CCL_NAMESPACE_BEGIN - -/* Texture Mapping */ - -#define TEXTURE_MAPPING_DEFINE(TextureNode) \ - SOCKET_POINT(tex_mapping.translation, "Translation", zero_float3()); \ - SOCKET_VECTOR(tex_mapping.rotation, "Rotation", zero_float3()); \ - SOCKET_VECTOR(tex_mapping.scale, "Scale", one_float3()); \ -\ - SOCKET_VECTOR(tex_mapping.min, "Min", make_float3(-FLT_MAX, -FLT_MAX, -FLT_MAX)); \ - SOCKET_VECTOR(tex_mapping.max, "Max", make_float3(FLT_MAX, FLT_MAX, FLT_MAX)); \ - SOCKET_BOOLEAN(tex_mapping.use_minmax, "Use Min Max", false); \ -\ - static NodeEnum mapping_axis_enum; \ - mapping_axis_enum.insert("none", TextureMapping::NONE); \ - mapping_axis_enum.insert("x", TextureMapping::X); \ - mapping_axis_enum.insert("y", TextureMapping::Y); \ - mapping_axis_enum.insert("z", TextureMapping::Z); \ - SOCKET_ENUM(tex_mapping.x_mapping, "x_mapping", mapping_axis_enum, TextureMapping::X); \ - SOCKET_ENUM(tex_mapping.y_mapping, "y_mapping", mapping_axis_enum, TextureMapping::Y); \ - SOCKET_ENUM(tex_mapping.z_mapping, "z_mapping", mapping_axis_enum, TextureMapping::Z); \ -\ - static NodeEnum mapping_type_enum; \ - mapping_type_enum.insert("point", TextureMapping::POINT); \ - mapping_type_enum.insert("texture", TextureMapping::TEXTURE); \ - mapping_type_enum.insert("vector", TextureMapping::VECTOR); \ - mapping_type_enum.insert("normal", TextureMapping::NORMAL); \ - SOCKET_ENUM(tex_mapping.type, "Type", mapping_type_enum, TextureMapping::TEXTURE); \ -\ - static NodeEnum mapping_projection_enum; \ - mapping_projection_enum.insert("flat", TextureMapping::FLAT); \ - mapping_projection_enum.insert("cube", TextureMapping::CUBE); \ - mapping_projection_enum.insert("tube", TextureMapping::TUBE); \ - mapping_projection_enum.insert("sphere", TextureMapping::SPHERE); \ - SOCKET_ENUM(tex_mapping.projection, "Projection", mapping_projection_enum, TextureMapping::FLAT); - -TextureMapping::TextureMapping() -{ -} - -Transform TextureMapping::compute_transform() -{ - Transform mmat = transform_scale(zero_float3()); - - if (x_mapping != NONE) - mmat[0][x_mapping - 1] = 1.0f; - if (y_mapping != NONE) - mmat[1][y_mapping - 1] = 1.0f; - if (z_mapping != NONE) - mmat[2][z_mapping - 1] = 1.0f; - - float3 scale_clamped = scale; - - if (type == TEXTURE || type == NORMAL) { - /* keep matrix invertible */ - if (fabsf(scale.x) < 1e-5f) - scale_clamped.x = signf(scale.x) * 1e-5f; - if (fabsf(scale.y) < 1e-5f) - scale_clamped.y = signf(scale.y) * 1e-5f; - if (fabsf(scale.z) < 1e-5f) - scale_clamped.z = signf(scale.z) * 1e-5f; - } - - Transform smat = transform_scale(scale_clamped); - Transform rmat = transform_euler(rotation); - Transform tmat = transform_translate(translation); - - Transform mat; - - switch (type) { - case TEXTURE: - /* inverse transform on texture coordinate gives - * forward transform on texture */ - mat = tmat * rmat * smat; - mat = transform_inverse(mat); - break; - case POINT: - /* full transform */ - mat = tmat * rmat * smat; - break; - case VECTOR: - /* no translation for vectors */ - mat = rmat * smat; - break; - case NORMAL: - /* no translation for normals, and inverse transpose */ - mat = rmat * smat; - mat = transform_transposed_inverse(mat); - break; - } - - /* projection last */ - mat = mat * mmat; - - return mat; -} - -bool TextureMapping::skip() -{ - if (translation != zero_float3()) - return false; - if (rotation != zero_float3()) - return false; - if (scale != one_float3()) - return false; - - if (x_mapping != X || y_mapping != Y || z_mapping != Z) - return false; - if (use_minmax) - return false; - - return true; -} - -void TextureMapping::compile(SVMCompiler &compiler, int offset_in, int offset_out) -{ - compiler.add_node(NODE_TEXTURE_MAPPING, offset_in, offset_out); - - Transform tfm = compute_transform(); - compiler.add_node(tfm.x); - compiler.add_node(tfm.y); - compiler.add_node(tfm.z); - - if (use_minmax) { - compiler.add_node(NODE_MIN_MAX, offset_out, offset_out); - compiler.add_node(float3_to_float4(min)); - compiler.add_node(float3_to_float4(max)); - } - - if (type == NORMAL) { - compiler.add_node(NODE_VECTOR_MATH, - NODE_VECTOR_MATH_NORMALIZE, - compiler.encode_uchar4(offset_out, offset_out, offset_out), - compiler.encode_uchar4(SVM_STACK_INVALID, offset_out)); - } -} - -/* Convenience function for texture nodes, allocating stack space to output - * a modified vector and returning its offset */ -int TextureMapping::compile_begin(SVMCompiler &compiler, ShaderInput *vector_in) -{ - if (!skip()) { - int offset_in = compiler.stack_assign(vector_in); - int offset_out = compiler.stack_find_offset(SocketType::VECTOR); - - compile(compiler, offset_in, offset_out); - - return offset_out; - } - - return compiler.stack_assign(vector_in); -} - -void TextureMapping::compile_end(SVMCompiler &compiler, ShaderInput *vector_in, int vector_offset) -{ - if (!skip()) { - compiler.stack_clear_offset(vector_in->type(), vector_offset); - } -} - -void TextureMapping::compile(OSLCompiler &compiler) -{ - if (!skip()) { - compiler.parameter("mapping", compute_transform()); - compiler.parameter("use_mapping", 1); - } -} - -/* Image Texture */ - -NODE_DEFINE(ImageTextureNode) -{ - NodeType *type = NodeType::add("image_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(ImageTextureNode); - - SOCKET_STRING(filename, "Filename", ustring()); - SOCKET_STRING(colorspace, "Colorspace", u_colorspace_auto); - - static NodeEnum alpha_type_enum; - alpha_type_enum.insert("auto", IMAGE_ALPHA_AUTO); - alpha_type_enum.insert("unassociated", IMAGE_ALPHA_UNASSOCIATED); - alpha_type_enum.insert("associated", IMAGE_ALPHA_ASSOCIATED); - alpha_type_enum.insert("channel_packed", IMAGE_ALPHA_CHANNEL_PACKED); - alpha_type_enum.insert("ignore", IMAGE_ALPHA_IGNORE); - SOCKET_ENUM(alpha_type, "Alpha Type", alpha_type_enum, IMAGE_ALPHA_AUTO); - - static NodeEnum interpolation_enum; - interpolation_enum.insert("closest", INTERPOLATION_CLOSEST); - interpolation_enum.insert("linear", INTERPOLATION_LINEAR); - interpolation_enum.insert("cubic", INTERPOLATION_CUBIC); - interpolation_enum.insert("smart", INTERPOLATION_SMART); - SOCKET_ENUM(interpolation, "Interpolation", interpolation_enum, INTERPOLATION_LINEAR); - - static NodeEnum extension_enum; - extension_enum.insert("periodic", EXTENSION_REPEAT); - extension_enum.insert("clamp", EXTENSION_EXTEND); - extension_enum.insert("black", EXTENSION_CLIP); - SOCKET_ENUM(extension, "Extension", extension_enum, EXTENSION_REPEAT); - - static NodeEnum projection_enum; - projection_enum.insert("flat", NODE_IMAGE_PROJ_FLAT); - projection_enum.insert("box", NODE_IMAGE_PROJ_BOX); - projection_enum.insert("sphere", NODE_IMAGE_PROJ_SPHERE); - projection_enum.insert("tube", NODE_IMAGE_PROJ_TUBE); - SOCKET_ENUM(projection, "Projection", projection_enum, NODE_IMAGE_PROJ_FLAT); - - SOCKET_FLOAT(projection_blend, "Projection Blend", 0.0f); - - SOCKET_INT_ARRAY(tiles, "Tiles", array<int>()); - SOCKET_BOOLEAN(animated, "Animated", false); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_UV); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(alpha, "Alpha"); - - return type; -} - -ImageTextureNode::ImageTextureNode() : ImageSlotTextureNode(get_node_type()) -{ - colorspace = u_colorspace_raw; - animated = false; - tiles.push_back_slow(1001); -} - -ShaderNode *ImageTextureNode::clone(ShaderGraph *graph) const -{ - ImageTextureNode *node = graph->create_node<ImageTextureNode>(*this); - node->handle = handle; - return node; -} - -ImageParams ImageTextureNode::image_params() const -{ - ImageParams params; - params.animated = animated; - params.interpolation = interpolation; - params.extension = extension; - params.alpha_type = alpha_type; - params.colorspace = colorspace; - return params; -} - -void ImageTextureNode::cull_tiles(Scene *scene, ShaderGraph *graph) -{ - /* Box projection computes its own UVs that always lie in the - * 1001 tile, so there's no point in loading any others. */ - if (projection == NODE_IMAGE_PROJ_BOX) { - tiles.clear(); - tiles.push_back_slow(1001); - return; - } - - if (!scene->params.background) { - /* During interactive renders, all tiles are loaded. - * While we could support updating this when UVs change, that could lead - * to annoying interruptions when loading images while editing UVs. */ - return; - } - - /* Only check UVs for tile culling if there are multiple tiles. */ - if (tiles.size() < 2) { - return; - } - - ShaderInput *vector_in = input("Vector"); - ustring attribute; - if (vector_in->link) { - ShaderNode *node = vector_in->link->parent; - if (node->type == UVMapNode::get_node_type()) { - UVMapNode *uvmap = (UVMapNode *)node; - attribute = uvmap->get_attribute(); - } - else if (node->type == TextureCoordinateNode::get_node_type()) { - if (vector_in->link != node->output("UV")) { - return; - } - } - else { - return; - } - } - - unordered_set<int> used_tiles; - /* TODO(lukas): This is quite inefficient. A fairly simple improvement would - * be to have a cache in each mesh that is indexed by attribute. - * Additionally, building a graph-to-meshes list once could help. */ - foreach (Geometry *geom, scene->geometry) { - foreach (Node *node, geom->get_used_shaders()) { - Shader *shader = static_cast<Shader *>(node); - if (shader->graph == graph) { - geom->get_uv_tiles(attribute, used_tiles); - } - } - } - - array<int> new_tiles; - foreach (int tile, tiles) { - if (used_tiles.count(tile)) { - new_tiles.push_back_slow(tile); - } - } - tiles.steal_data(new_tiles); -} - -void ImageTextureNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ -#ifdef WITH_PTEX - /* todo: avoid loading other texture coordinates when using ptex, - * and hide texture coordinate socket in the UI */ - if (shader->has_surface_link() && string_endswith(filename, ".ptx")) { - /* ptex */ - attributes->add(ATTR_STD_PTEX_FACE_ID); - attributes->add(ATTR_STD_PTEX_UV); - } -#endif - - ShaderNode::attributes(shader, attributes); -} - -void ImageTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *alpha_out = output("Alpha"); - - if (handle.empty()) { - cull_tiles(compiler.scene, compiler.current_graph); - ImageManager *image_manager = compiler.scene->image_manager; - handle = image_manager->add_image(filename.string(), image_params(), tiles); - } - - /* All tiles have the same metadata. */ - const ImageMetaData metadata = handle.metadata(); - const bool compress_as_srgb = metadata.compress_as_srgb; - const ustring known_colorspace = metadata.colorspace; - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - uint flags = 0; - - if (compress_as_srgb) { - flags |= NODE_IMAGE_COMPRESS_AS_SRGB; - } - if (!alpha_out->links.empty()) { - const bool unassociate_alpha = !(ColorSpaceManager::colorspace_is_data(colorspace) || - alpha_type == IMAGE_ALPHA_CHANNEL_PACKED || - alpha_type == IMAGE_ALPHA_IGNORE); - - if (unassociate_alpha) { - flags |= NODE_IMAGE_ALPHA_UNASSOCIATE; - } - } - - if (projection != NODE_IMAGE_PROJ_BOX) { - /* If there only is one image (a very common case), we encode it as a negative value. */ - int num_nodes; - if (handle.num_tiles() == 1) { - num_nodes = -handle.svm_slot(); - } - else { - num_nodes = divide_up(handle.num_tiles(), 2); - } - - compiler.add_node(NODE_TEX_IMAGE, - num_nodes, - compiler.encode_uchar4(vector_offset, - compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(alpha_out), - flags), - projection); - - if (num_nodes > 0) { - for (int i = 0; i < num_nodes; i++) { - int4 node; - node.x = tiles[2 * i]; - node.y = handle.svm_slot(2 * i); - if (2 * i + 1 < tiles.size()) { - node.z = tiles[2 * i + 1]; - node.w = handle.svm_slot(2 * i + 1); - } - else { - node.z = -1; - node.w = -1; - } - compiler.add_node(node.x, node.y, node.z, node.w); - } - } - } - else { - assert(handle.num_tiles() == 1); - compiler.add_node(NODE_TEX_IMAGE_BOX, - handle.svm_slot(), - compiler.encode_uchar4(vector_offset, - compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(alpha_out), - flags), - __float_as_int(projection_blend)); - } - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void ImageTextureNode::compile(OSLCompiler &compiler) -{ - ShaderOutput *alpha_out = output("Alpha"); - - tex_mapping.compile(compiler); - - if (handle.empty()) { - ImageManager *image_manager = compiler.scene->image_manager; - handle = image_manager->add_image(filename.string(), image_params()); - } - - const ImageMetaData metadata = handle.metadata(); - const bool is_float = metadata.is_float(); - const bool compress_as_srgb = metadata.compress_as_srgb; - const ustring known_colorspace = metadata.colorspace; - - if (handle.svm_slot() == -1) { - compiler.parameter_texture( - "filename", filename, compress_as_srgb ? u_colorspace_raw : known_colorspace); - } - else { - compiler.parameter_texture("filename", handle.svm_slot()); - } - - const bool unassociate_alpha = !(ColorSpaceManager::colorspace_is_data(colorspace) || - alpha_type == IMAGE_ALPHA_CHANNEL_PACKED || - alpha_type == IMAGE_ALPHA_IGNORE); - const bool is_tiled = (filename.find("<UDIM>") != string::npos); - - compiler.parameter(this, "projection"); - compiler.parameter(this, "projection_blend"); - compiler.parameter("compress_as_srgb", compress_as_srgb); - compiler.parameter("ignore_alpha", alpha_type == IMAGE_ALPHA_IGNORE); - compiler.parameter("unassociate_alpha", !alpha_out->links.empty() && unassociate_alpha); - compiler.parameter("is_float", is_float); - compiler.parameter("is_tiled", is_tiled); - compiler.parameter(this, "interpolation"); - compiler.parameter(this, "extension"); - - compiler.add(this, "node_image_texture"); -} - -/* Environment Texture */ - -NODE_DEFINE(EnvironmentTextureNode) -{ - NodeType *type = NodeType::add("environment_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(EnvironmentTextureNode); - - SOCKET_STRING(filename, "Filename", ustring()); - SOCKET_STRING(colorspace, "Colorspace", u_colorspace_auto); - - static NodeEnum alpha_type_enum; - alpha_type_enum.insert("auto", IMAGE_ALPHA_AUTO); - alpha_type_enum.insert("unassociated", IMAGE_ALPHA_UNASSOCIATED); - alpha_type_enum.insert("associated", IMAGE_ALPHA_ASSOCIATED); - alpha_type_enum.insert("channel_packed", IMAGE_ALPHA_CHANNEL_PACKED); - alpha_type_enum.insert("ignore", IMAGE_ALPHA_IGNORE); - SOCKET_ENUM(alpha_type, "Alpha Type", alpha_type_enum, IMAGE_ALPHA_AUTO); - - static NodeEnum interpolation_enum; - interpolation_enum.insert("closest", INTERPOLATION_CLOSEST); - interpolation_enum.insert("linear", INTERPOLATION_LINEAR); - interpolation_enum.insert("cubic", INTERPOLATION_CUBIC); - interpolation_enum.insert("smart", INTERPOLATION_SMART); - SOCKET_ENUM(interpolation, "Interpolation", interpolation_enum, INTERPOLATION_LINEAR); - - static NodeEnum projection_enum; - projection_enum.insert("equirectangular", NODE_ENVIRONMENT_EQUIRECTANGULAR); - projection_enum.insert("mirror_ball", NODE_ENVIRONMENT_MIRROR_BALL); - SOCKET_ENUM(projection, "Projection", projection_enum, NODE_ENVIRONMENT_EQUIRECTANGULAR); - - SOCKET_BOOLEAN(animated, "Animated", false); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_POSITION); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(alpha, "Alpha"); - - return type; -} - -EnvironmentTextureNode::EnvironmentTextureNode() : ImageSlotTextureNode(get_node_type()) -{ - colorspace = u_colorspace_raw; - animated = false; -} - -ShaderNode *EnvironmentTextureNode::clone(ShaderGraph *graph) const -{ - EnvironmentTextureNode *node = graph->create_node<EnvironmentTextureNode>(*this); - node->handle = handle; - return node; -} - -ImageParams EnvironmentTextureNode::image_params() const -{ - ImageParams params; - params.animated = animated; - params.interpolation = interpolation; - params.extension = EXTENSION_REPEAT; - params.alpha_type = alpha_type; - params.colorspace = colorspace; - return params; -} - -void EnvironmentTextureNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ -#ifdef WITH_PTEX - if (shader->has_surface_link() && string_endswith(filename, ".ptx")) { - /* ptex */ - attributes->add(ATTR_STD_PTEX_FACE_ID); - attributes->add(ATTR_STD_PTEX_UV); - } -#endif - - ShaderNode::attributes(shader, attributes); -} - -void EnvironmentTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *alpha_out = output("Alpha"); - - if (handle.empty()) { - ImageManager *image_manager = compiler.scene->image_manager; - handle = image_manager->add_image(filename.string(), image_params()); - } - - const ImageMetaData metadata = handle.metadata(); - const bool compress_as_srgb = metadata.compress_as_srgb; - const ustring known_colorspace = metadata.colorspace; - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - uint flags = 0; - - if (compress_as_srgb) { - flags |= NODE_IMAGE_COMPRESS_AS_SRGB; - } - - compiler.add_node(NODE_TEX_ENVIRONMENT, - handle.svm_slot(), - compiler.encode_uchar4(vector_offset, - compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(alpha_out), - flags), - projection); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void EnvironmentTextureNode::compile(OSLCompiler &compiler) -{ - if (handle.empty()) { - ImageManager *image_manager = compiler.scene->image_manager; - handle = image_manager->add_image(filename.string(), image_params()); - } - - tex_mapping.compile(compiler); - - const ImageMetaData metadata = handle.metadata(); - const bool is_float = metadata.is_float(); - const bool compress_as_srgb = metadata.compress_as_srgb; - const ustring known_colorspace = metadata.colorspace; - - if (handle.svm_slot() == -1) { - compiler.parameter_texture( - "filename", filename, compress_as_srgb ? u_colorspace_raw : known_colorspace); - } - else { - compiler.parameter_texture("filename", handle.svm_slot()); - } - - compiler.parameter(this, "projection"); - compiler.parameter(this, "interpolation"); - compiler.parameter("compress_as_srgb", compress_as_srgb); - compiler.parameter("ignore_alpha", alpha_type == IMAGE_ALPHA_IGNORE); - compiler.parameter("is_float", is_float); - compiler.add(this, "node_environment_texture"); -} - -/* Sky Texture */ - -static float2 sky_spherical_coordinates(float3 dir) -{ - return make_float2(acosf(dir.z), atan2f(dir.x, dir.y)); -} - -typedef struct SunSky { - /* sun direction in spherical and cartesian */ - float theta, phi; - - /* Parameter */ - float radiance_x, radiance_y, radiance_z; - float config_x[9], config_y[9], config_z[9], nishita_data[10]; -} SunSky; - -/* Preetham model */ -static float sky_perez_function(float lam[6], float theta, float gamma) -{ - return (1.0f + lam[0] * expf(lam[1] / cosf(theta))) * - (1.0f + lam[2] * expf(lam[3] * gamma) + lam[4] * cosf(gamma) * cosf(gamma)); -} - -static void sky_texture_precompute_preetham(SunSky *sunsky, float3 dir, float turbidity) -{ - /* - * We re-use the SunSky struct of the new model, to avoid extra variables - * zenith_Y/x/y is now radiance_x/y/z - * perez_Y/x/y is now config_x/y/z - */ - - float2 spherical = sky_spherical_coordinates(dir); - float theta = spherical.x; - float phi = spherical.y; - - sunsky->theta = theta; - sunsky->phi = phi; - - float theta2 = theta * theta; - float theta3 = theta2 * theta; - float T = turbidity; - float T2 = T * T; - - float chi = (4.0f / 9.0f - T / 120.0f) * (M_PI_F - 2.0f * theta); - sunsky->radiance_x = (4.0453f * T - 4.9710f) * tanf(chi) - 0.2155f * T + 2.4192f; - sunsky->radiance_x *= 0.06f; - - sunsky->radiance_y = (0.00166f * theta3 - 0.00375f * theta2 + 0.00209f * theta) * T2 + - (-0.02903f * theta3 + 0.06377f * theta2 - 0.03202f * theta + 0.00394f) * T + - (0.11693f * theta3 - 0.21196f * theta2 + 0.06052f * theta + 0.25886f); - - sunsky->radiance_z = (0.00275f * theta3 - 0.00610f * theta2 + 0.00317f * theta) * T2 + - (-0.04214f * theta3 + 0.08970f * theta2 - 0.04153f * theta + 0.00516f) * T + - (0.15346f * theta3 - 0.26756f * theta2 + 0.06670f * theta + 0.26688f); - - sunsky->config_x[0] = (0.1787f * T - 1.4630f); - sunsky->config_x[1] = (-0.3554f * T + 0.4275f); - sunsky->config_x[2] = (-0.0227f * T + 5.3251f); - sunsky->config_x[3] = (0.1206f * T - 2.5771f); - sunsky->config_x[4] = (-0.0670f * T + 0.3703f); - - sunsky->config_y[0] = (-0.0193f * T - 0.2592f); - sunsky->config_y[1] = (-0.0665f * T + 0.0008f); - sunsky->config_y[2] = (-0.0004f * T + 0.2125f); - sunsky->config_y[3] = (-0.0641f * T - 0.8989f); - sunsky->config_y[4] = (-0.0033f * T + 0.0452f); - - sunsky->config_z[0] = (-0.0167f * T - 0.2608f); - sunsky->config_z[1] = (-0.0950f * T + 0.0092f); - sunsky->config_z[2] = (-0.0079f * T + 0.2102f); - sunsky->config_z[3] = (-0.0441f * T - 1.6537f); - sunsky->config_z[4] = (-0.0109f * T + 0.0529f); - - /* unused for old sky model */ - for (int i = 5; i < 9; i++) { - sunsky->config_x[i] = 0.0f; - sunsky->config_y[i] = 0.0f; - sunsky->config_z[i] = 0.0f; - } - - sunsky->radiance_x /= sky_perez_function(sunsky->config_x, 0, theta); - sunsky->radiance_y /= sky_perez_function(sunsky->config_y, 0, theta); - sunsky->radiance_z /= sky_perez_function(sunsky->config_z, 0, theta); -} - -/* Hosek / Wilkie */ -static void sky_texture_precompute_hosek(SunSky *sunsky, - float3 dir, - float turbidity, - float ground_albedo) -{ - /* Calculate Sun Direction and save coordinates */ - float2 spherical = sky_spherical_coordinates(dir); - float theta = spherical.x; - float phi = spherical.y; - - /* Clamp Turbidity */ - turbidity = clamp(turbidity, 0.0f, 10.0f); - - /* Clamp to Horizon */ - theta = clamp(theta, 0.0f, M_PI_2_F); - - sunsky->theta = theta; - sunsky->phi = phi; - - float solarElevation = M_PI_2_F - theta; - - /* Initialize Sky Model */ - SKY_ArHosekSkyModelState *sky_state; - sky_state = SKY_arhosek_xyz_skymodelstate_alloc_init( - (double)turbidity, (double)ground_albedo, (double)solarElevation); - - /* Copy values from sky_state to SunSky */ - for (int i = 0; i < 9; ++i) { - sunsky->config_x[i] = (float)sky_state->configs[0][i]; - sunsky->config_y[i] = (float)sky_state->configs[1][i]; - sunsky->config_z[i] = (float)sky_state->configs[2][i]; - } - sunsky->radiance_x = (float)sky_state->radiances[0]; - sunsky->radiance_y = (float)sky_state->radiances[1]; - sunsky->radiance_z = (float)sky_state->radiances[2]; - - /* Free sky_state */ - SKY_arhosekskymodelstate_free(sky_state); -} - -/* Nishita improved */ -static void sky_texture_precompute_nishita(SunSky *sunsky, - bool sun_disc, - float sun_size, - float sun_intensity, - float sun_elevation, - float sun_rotation, - float altitude, - float air_density, - float dust_density) -{ - /* sample 2 sun pixels */ - float pixel_bottom[3]; - float pixel_top[3]; - SKY_nishita_skymodel_precompute_sun( - sun_elevation, sun_size, altitude, air_density, dust_density, pixel_bottom, pixel_top); - /* limit sun rotation between 0 and 360 degrees */ - sun_rotation = fmodf(sun_rotation, M_2PI_F); - if (sun_rotation < 0.0f) { - sun_rotation += M_2PI_F; - } - sun_rotation = M_2PI_F - sun_rotation; - /* send data to svm_sky */ - sunsky->nishita_data[0] = pixel_bottom[0]; - sunsky->nishita_data[1] = pixel_bottom[1]; - sunsky->nishita_data[2] = pixel_bottom[2]; - sunsky->nishita_data[3] = pixel_top[0]; - sunsky->nishita_data[4] = pixel_top[1]; - sunsky->nishita_data[5] = pixel_top[2]; - sunsky->nishita_data[6] = sun_elevation; - sunsky->nishita_data[7] = sun_rotation; - sunsky->nishita_data[8] = sun_disc ? sun_size : -1.0f; - sunsky->nishita_data[9] = sun_intensity; -} - -NODE_DEFINE(SkyTextureNode) -{ - NodeType *type = NodeType::add("sky_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(SkyTextureNode); - - static NodeEnum type_enum; - type_enum.insert("preetham", NODE_SKY_PREETHAM); - type_enum.insert("hosek_wilkie", NODE_SKY_HOSEK); - type_enum.insert("nishita_improved", NODE_SKY_NISHITA); - SOCKET_ENUM(sky_type, "Type", type_enum, NODE_SKY_NISHITA); - - SOCKET_VECTOR(sun_direction, "Sun Direction", make_float3(0.0f, 0.0f, 1.0f)); - SOCKET_FLOAT(turbidity, "Turbidity", 2.2f); - SOCKET_FLOAT(ground_albedo, "Ground Albedo", 0.3f); - SOCKET_BOOLEAN(sun_disc, "Sun Disc", true); - SOCKET_FLOAT(sun_size, "Sun Size", 0.009512f); - SOCKET_FLOAT(sun_intensity, "Sun Intensity", 1.0f); - SOCKET_FLOAT(sun_elevation, "Sun Elevation", 15.0f * M_PI_F / 180.0f); - SOCKET_FLOAT(sun_rotation, "Sun Rotation", 0.0f); - SOCKET_FLOAT(altitude, "Altitude", 1.0f); - SOCKET_FLOAT(air_density, "Air", 1.0f); - SOCKET_FLOAT(dust_density, "Dust", 1.0f); - SOCKET_FLOAT(ozone_density, "Ozone", 1.0f); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -SkyTextureNode::SkyTextureNode() : TextureNode(get_node_type()) -{ -} - -void SkyTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *color_out = output("Color"); - - SunSky sunsky; - if (sky_type == NODE_SKY_PREETHAM) - sky_texture_precompute_preetham(&sunsky, sun_direction, turbidity); - else if (sky_type == NODE_SKY_HOSEK) - sky_texture_precompute_hosek(&sunsky, sun_direction, turbidity, ground_albedo); - else if (sky_type == NODE_SKY_NISHITA) { - /* Clamp altitude to reasonable values. - * Below 1m causes numerical issues and above 60km is space. */ - float clamped_altitude = clamp(altitude, 1.0f, 59999.0f); - - sky_texture_precompute_nishita(&sunsky, - sun_disc, - get_sun_size(), - sun_intensity, - sun_elevation, - sun_rotation, - clamped_altitude, - air_density, - dust_density); - /* precomputed texture image parameters */ - ImageManager *image_manager = compiler.scene->image_manager; - ImageParams impar; - impar.interpolation = INTERPOLATION_LINEAR; - impar.extension = EXTENSION_EXTEND; - - /* precompute sky texture */ - if (handle.empty()) { - SkyLoader *loader = new SkyLoader( - sun_elevation, clamped_altitude, air_density, dust_density, ozone_density); - handle = image_manager->add_image(loader, impar); - } - } - else - assert(false); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.stack_assign(color_out); - compiler.add_node(NODE_TEX_SKY, vector_offset, compiler.stack_assign(color_out), sky_type); - /* nishita doesn't need this data */ - if (sky_type != NODE_SKY_NISHITA) { - compiler.add_node(__float_as_uint(sunsky.phi), - __float_as_uint(sunsky.theta), - __float_as_uint(sunsky.radiance_x), - __float_as_uint(sunsky.radiance_y)); - compiler.add_node(__float_as_uint(sunsky.radiance_z), - __float_as_uint(sunsky.config_x[0]), - __float_as_uint(sunsky.config_x[1]), - __float_as_uint(sunsky.config_x[2])); - compiler.add_node(__float_as_uint(sunsky.config_x[3]), - __float_as_uint(sunsky.config_x[4]), - __float_as_uint(sunsky.config_x[5]), - __float_as_uint(sunsky.config_x[6])); - compiler.add_node(__float_as_uint(sunsky.config_x[7]), - __float_as_uint(sunsky.config_x[8]), - __float_as_uint(sunsky.config_y[0]), - __float_as_uint(sunsky.config_y[1])); - compiler.add_node(__float_as_uint(sunsky.config_y[2]), - __float_as_uint(sunsky.config_y[3]), - __float_as_uint(sunsky.config_y[4]), - __float_as_uint(sunsky.config_y[5])); - compiler.add_node(__float_as_uint(sunsky.config_y[6]), - __float_as_uint(sunsky.config_y[7]), - __float_as_uint(sunsky.config_y[8]), - __float_as_uint(sunsky.config_z[0])); - compiler.add_node(__float_as_uint(sunsky.config_z[1]), - __float_as_uint(sunsky.config_z[2]), - __float_as_uint(sunsky.config_z[3]), - __float_as_uint(sunsky.config_z[4])); - compiler.add_node(__float_as_uint(sunsky.config_z[5]), - __float_as_uint(sunsky.config_z[6]), - __float_as_uint(sunsky.config_z[7]), - __float_as_uint(sunsky.config_z[8])); - } - else { - compiler.add_node(__float_as_uint(sunsky.nishita_data[0]), - __float_as_uint(sunsky.nishita_data[1]), - __float_as_uint(sunsky.nishita_data[2]), - __float_as_uint(sunsky.nishita_data[3])); - compiler.add_node(__float_as_uint(sunsky.nishita_data[4]), - __float_as_uint(sunsky.nishita_data[5]), - __float_as_uint(sunsky.nishita_data[6]), - __float_as_uint(sunsky.nishita_data[7])); - compiler.add_node(__float_as_uint(sunsky.nishita_data[8]), - __float_as_uint(sunsky.nishita_data[9]), - handle.svm_slot(), - 0); - } - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void SkyTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - SunSky sunsky; - if (sky_type == NODE_SKY_PREETHAM) - sky_texture_precompute_preetham(&sunsky, sun_direction, turbidity); - else if (sky_type == NODE_SKY_HOSEK) - sky_texture_precompute_hosek(&sunsky, sun_direction, turbidity, ground_albedo); - else if (sky_type == NODE_SKY_NISHITA) { - /* Clamp altitude to reasonable values. - * Below 1m causes numerical issues and above 60km is space. */ - float clamped_altitude = clamp(altitude, 1.0f, 59999.0f); - - sky_texture_precompute_nishita(&sunsky, - sun_disc, - get_sun_size(), - sun_intensity, - sun_elevation, - sun_rotation, - clamped_altitude, - air_density, - dust_density); - /* precomputed texture image parameters */ - ImageManager *image_manager = compiler.scene->image_manager; - ImageParams impar; - impar.interpolation = INTERPOLATION_LINEAR; - impar.extension = EXTENSION_EXTEND; - - /* precompute sky texture */ - if (handle.empty()) { - SkyLoader *loader = new SkyLoader( - sun_elevation, clamped_altitude, air_density, dust_density, ozone_density); - handle = image_manager->add_image(loader, impar); - } - } - else - assert(false); - - compiler.parameter(this, "sky_type"); - compiler.parameter("theta", sunsky.theta); - compiler.parameter("phi", sunsky.phi); - compiler.parameter_color("radiance", - make_float3(sunsky.radiance_x, sunsky.radiance_y, sunsky.radiance_z)); - compiler.parameter_array("config_x", sunsky.config_x, 9); - compiler.parameter_array("config_y", sunsky.config_y, 9); - compiler.parameter_array("config_z", sunsky.config_z, 9); - compiler.parameter_array("nishita_data", sunsky.nishita_data, 10); - /* nishita texture */ - if (sky_type == NODE_SKY_NISHITA) { - compiler.parameter_texture("filename", handle.svm_slot()); - } - compiler.add(this, "node_sky_texture"); -} - -/* Gradient Texture */ - -NODE_DEFINE(GradientTextureNode) -{ - NodeType *type = NodeType::add("gradient_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(GradientTextureNode); - - static NodeEnum type_enum; - type_enum.insert("linear", NODE_BLEND_LINEAR); - type_enum.insert("quadratic", NODE_BLEND_QUADRATIC); - type_enum.insert("easing", NODE_BLEND_EASING); - type_enum.insert("diagonal", NODE_BLEND_DIAGONAL); - type_enum.insert("radial", NODE_BLEND_RADIAL); - type_enum.insert("quadratic_sphere", NODE_BLEND_QUADRATIC_SPHERE); - type_enum.insert("spherical", NODE_BLEND_SPHERICAL); - SOCKET_ENUM(gradient_type, "Type", type_enum, NODE_BLEND_LINEAR); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -GradientTextureNode::GradientTextureNode() : TextureNode(get_node_type()) -{ -} - -void GradientTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *fac_out = output("Fac"); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.add_node(NODE_TEX_GRADIENT, - compiler.encode_uchar4(gradient_type, - vector_offset, - compiler.stack_assign_if_linked(fac_out), - compiler.stack_assign_if_linked(color_out))); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void GradientTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.parameter(this, "gradient_type"); - compiler.add(this, "node_gradient_texture"); -} - -/* Noise Texture */ - -NODE_DEFINE(NoiseTextureNode) -{ - NodeType *type = NodeType::add("noise_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(NoiseTextureNode); - - static NodeEnum dimensions_enum; - dimensions_enum.insert("1D", 1); - dimensions_enum.insert("2D", 2); - dimensions_enum.insert("3D", 3); - dimensions_enum.insert("4D", 4); - SOCKET_ENUM(dimensions, "Dimensions", dimensions_enum, 3); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - SOCKET_IN_FLOAT(w, "W", 0.0f); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - SOCKET_IN_FLOAT(detail, "Detail", 2.0f); - SOCKET_IN_FLOAT(roughness, "Roughness", 0.5f); - SOCKET_IN_FLOAT(distortion, "Distortion", 0.0f); - - SOCKET_OUT_FLOAT(fac, "Fac"); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -NoiseTextureNode::NoiseTextureNode() : TextureNode(get_node_type()) -{ -} - -void NoiseTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *w_in = input("W"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *detail_in = input("Detail"); - ShaderInput *roughness_in = input("Roughness"); - ShaderInput *distortion_in = input("Distortion"); - ShaderOutput *fac_out = output("Fac"); - ShaderOutput *color_out = output("Color"); - - int vector_stack_offset = tex_mapping.compile_begin(compiler, vector_in); - int w_stack_offset = compiler.stack_assign_if_linked(w_in); - int scale_stack_offset = compiler.stack_assign_if_linked(scale_in); - int detail_stack_offset = compiler.stack_assign_if_linked(detail_in); - int roughness_stack_offset = compiler.stack_assign_if_linked(roughness_in); - int distortion_stack_offset = compiler.stack_assign_if_linked(distortion_in); - int fac_stack_offset = compiler.stack_assign_if_linked(fac_out); - int color_stack_offset = compiler.stack_assign_if_linked(color_out); - - compiler.add_node( - NODE_TEX_NOISE, - dimensions, - compiler.encode_uchar4( - vector_stack_offset, w_stack_offset, scale_stack_offset, detail_stack_offset), - compiler.encode_uchar4( - roughness_stack_offset, distortion_stack_offset, fac_stack_offset, color_stack_offset)); - compiler.add_node( - __float_as_int(w), __float_as_int(scale), __float_as_int(detail), __float_as_int(roughness)); - - compiler.add_node( - __float_as_int(distortion), SVM_STACK_INVALID, SVM_STACK_INVALID, SVM_STACK_INVALID); - - tex_mapping.compile_end(compiler, vector_in, vector_stack_offset); -} - -void NoiseTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - compiler.parameter(this, "dimensions"); - compiler.add(this, "node_noise_texture"); -} - -/* Voronoi Texture */ - -NODE_DEFINE(VoronoiTextureNode) -{ - NodeType *type = NodeType::add("voronoi_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(VoronoiTextureNode); - - static NodeEnum dimensions_enum; - dimensions_enum.insert("1D", 1); - dimensions_enum.insert("2D", 2); - dimensions_enum.insert("3D", 3); - dimensions_enum.insert("4D", 4); - SOCKET_ENUM(dimensions, "Dimensions", dimensions_enum, 3); - - static NodeEnum metric_enum; - metric_enum.insert("euclidean", NODE_VORONOI_EUCLIDEAN); - metric_enum.insert("manhattan", NODE_VORONOI_MANHATTAN); - metric_enum.insert("chebychev", NODE_VORONOI_CHEBYCHEV); - metric_enum.insert("minkowski", NODE_VORONOI_MINKOWSKI); - SOCKET_ENUM(metric, "Distance Metric", metric_enum, NODE_VORONOI_EUCLIDEAN); - - static NodeEnum feature_enum; - feature_enum.insert("f1", NODE_VORONOI_F1); - feature_enum.insert("f2", NODE_VORONOI_F2); - feature_enum.insert("smooth_f1", NODE_VORONOI_SMOOTH_F1); - feature_enum.insert("distance_to_edge", NODE_VORONOI_DISTANCE_TO_EDGE); - feature_enum.insert("n_sphere_radius", NODE_VORONOI_N_SPHERE_RADIUS); - SOCKET_ENUM(feature, "Feature", feature_enum, NODE_VORONOI_F1); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - SOCKET_IN_FLOAT(w, "W", 0.0f); - SOCKET_IN_FLOAT(scale, "Scale", 5.0f); - SOCKET_IN_FLOAT(smoothness, "Smoothness", 5.0f); - SOCKET_IN_FLOAT(exponent, "Exponent", 0.5f); - SOCKET_IN_FLOAT(randomness, "Randomness", 1.0f); - - SOCKET_OUT_FLOAT(distance, "Distance"); - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_POINT(position, "Position"); - SOCKET_OUT_FLOAT(w, "W"); - SOCKET_OUT_FLOAT(radius, "Radius"); - - return type; -} - -VoronoiTextureNode::VoronoiTextureNode() : TextureNode(get_node_type()) -{ -} - -void VoronoiTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *w_in = input("W"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *smoothness_in = input("Smoothness"); - ShaderInput *exponent_in = input("Exponent"); - ShaderInput *randomness_in = input("Randomness"); - - ShaderOutput *distance_out = output("Distance"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *position_out = output("Position"); - ShaderOutput *w_out = output("W"); - ShaderOutput *radius_out = output("Radius"); - - int vector_stack_offset = tex_mapping.compile_begin(compiler, vector_in); - int w_in_stack_offset = compiler.stack_assign_if_linked(w_in); - int scale_stack_offset = compiler.stack_assign_if_linked(scale_in); - int smoothness_stack_offset = compiler.stack_assign_if_linked(smoothness_in); - int exponent_stack_offset = compiler.stack_assign_if_linked(exponent_in); - int randomness_stack_offset = compiler.stack_assign_if_linked(randomness_in); - int distance_stack_offset = compiler.stack_assign_if_linked(distance_out); - int color_stack_offset = compiler.stack_assign_if_linked(color_out); - int position_stack_offset = compiler.stack_assign_if_linked(position_out); - int w_out_stack_offset = compiler.stack_assign_if_linked(w_out); - int radius_stack_offset = compiler.stack_assign_if_linked(radius_out); - - compiler.add_node(NODE_TEX_VORONOI, dimensions, feature, metric); - compiler.add_node( - compiler.encode_uchar4( - vector_stack_offset, w_in_stack_offset, scale_stack_offset, smoothness_stack_offset), - compiler.encode_uchar4(exponent_stack_offset, - randomness_stack_offset, - distance_stack_offset, - color_stack_offset), - compiler.encode_uchar4(position_stack_offset, w_out_stack_offset, radius_stack_offset), - __float_as_int(w)); - - compiler.add_node(__float_as_int(scale), - __float_as_int(smoothness), - __float_as_int(exponent), - __float_as_int(randomness)); - - tex_mapping.compile_end(compiler, vector_in, vector_stack_offset); -} - -void VoronoiTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.parameter(this, "dimensions"); - compiler.parameter(this, "feature"); - compiler.parameter(this, "metric"); - compiler.add(this, "node_voronoi_texture"); -} - -/* IES Light */ - -NODE_DEFINE(IESLightNode) -{ - NodeType *type = NodeType::add("ies_light", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(IESLightNode); - - SOCKET_STRING(ies, "IES", ustring()); - SOCKET_STRING(filename, "File Name", ustring()); - - SOCKET_IN_FLOAT(strength, "Strength", 1.0f); - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_NORMAL); - - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -IESLightNode::IESLightNode() : TextureNode(get_node_type()) -{ - light_manager = NULL; - slot = -1; -} - -ShaderNode *IESLightNode::clone(ShaderGraph *graph) const -{ - IESLightNode *node = graph->create_node<IESLightNode>(*this); - - node->light_manager = NULL; - node->slot = -1; - - return node; -} - -IESLightNode::~IESLightNode() -{ - if (light_manager) { - light_manager->remove_ies(slot); - } -} - -void IESLightNode::get_slot() -{ - assert(light_manager); - - if (slot == -1) { - if (ies.empty()) { - slot = light_manager->add_ies_from_file(filename.string()); - } - else { - slot = light_manager->add_ies(ies.string()); - } - } -} - -void IESLightNode::compile(SVMCompiler &compiler) -{ - light_manager = compiler.scene->light_manager; - get_slot(); - - ShaderInput *strength_in = input("Strength"); - ShaderInput *vector_in = input("Vector"); - ShaderOutput *fac_out = output("Fac"); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.add_node(NODE_IES, - compiler.encode_uchar4(compiler.stack_assign_if_linked(strength_in), - vector_offset, - compiler.stack_assign(fac_out), - 0), - slot, - __float_as_int(strength)); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void IESLightNode::compile(OSLCompiler &compiler) -{ - light_manager = compiler.scene->light_manager; - get_slot(); - - tex_mapping.compile(compiler); - - compiler.parameter_texture_ies("filename", slot); - compiler.add(this, "node_ies_light"); -} - -/* White Noise Texture */ - -NODE_DEFINE(WhiteNoiseTextureNode) -{ - NodeType *type = NodeType::add("white_noise_texture", create, NodeType::SHADER); - - static NodeEnum dimensions_enum; - dimensions_enum.insert("1D", 1); - dimensions_enum.insert("2D", 2); - dimensions_enum.insert("3D", 3); - dimensions_enum.insert("4D", 4); - SOCKET_ENUM(dimensions, "Dimensions", dimensions_enum, 3); - - SOCKET_IN_POINT(vector, "Vector", zero_float3()); - SOCKET_IN_FLOAT(w, "W", 0.0f); - - SOCKET_OUT_FLOAT(value, "Value"); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -WhiteNoiseTextureNode::WhiteNoiseTextureNode() : ShaderNode(get_node_type()) -{ -} - -void WhiteNoiseTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *w_in = input("W"); - ShaderOutput *value_out = output("Value"); - ShaderOutput *color_out = output("Color"); - - int vector_stack_offset = compiler.stack_assign(vector_in); - int w_stack_offset = compiler.stack_assign(w_in); - int value_stack_offset = compiler.stack_assign(value_out); - int color_stack_offset = compiler.stack_assign(color_out); - - compiler.add_node(NODE_TEX_WHITE_NOISE, - dimensions, - compiler.encode_uchar4(vector_stack_offset, w_stack_offset), - compiler.encode_uchar4(value_stack_offset, color_stack_offset)); -} - -void WhiteNoiseTextureNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "dimensions"); - compiler.add(this, "node_white_noise_texture"); -} - -/* Musgrave Texture */ - -NODE_DEFINE(MusgraveTextureNode) -{ - NodeType *type = NodeType::add("musgrave_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(MusgraveTextureNode); - - static NodeEnum dimensions_enum; - dimensions_enum.insert("1D", 1); - dimensions_enum.insert("2D", 2); - dimensions_enum.insert("3D", 3); - dimensions_enum.insert("4D", 4); - SOCKET_ENUM(dimensions, "Dimensions", dimensions_enum, 3); - - static NodeEnum type_enum; - type_enum.insert("multifractal", NODE_MUSGRAVE_MULTIFRACTAL); - type_enum.insert("fBM", NODE_MUSGRAVE_FBM); - type_enum.insert("hybrid_multifractal", NODE_MUSGRAVE_HYBRID_MULTIFRACTAL); - type_enum.insert("ridged_multifractal", NODE_MUSGRAVE_RIDGED_MULTIFRACTAL); - type_enum.insert("hetero_terrain", NODE_MUSGRAVE_HETERO_TERRAIN); - SOCKET_ENUM(musgrave_type, "Type", type_enum, NODE_MUSGRAVE_FBM); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - SOCKET_IN_FLOAT(w, "W", 0.0f); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - SOCKET_IN_FLOAT(detail, "Detail", 2.0f); - SOCKET_IN_FLOAT(dimension, "Dimension", 2.0f); - SOCKET_IN_FLOAT(lacunarity, "Lacunarity", 2.0f); - SOCKET_IN_FLOAT(offset, "Offset", 0.0f); - SOCKET_IN_FLOAT(gain, "Gain", 1.0f); - - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -MusgraveTextureNode::MusgraveTextureNode() : TextureNode(get_node_type()) -{ -} - -void MusgraveTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *w_in = input("W"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *detail_in = input("Detail"); - ShaderInput *dimension_in = input("Dimension"); - ShaderInput *lacunarity_in = input("Lacunarity"); - ShaderInput *offset_in = input("Offset"); - ShaderInput *gain_in = input("Gain"); - ShaderOutput *fac_out = output("Fac"); - - int vector_stack_offset = tex_mapping.compile_begin(compiler, vector_in); - int w_stack_offset = compiler.stack_assign_if_linked(w_in); - int scale_stack_offset = compiler.stack_assign_if_linked(scale_in); - int detail_stack_offset = compiler.stack_assign_if_linked(detail_in); - int dimension_stack_offset = compiler.stack_assign_if_linked(dimension_in); - int lacunarity_stack_offset = compiler.stack_assign_if_linked(lacunarity_in); - int offset_stack_offset = compiler.stack_assign_if_linked(offset_in); - int gain_stack_offset = compiler.stack_assign_if_linked(gain_in); - int fac_stack_offset = compiler.stack_assign(fac_out); - - compiler.add_node( - NODE_TEX_MUSGRAVE, - compiler.encode_uchar4(musgrave_type, dimensions, vector_stack_offset, w_stack_offset), - compiler.encode_uchar4(scale_stack_offset, - detail_stack_offset, - dimension_stack_offset, - lacunarity_stack_offset), - compiler.encode_uchar4(offset_stack_offset, gain_stack_offset, fac_stack_offset)); - compiler.add_node( - __float_as_int(w), __float_as_int(scale), __float_as_int(detail), __float_as_int(dimension)); - compiler.add_node(__float_as_int(lacunarity), __float_as_int(offset), __float_as_int(gain)); - - tex_mapping.compile_end(compiler, vector_in, vector_stack_offset); -} - -void MusgraveTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.parameter(this, "musgrave_type"); - compiler.parameter(this, "dimensions"); - compiler.add(this, "node_musgrave_texture"); -} - -/* Wave Texture */ - -NODE_DEFINE(WaveTextureNode) -{ - NodeType *type = NodeType::add("wave_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(WaveTextureNode); - - static NodeEnum type_enum; - type_enum.insert("bands", NODE_WAVE_BANDS); - type_enum.insert("rings", NODE_WAVE_RINGS); - SOCKET_ENUM(wave_type, "Type", type_enum, NODE_WAVE_BANDS); - - static NodeEnum bands_direction_enum; - bands_direction_enum.insert("x", NODE_WAVE_BANDS_DIRECTION_X); - bands_direction_enum.insert("y", NODE_WAVE_BANDS_DIRECTION_Y); - bands_direction_enum.insert("z", NODE_WAVE_BANDS_DIRECTION_Z); - bands_direction_enum.insert("diagonal", NODE_WAVE_BANDS_DIRECTION_DIAGONAL); - SOCKET_ENUM( - bands_direction, "Bands Direction", bands_direction_enum, NODE_WAVE_BANDS_DIRECTION_X); - - static NodeEnum rings_direction_enum; - rings_direction_enum.insert("x", NODE_WAVE_RINGS_DIRECTION_X); - rings_direction_enum.insert("y", NODE_WAVE_RINGS_DIRECTION_Y); - rings_direction_enum.insert("z", NODE_WAVE_RINGS_DIRECTION_Z); - rings_direction_enum.insert("spherical", NODE_WAVE_RINGS_DIRECTION_SPHERICAL); - SOCKET_ENUM( - rings_direction, "Rings Direction", rings_direction_enum, NODE_WAVE_BANDS_DIRECTION_X); - - static NodeEnum profile_enum; - profile_enum.insert("sine", NODE_WAVE_PROFILE_SIN); - profile_enum.insert("saw", NODE_WAVE_PROFILE_SAW); - profile_enum.insert("tri", NODE_WAVE_PROFILE_TRI); - SOCKET_ENUM(profile, "Profile", profile_enum, NODE_WAVE_PROFILE_SIN); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - SOCKET_IN_FLOAT(distortion, "Distortion", 0.0f); - SOCKET_IN_FLOAT(detail, "Detail", 2.0f); - SOCKET_IN_FLOAT(detail_scale, "Detail Scale", 0.0f); - SOCKET_IN_FLOAT(detail_roughness, "Detail Roughness", 0.5f); - SOCKET_IN_FLOAT(phase, "Phase Offset", 0.0f); - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -WaveTextureNode::WaveTextureNode() : TextureNode(get_node_type()) -{ -} - -void WaveTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *distortion_in = input("Distortion"); - ShaderInput *detail_in = input("Detail"); - ShaderInput *dscale_in = input("Detail Scale"); - ShaderInput *droughness_in = input("Detail Roughness"); - ShaderInput *phase_in = input("Phase Offset"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *fac_out = output("Fac"); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.add_node(NODE_TEX_WAVE, - compiler.encode_uchar4(wave_type, bands_direction, rings_direction, profile), - compiler.encode_uchar4(vector_offset, - compiler.stack_assign_if_linked(scale_in), - compiler.stack_assign_if_linked(distortion_in)), - compiler.encode_uchar4(compiler.stack_assign_if_linked(detail_in), - compiler.stack_assign_if_linked(dscale_in), - compiler.stack_assign_if_linked(droughness_in), - compiler.stack_assign_if_linked(phase_in))); - - compiler.add_node(compiler.encode_uchar4(compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(fac_out)), - __float_as_int(scale), - __float_as_int(distortion), - __float_as_int(detail)); - - compiler.add_node(__float_as_int(detail_scale), - __float_as_int(detail_roughness), - __float_as_int(phase), - SVM_STACK_INVALID); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void WaveTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.parameter(this, "wave_type"); - compiler.parameter(this, "bands_direction"); - compiler.parameter(this, "rings_direction"); - compiler.parameter(this, "profile"); - - compiler.add(this, "node_wave_texture"); -} - -/* Magic Texture */ - -NODE_DEFINE(MagicTextureNode) -{ - NodeType *type = NodeType::add("magic_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(MagicTextureNode); - - SOCKET_INT(depth, "Depth", 2); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - SOCKET_IN_FLOAT(scale, "Scale", 5.0f); - SOCKET_IN_FLOAT(distortion, "Distortion", 1.0f); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -MagicTextureNode::MagicTextureNode() : TextureNode(get_node_type()) -{ -} - -void MagicTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *distortion_in = input("Distortion"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *fac_out = output("Fac"); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.add_node(NODE_TEX_MAGIC, - compiler.encode_uchar4(depth, - compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(fac_out)), - compiler.encode_uchar4(vector_offset, - compiler.stack_assign_if_linked(scale_in), - compiler.stack_assign_if_linked(distortion_in))); - compiler.add_node(__float_as_int(scale), __float_as_int(distortion)); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void MagicTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.parameter(this, "depth"); - compiler.add(this, "node_magic_texture"); -} - -/* Checker Texture */ - -NODE_DEFINE(CheckerTextureNode) -{ - NodeType *type = NodeType::add("checker_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(CheckerTextureNode); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - SOCKET_IN_COLOR(color1, "Color1", zero_float3()); - SOCKET_IN_COLOR(color2, "Color2", zero_float3()); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -CheckerTextureNode::CheckerTextureNode() : TextureNode(get_node_type()) -{ -} - -void CheckerTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *color1_in = input("Color1"); - ShaderInput *color2_in = input("Color2"); - ShaderInput *scale_in = input("Scale"); - - ShaderOutput *color_out = output("Color"); - ShaderOutput *fac_out = output("Fac"); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.add_node(NODE_TEX_CHECKER, - compiler.encode_uchar4(vector_offset, - compiler.stack_assign(color1_in), - compiler.stack_assign(color2_in), - compiler.stack_assign_if_linked(scale_in)), - compiler.encode_uchar4(compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(fac_out)), - __float_as_int(scale)); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void CheckerTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.add(this, "node_checker_texture"); -} - -/* Brick Texture */ - -NODE_DEFINE(BrickTextureNode) -{ - NodeType *type = NodeType::add("brick_texture", create, NodeType::SHADER); - - TEXTURE_MAPPING_DEFINE(BrickTextureNode); - - SOCKET_FLOAT(offset, "Offset", 0.5f); - SOCKET_INT(offset_frequency, "Offset Frequency", 2); - SOCKET_FLOAT(squash, "Squash", 1.0f); - SOCKET_INT(squash_frequency, "Squash Frequency", 2); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_TEXTURE_GENERATED); - - SOCKET_IN_COLOR(color1, "Color1", zero_float3()); - SOCKET_IN_COLOR(color2, "Color2", zero_float3()); - SOCKET_IN_COLOR(mortar, "Mortar", zero_float3()); - SOCKET_IN_FLOAT(scale, "Scale", 5.0f); - SOCKET_IN_FLOAT(mortar_size, "Mortar Size", 0.02f); - SOCKET_IN_FLOAT(mortar_smooth, "Mortar Smooth", 0.0f); - SOCKET_IN_FLOAT(bias, "Bias", 0.0f); - SOCKET_IN_FLOAT(brick_width, "Brick Width", 0.5f); - SOCKET_IN_FLOAT(row_height, "Row Height", 0.25f); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -BrickTextureNode::BrickTextureNode() : TextureNode(get_node_type()) -{ -} - -void BrickTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *color1_in = input("Color1"); - ShaderInput *color2_in = input("Color2"); - ShaderInput *mortar_in = input("Mortar"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *mortar_size_in = input("Mortar Size"); - ShaderInput *mortar_smooth_in = input("Mortar Smooth"); - ShaderInput *bias_in = input("Bias"); - ShaderInput *brick_width_in = input("Brick Width"); - ShaderInput *row_height_in = input("Row Height"); - - ShaderOutput *color_out = output("Color"); - ShaderOutput *fac_out = output("Fac"); - - int vector_offset = tex_mapping.compile_begin(compiler, vector_in); - - compiler.add_node(NODE_TEX_BRICK, - compiler.encode_uchar4(vector_offset, - compiler.stack_assign(color1_in), - compiler.stack_assign(color2_in), - compiler.stack_assign(mortar_in)), - compiler.encode_uchar4(compiler.stack_assign_if_linked(scale_in), - compiler.stack_assign_if_linked(mortar_size_in), - compiler.stack_assign_if_linked(bias_in), - compiler.stack_assign_if_linked(brick_width_in)), - compiler.encode_uchar4(compiler.stack_assign_if_linked(row_height_in), - compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(fac_out), - compiler.stack_assign_if_linked(mortar_smooth_in))); - - compiler.add_node(compiler.encode_uchar4(offset_frequency, squash_frequency), - __float_as_int(scale), - __float_as_int(mortar_size), - __float_as_int(bias)); - - compiler.add_node(__float_as_int(brick_width), - __float_as_int(row_height), - __float_as_int(offset), - __float_as_int(squash)); - - compiler.add_node( - __float_as_int(mortar_smooth), SVM_STACK_INVALID, SVM_STACK_INVALID, SVM_STACK_INVALID); - - tex_mapping.compile_end(compiler, vector_in, vector_offset); -} - -void BrickTextureNode::compile(OSLCompiler &compiler) -{ - tex_mapping.compile(compiler); - - compiler.parameter(this, "offset"); - compiler.parameter(this, "offset_frequency"); - compiler.parameter(this, "squash"); - compiler.parameter(this, "squash_frequency"); - compiler.add(this, "node_brick_texture"); -} - -/* Point Density Texture */ - -NODE_DEFINE(PointDensityTextureNode) -{ - NodeType *type = NodeType::add("point_density_texture", create, NodeType::SHADER); - - SOCKET_STRING(filename, "Filename", ustring()); - - static NodeEnum space_enum; - space_enum.insert("object", NODE_TEX_VOXEL_SPACE_OBJECT); - space_enum.insert("world", NODE_TEX_VOXEL_SPACE_WORLD); - SOCKET_ENUM(space, "Space", space_enum, NODE_TEX_VOXEL_SPACE_OBJECT); - - static NodeEnum interpolation_enum; - interpolation_enum.insert("closest", INTERPOLATION_CLOSEST); - interpolation_enum.insert("linear", INTERPOLATION_LINEAR); - interpolation_enum.insert("cubic", INTERPOLATION_CUBIC); - interpolation_enum.insert("smart", INTERPOLATION_SMART); - SOCKET_ENUM(interpolation, "Interpolation", interpolation_enum, INTERPOLATION_LINEAR); - - SOCKET_TRANSFORM(tfm, "Transform", transform_identity()); - - SOCKET_IN_POINT(vector, "Vector", zero_float3(), SocketType::LINK_POSITION); - - SOCKET_OUT_FLOAT(density, "Density"); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -PointDensityTextureNode::PointDensityTextureNode() : ShaderNode(get_node_type()) -{ -} - -PointDensityTextureNode::~PointDensityTextureNode() -{ -} - -ShaderNode *PointDensityTextureNode::clone(ShaderGraph *graph) const -{ - /* Increase image user count for new node. We need to ensure to not call - * add_image again, to work around access of freed data on the Blender - * side. A better solution should be found to avoid this. */ - PointDensityTextureNode *node = graph->create_node<PointDensityTextureNode>(*this); - node->handle = handle; /* TODO: not needed? */ - return node; -} - -void PointDensityTextureNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_volume) - attributes->add(ATTR_STD_GENERATED_TRANSFORM); - - ShaderNode::attributes(shader, attributes); -} - -ImageParams PointDensityTextureNode::image_params() const -{ - ImageParams params; - params.interpolation = interpolation; - return params; -} - -void PointDensityTextureNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *density_out = output("Density"); - ShaderOutput *color_out = output("Color"); - - const bool use_density = !density_out->links.empty(); - const bool use_color = !color_out->links.empty(); - - if (use_density || use_color) { - if (handle.empty()) { - ImageManager *image_manager = compiler.scene->image_manager; - handle = image_manager->add_image(filename.string(), image_params()); - } - - const int slot = handle.svm_slot(); - if (slot != -1) { - compiler.stack_assign(vector_in); - compiler.add_node(NODE_TEX_VOXEL, - slot, - compiler.encode_uchar4(compiler.stack_assign(vector_in), - compiler.stack_assign_if_linked(density_out), - compiler.stack_assign_if_linked(color_out), - space)); - if (space == NODE_TEX_VOXEL_SPACE_WORLD) { - compiler.add_node(tfm.x); - compiler.add_node(tfm.y); - compiler.add_node(tfm.z); - } - } - else { - if (use_density) { - compiler.add_node(NODE_VALUE_F, __float_as_int(0.0f), compiler.stack_assign(density_out)); - } - if (use_color) { - compiler.add_node(NODE_VALUE_V, compiler.stack_assign(color_out)); - compiler.add_node( - NODE_VALUE_V, - make_float3(TEX_IMAGE_MISSING_R, TEX_IMAGE_MISSING_G, TEX_IMAGE_MISSING_B)); - } - } - } -} - -void PointDensityTextureNode::compile(OSLCompiler &compiler) -{ - ShaderOutput *density_out = output("Density"); - ShaderOutput *color_out = output("Color"); - - const bool use_density = !density_out->links.empty(); - const bool use_color = !color_out->links.empty(); - - if (use_density || use_color) { - if (handle.empty()) { - ImageManager *image_manager = compiler.scene->image_manager; - handle = image_manager->add_image(filename.string(), image_params()); - } - - compiler.parameter_texture("filename", handle.svm_slot()); - if (space == NODE_TEX_VOXEL_SPACE_WORLD) { - compiler.parameter("mapping", tfm); - compiler.parameter("use_mapping", 1); - } - compiler.parameter(this, "interpolation"); - compiler.add(this, "node_voxel_texture"); - } -} - -/* Normal */ - -NODE_DEFINE(NormalNode) -{ - NodeType *type = NodeType::add("normal", create, NodeType::SHADER); - - SOCKET_VECTOR(direction, "direction", zero_float3()); - - SOCKET_IN_NORMAL(normal, "Normal", zero_float3()); - - SOCKET_OUT_NORMAL(normal, "Normal"); - SOCKET_OUT_FLOAT(dot, "Dot"); - - return type; -} - -NormalNode::NormalNode() : ShaderNode(get_node_type()) -{ -} - -void NormalNode::compile(SVMCompiler &compiler) -{ - ShaderInput *normal_in = input("Normal"); - ShaderOutput *normal_out = output("Normal"); - ShaderOutput *dot_out = output("Dot"); - - compiler.add_node(NODE_NORMAL, - compiler.stack_assign(normal_in), - compiler.stack_assign(normal_out), - compiler.stack_assign(dot_out)); - compiler.add_node( - __float_as_int(direction.x), __float_as_int(direction.y), __float_as_int(direction.z)); -} - -void NormalNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "direction"); - compiler.add(this, "node_normal"); -} - -/* Mapping */ - -NODE_DEFINE(MappingNode) -{ - NodeType *type = NodeType::add("mapping", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("point", NODE_MAPPING_TYPE_POINT); - type_enum.insert("texture", NODE_MAPPING_TYPE_TEXTURE); - type_enum.insert("vector", NODE_MAPPING_TYPE_VECTOR); - type_enum.insert("normal", NODE_MAPPING_TYPE_NORMAL); - SOCKET_ENUM(mapping_type, "Type", type_enum, NODE_MAPPING_TYPE_POINT); - - SOCKET_IN_POINT(vector, "Vector", zero_float3()); - SOCKET_IN_POINT(location, "Location", zero_float3()); - SOCKET_IN_POINT(rotation, "Rotation", zero_float3()); - SOCKET_IN_POINT(scale, "Scale", one_float3()); - - SOCKET_OUT_POINT(vector, "Vector"); - - return type; -} - -MappingNode::MappingNode() : ShaderNode(get_node_type()) -{ -} - -void MappingNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - float3 result = svm_mapping((NodeMappingType)mapping_type, vector, location, rotation, scale); - folder.make_constant(result); - } - else { - folder.fold_mapping((NodeMappingType)mapping_type); - } -} - -void MappingNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *location_in = input("Location"); - ShaderInput *rotation_in = input("Rotation"); - ShaderInput *scale_in = input("Scale"); - ShaderOutput *vector_out = output("Vector"); - - int vector_stack_offset = compiler.stack_assign(vector_in); - int location_stack_offset = compiler.stack_assign(location_in); - int rotation_stack_offset = compiler.stack_assign(rotation_in); - int scale_stack_offset = compiler.stack_assign(scale_in); - int result_stack_offset = compiler.stack_assign(vector_out); - - compiler.add_node( - NODE_MAPPING, - mapping_type, - compiler.encode_uchar4( - vector_stack_offset, location_stack_offset, rotation_stack_offset, scale_stack_offset), - result_stack_offset); -} - -void MappingNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "mapping_type"); - compiler.add(this, "node_mapping"); -} - -/* RGBToBW */ - -NODE_DEFINE(RGBToBWNode) -{ - NodeType *type = NodeType::add("rgb_to_bw", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", zero_float3()); - SOCKET_OUT_FLOAT(val, "Val"); - - return type; -} - -RGBToBWNode::RGBToBWNode() : ShaderNode(get_node_type()) -{ -} - -void RGBToBWNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - float val = folder.scene->shader_manager->linear_rgb_to_gray(color); - folder.make_constant(val); - } -} - -void RGBToBWNode::compile(SVMCompiler &compiler) -{ - compiler.add_node(NODE_CONVERT, - NODE_CONVERT_CF, - compiler.stack_assign(inputs[0]), - compiler.stack_assign(outputs[0])); -} - -void RGBToBWNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_rgb_to_bw"); -} - -/* Convert */ - -const NodeType *ConvertNode::node_types[ConvertNode::MAX_TYPE][ConvertNode::MAX_TYPE]; -bool ConvertNode::initialized = ConvertNode::register_types(); - -Node *ConvertNode::create(const NodeType *type) -{ - return new ConvertNode(type->inputs[0].type, type->outputs[0].type); -} - -bool ConvertNode::register_types() -{ - const int num_types = 8; - SocketType::Type types[num_types] = {SocketType::FLOAT, - SocketType::INT, - SocketType::COLOR, - SocketType::VECTOR, - SocketType::POINT, - SocketType::NORMAL, - SocketType::STRING, - SocketType::CLOSURE}; - - for (size_t i = 0; i < num_types; i++) { - SocketType::Type from = types[i]; - ustring from_name(SocketType::type_name(from)); - ustring from_value_name("value_" + from_name.string()); - - for (size_t j = 0; j < num_types; j++) { - SocketType::Type to = types[j]; - ustring to_name(SocketType::type_name(to)); - ustring to_value_name("value_" + to_name.string()); - - string node_name = "convert_" + from_name.string() + "_to_" + to_name.string(); - NodeType *type = NodeType::add(node_name.c_str(), create, NodeType::SHADER); - - type->register_input(from_value_name, - from_value_name, - from, - SOCKET_OFFSETOF(ConvertNode, value_float), - SocketType::zero_default_value(), - NULL, - NULL, - SocketType::LINKABLE); - type->register_output(to_value_name, to_value_name, to); - - assert(from < MAX_TYPE); - assert(to < MAX_TYPE); - - node_types[from][to] = type; - } - } - - return true; -} - -ConvertNode::ConvertNode(SocketType::Type from_, SocketType::Type to_, bool autoconvert) - : ShaderNode(node_types[from_][to_]) -{ - from = from_; - to = to_; - - if (from == to) - special_type = SHADER_SPECIAL_TYPE_PROXY; - else if (autoconvert) - special_type = SHADER_SPECIAL_TYPE_AUTOCONVERT; -} - -/* Union usage requires a manual copy constructor. */ -ConvertNode::ConvertNode(const ConvertNode &other) - : ShaderNode(other), - from(other.from), - to(other.to), - value_color(other.value_color), - value_string(other.value_string) -{ -} - -void ConvertNode::constant_fold(const ConstantFolder &folder) -{ - /* proxy nodes should have been removed at this point */ - assert(special_type != SHADER_SPECIAL_TYPE_PROXY); - - /* TODO(DingTo): conversion from/to int is not supported yet, don't fold in that case */ - - if (folder.all_inputs_constant()) { - if (from == SocketType::FLOAT) { - if (SocketType::is_float3(to)) { - folder.make_constant(make_float3(value_float, value_float, value_float)); - } - } - else if (SocketType::is_float3(from)) { - if (to == SocketType::FLOAT) { - if (from == SocketType::COLOR) { - /* color to float */ - float val = folder.scene->shader_manager->linear_rgb_to_gray(value_color); - folder.make_constant(val); - } - else { - /* vector/point/normal to float */ - folder.make_constant(average(value_vector)); - } - } - else if (SocketType::is_float3(to)) { - folder.make_constant(value_color); - } - } - } - else { - ShaderInput *in = inputs[0]; - ShaderNode *prev = in->link->parent; - - /* no-op conversion of A to B to A */ - if (prev->type == node_types[to][from]) { - ShaderInput *prev_in = prev->inputs[0]; - - if (SocketType::is_float3(from) && (to == SocketType::FLOAT || SocketType::is_float3(to)) && - prev_in->link) { - folder.bypass(prev_in->link); - } - } - } -} - -void ConvertNode::compile(SVMCompiler &compiler) -{ - /* proxy nodes should have been removed at this point */ - assert(special_type != SHADER_SPECIAL_TYPE_PROXY); - - ShaderInput *in = inputs[0]; - ShaderOutput *out = outputs[0]; - - if (from == SocketType::FLOAT) { - if (to == SocketType::INT) - /* float to int */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_FI, compiler.stack_assign(in), compiler.stack_assign(out)); - else - /* float to float3 */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_FV, compiler.stack_assign(in), compiler.stack_assign(out)); - } - else if (from == SocketType::INT) { - if (to == SocketType::FLOAT) - /* int to float */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_IF, compiler.stack_assign(in), compiler.stack_assign(out)); - else - /* int to vector/point/normal */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_IV, compiler.stack_assign(in), compiler.stack_assign(out)); - } - else if (to == SocketType::FLOAT) { - if (from == SocketType::COLOR) - /* color to float */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_CF, compiler.stack_assign(in), compiler.stack_assign(out)); - else - /* vector/point/normal to float */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_VF, compiler.stack_assign(in), compiler.stack_assign(out)); - } - else if (to == SocketType::INT) { - if (from == SocketType::COLOR) - /* color to int */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_CI, compiler.stack_assign(in), compiler.stack_assign(out)); - else - /* vector/point/normal to int */ - compiler.add_node( - NODE_CONVERT, NODE_CONVERT_VI, compiler.stack_assign(in), compiler.stack_assign(out)); - } - else { - /* float3 to float3 */ - if (in->link) { - /* no op in SVM */ - compiler.stack_link(in, out); - } - else { - /* set 0,0,0 value */ - compiler.add_node(NODE_VALUE_V, compiler.stack_assign(out)); - compiler.add_node(NODE_VALUE_V, value_color); - } - } -} - -void ConvertNode::compile(OSLCompiler &compiler) -{ - /* proxy nodes should have been removed at this point */ - assert(special_type != SHADER_SPECIAL_TYPE_PROXY); - - if (from == SocketType::FLOAT) - compiler.add(this, "node_convert_from_float"); - else if (from == SocketType::INT) - compiler.add(this, "node_convert_from_int"); - else if (from == SocketType::COLOR) - compiler.add(this, "node_convert_from_color"); - else if (from == SocketType::VECTOR) - compiler.add(this, "node_convert_from_vector"); - else if (from == SocketType::POINT) - compiler.add(this, "node_convert_from_point"); - else if (from == SocketType::NORMAL) - compiler.add(this, "node_convert_from_normal"); - else - assert(0); -} - -/* Base type for all closure-type nodes */ - -BsdfBaseNode::BsdfBaseNode(const NodeType *node_type) : ShaderNode(node_type) -{ - special_type = SHADER_SPECIAL_TYPE_CLOSURE; -} - -bool BsdfBaseNode::has_bump() -{ - /* detect if anything is plugged into the normal input besides the default */ - ShaderInput *normal_in = input("Normal"); - return (normal_in && normal_in->link && - normal_in->link->parent->special_type != SHADER_SPECIAL_TYPE_GEOMETRY); -} - -/* BSDF Closure */ - -BsdfNode::BsdfNode(const NodeType *node_type) : BsdfBaseNode(node_type) -{ -} - -void BsdfNode::compile(SVMCompiler &compiler, - ShaderInput *param1, - ShaderInput *param2, - ShaderInput *param3, - ShaderInput *param4) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *normal_in = input("Normal"); - ShaderInput *tangent_in = input("Tangent"); - - if (color_in->link) - compiler.add_node(NODE_CLOSURE_WEIGHT, compiler.stack_assign(color_in)); - else - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, color); - - int normal_offset = (normal_in) ? compiler.stack_assign_if_linked(normal_in) : SVM_STACK_INVALID; - int tangent_offset = (tangent_in) ? compiler.stack_assign_if_linked(tangent_in) : - SVM_STACK_INVALID; - int param3_offset = (param3) ? compiler.stack_assign(param3) : SVM_STACK_INVALID; - int param4_offset = (param4) ? compiler.stack_assign(param4) : SVM_STACK_INVALID; - - compiler.add_node( - NODE_CLOSURE_BSDF, - compiler.encode_uchar4(closure, - (param1) ? compiler.stack_assign(param1) : SVM_STACK_INVALID, - (param2) ? compiler.stack_assign(param2) : SVM_STACK_INVALID, - compiler.closure_mix_weight_offset()), - __float_as_int((param1) ? get_float(param1->socket_type) : 0.0f), - __float_as_int((param2) ? get_float(param2->socket_type) : 0.0f)); - - compiler.add_node(normal_offset, tangent_offset, param3_offset, param4_offset); -} - -void BsdfNode::compile(SVMCompiler &compiler) -{ - compile(compiler, NULL, NULL); -} - -void BsdfNode::compile(OSLCompiler & /*compiler*/) -{ - assert(0); -} - -/* Anisotropic BSDF Closure */ - -NODE_DEFINE(AnisotropicBsdfNode) -{ - NodeType *type = NodeType::add("anisotropic_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum distribution_enum; - distribution_enum.insert("beckmann", CLOSURE_BSDF_MICROFACET_BECKMANN_ID); - distribution_enum.insert("GGX", CLOSURE_BSDF_MICROFACET_GGX_ID); - distribution_enum.insert("Multiscatter GGX", CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID); - distribution_enum.insert("ashikhmin_shirley", CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID); - SOCKET_ENUM(distribution, "Distribution", distribution_enum, CLOSURE_BSDF_MICROFACET_GGX_ID); - - SOCKET_IN_VECTOR(tangent, "Tangent", zero_float3(), SocketType::LINK_TANGENT); - - SOCKET_IN_FLOAT(roughness, "Roughness", 0.5f); - SOCKET_IN_FLOAT(anisotropy, "Anisotropy", 0.5f); - SOCKET_IN_FLOAT(rotation, "Rotation", 0.0f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -AnisotropicBsdfNode::AnisotropicBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_MICROFACET_GGX_ID; -} - -void AnisotropicBsdfNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link()) { - ShaderInput *tangent_in = input("Tangent"); - - if (!tangent_in->link) - attributes->add(ATTR_STD_GENERATED); - } - - ShaderNode::attributes(shader, attributes); -} - -void AnisotropicBsdfNode::compile(SVMCompiler &compiler) -{ - closure = distribution; - - if (closure == CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID) - BsdfNode::compile( - compiler, input("Roughness"), input("Anisotropy"), input("Rotation"), input("Color")); - else - BsdfNode::compile(compiler, input("Roughness"), input("Anisotropy"), input("Rotation")); -} - -void AnisotropicBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "distribution"); - compiler.add(this, "node_anisotropic_bsdf"); -} - -/* Glossy BSDF Closure */ - -NODE_DEFINE(GlossyBsdfNode) -{ - NodeType *type = NodeType::add("glossy_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum distribution_enum; - distribution_enum.insert("sharp", CLOSURE_BSDF_REFLECTION_ID); - distribution_enum.insert("beckmann", CLOSURE_BSDF_MICROFACET_BECKMANN_ID); - distribution_enum.insert("GGX", CLOSURE_BSDF_MICROFACET_GGX_ID); - distribution_enum.insert("ashikhmin_shirley", CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID); - distribution_enum.insert("Multiscatter GGX", CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID); - SOCKET_ENUM(distribution, "Distribution", distribution_enum, CLOSURE_BSDF_MICROFACET_GGX_ID); - SOCKET_IN_FLOAT(roughness, "Roughness", 0.5f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -GlossyBsdfNode::GlossyBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_MICROFACET_GGX_ID; - distribution_orig = NBUILTIN_CLOSURES; -} - -void GlossyBsdfNode::simplify_settings(Scene *scene) -{ - if (distribution_orig == NBUILTIN_CLOSURES) { - roughness_orig = roughness; - distribution_orig = distribution; - } - else { - /* By default we use original values, so we don't worry about restoring - * defaults later one and can only do override when needed. - */ - roughness = roughness_orig; - distribution = distribution_orig; - } - Integrator *integrator = scene->integrator; - ShaderInput *roughness_input = input("Roughness"); - if (integrator->get_filter_glossy() == 0.0f) { - /* Fallback to Sharp closure for Roughness close to 0. - * Note: Keep the epsilon in sync with kernel! - */ - if (!roughness_input->link && roughness <= 1e-4f) { - VLOG(1) << "Using sharp glossy BSDF."; - distribution = CLOSURE_BSDF_REFLECTION_ID; - } - } - else { - /* If filter glossy is used we replace Sharp glossy with GGX so we can - * benefit from closure blur to remove unwanted noise. - */ - if (roughness_input->link == NULL && distribution == CLOSURE_BSDF_REFLECTION_ID) { - VLOG(1) << "Using GGX glossy with filter glossy."; - distribution = CLOSURE_BSDF_MICROFACET_GGX_ID; - roughness = 0.0f; - } - } - closure = distribution; -} - -bool GlossyBsdfNode::has_integrator_dependency() -{ - ShaderInput *roughness_input = input("Roughness"); - return !roughness_input->link && - (distribution == CLOSURE_BSDF_REFLECTION_ID || roughness <= 1e-4f); -} - -void GlossyBsdfNode::compile(SVMCompiler &compiler) -{ - closure = distribution; - - if (closure == CLOSURE_BSDF_REFLECTION_ID) - BsdfNode::compile(compiler, NULL, NULL); - else if (closure == CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID) - BsdfNode::compile(compiler, input("Roughness"), NULL, NULL, input("Color")); - else - BsdfNode::compile(compiler, input("Roughness"), NULL); -} - -void GlossyBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "distribution"); - compiler.add(this, "node_glossy_bsdf"); -} - -/* Glass BSDF Closure */ - -NODE_DEFINE(GlassBsdfNode) -{ - NodeType *type = NodeType::add("glass_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum distribution_enum; - distribution_enum.insert("sharp", CLOSURE_BSDF_SHARP_GLASS_ID); - distribution_enum.insert("beckmann", CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID); - distribution_enum.insert("GGX", CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID); - distribution_enum.insert("Multiscatter GGX", CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID); - SOCKET_ENUM( - distribution, "Distribution", distribution_enum, CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID); - SOCKET_IN_FLOAT(roughness, "Roughness", 0.0f); - SOCKET_IN_FLOAT(IOR, "IOR", 0.3f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -GlassBsdfNode::GlassBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_SHARP_GLASS_ID; - distribution_orig = NBUILTIN_CLOSURES; -} - -void GlassBsdfNode::simplify_settings(Scene *scene) -{ - if (distribution_orig == NBUILTIN_CLOSURES) { - roughness_orig = roughness; - distribution_orig = distribution; - } - else { - /* By default we use original values, so we don't worry about restoring - * defaults later one and can only do override when needed. - */ - roughness = roughness_orig; - distribution = distribution_orig; - } - Integrator *integrator = scene->integrator; - ShaderInput *roughness_input = input("Roughness"); - if (integrator->get_filter_glossy() == 0.0f) { - /* Fallback to Sharp closure for Roughness close to 0. - * Note: Keep the epsilon in sync with kernel! - */ - if (!roughness_input->link && roughness <= 1e-4f) { - VLOG(1) << "Using sharp glass BSDF."; - distribution = CLOSURE_BSDF_SHARP_GLASS_ID; - } - } - else { - /* If filter glossy is used we replace Sharp glossy with GGX so we can - * benefit from closure blur to remove unwanted noise. - */ - if (roughness_input->link == NULL && distribution == CLOSURE_BSDF_SHARP_GLASS_ID) { - VLOG(1) << "Using GGX glass with filter glossy."; - distribution = CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID; - roughness = 0.0f; - } - } - closure = distribution; -} - -bool GlassBsdfNode::has_integrator_dependency() -{ - ShaderInput *roughness_input = input("Roughness"); - return !roughness_input->link && - (distribution == CLOSURE_BSDF_SHARP_GLASS_ID || roughness <= 1e-4f); -} - -void GlassBsdfNode::compile(SVMCompiler &compiler) -{ - closure = distribution; - - if (closure == CLOSURE_BSDF_SHARP_GLASS_ID) - BsdfNode::compile(compiler, NULL, input("IOR")); - else if (closure == CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID) - BsdfNode::compile(compiler, input("Roughness"), input("IOR"), input("Color")); - else - BsdfNode::compile(compiler, input("Roughness"), input("IOR")); -} - -void GlassBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "distribution"); - compiler.add(this, "node_glass_bsdf"); -} - -/* Refraction BSDF Closure */ - -NODE_DEFINE(RefractionBsdfNode) -{ - NodeType *type = NodeType::add("refraction_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum distribution_enum; - distribution_enum.insert("sharp", CLOSURE_BSDF_REFRACTION_ID); - distribution_enum.insert("beckmann", CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID); - distribution_enum.insert("GGX", CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID); - SOCKET_ENUM( - distribution, "Distribution", distribution_enum, CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID); - - SOCKET_IN_FLOAT(roughness, "Roughness", 0.0f); - SOCKET_IN_FLOAT(IOR, "IOR", 0.3f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -RefractionBsdfNode::RefractionBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_REFRACTION_ID; - distribution_orig = NBUILTIN_CLOSURES; -} - -void RefractionBsdfNode::simplify_settings(Scene *scene) -{ - if (distribution_orig == NBUILTIN_CLOSURES) { - roughness_orig = roughness; - distribution_orig = distribution; - } - else { - /* By default we use original values, so we don't worry about restoring - * defaults later one and can only do override when needed. - */ - roughness = roughness_orig; - distribution = distribution_orig; - } - Integrator *integrator = scene->integrator; - ShaderInput *roughness_input = input("Roughness"); - if (integrator->get_filter_glossy() == 0.0f) { - /* Fallback to Sharp closure for Roughness close to 0. - * Note: Keep the epsilon in sync with kernel! - */ - if (!roughness_input->link && roughness <= 1e-4f) { - VLOG(1) << "Using sharp refraction BSDF."; - distribution = CLOSURE_BSDF_REFRACTION_ID; - } - } - else { - /* If filter glossy is used we replace Sharp glossy with GGX so we can - * benefit from closure blur to remove unwanted noise. - */ - if (roughness_input->link == NULL && distribution == CLOSURE_BSDF_REFRACTION_ID) { - VLOG(1) << "Using GGX refraction with filter glossy."; - distribution = CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID; - roughness = 0.0f; - } - } - closure = distribution; -} - -bool RefractionBsdfNode::has_integrator_dependency() -{ - ShaderInput *roughness_input = input("Roughness"); - return !roughness_input->link && - (distribution == CLOSURE_BSDF_REFRACTION_ID || roughness <= 1e-4f); -} - -void RefractionBsdfNode::compile(SVMCompiler &compiler) -{ - closure = distribution; - - if (closure == CLOSURE_BSDF_REFRACTION_ID) - BsdfNode::compile(compiler, NULL, input("IOR")); - else - BsdfNode::compile(compiler, input("Roughness"), input("IOR")); -} - -void RefractionBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "distribution"); - compiler.add(this, "node_refraction_bsdf"); -} - -/* Toon BSDF Closure */ - -NODE_DEFINE(ToonBsdfNode) -{ - NodeType *type = NodeType::add("toon_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum component_enum; - component_enum.insert("diffuse", CLOSURE_BSDF_DIFFUSE_TOON_ID); - component_enum.insert("glossy", CLOSURE_BSDF_GLOSSY_TOON_ID); - SOCKET_ENUM(component, "Component", component_enum, CLOSURE_BSDF_DIFFUSE_TOON_ID); - SOCKET_IN_FLOAT(size, "Size", 0.5f); - SOCKET_IN_FLOAT(smooth, "Smooth", 0.0f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -ToonBsdfNode::ToonBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_DIFFUSE_TOON_ID; -} - -void ToonBsdfNode::compile(SVMCompiler &compiler) -{ - closure = component; - - BsdfNode::compile(compiler, input("Size"), input("Smooth")); -} - -void ToonBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "component"); - compiler.add(this, "node_toon_bsdf"); -} - -/* Velvet BSDF Closure */ - -NODE_DEFINE(VelvetBsdfNode) -{ - NodeType *type = NodeType::add("velvet_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - SOCKET_IN_FLOAT(sigma, "Sigma", 1.0f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -VelvetBsdfNode::VelvetBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_ASHIKHMIN_VELVET_ID; -} - -void VelvetBsdfNode::compile(SVMCompiler &compiler) -{ - BsdfNode::compile(compiler, input("Sigma"), NULL); -} - -void VelvetBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_velvet_bsdf"); -} - -/* Diffuse BSDF Closure */ - -NODE_DEFINE(DiffuseBsdfNode) -{ - NodeType *type = NodeType::add("diffuse_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - SOCKET_IN_FLOAT(roughness, "Roughness", 0.0f); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -DiffuseBsdfNode::DiffuseBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_DIFFUSE_ID; -} - -void DiffuseBsdfNode::compile(SVMCompiler &compiler) -{ - BsdfNode::compile(compiler, input("Roughness"), NULL); -} - -void DiffuseBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_diffuse_bsdf"); -} - -/* Disney principled BSDF Closure */ -NODE_DEFINE(PrincipledBsdfNode) -{ - NodeType *type = NodeType::add("principled_bsdf", create, NodeType::SHADER); - - static NodeEnum distribution_enum; - distribution_enum.insert("GGX", CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID); - distribution_enum.insert("Multiscatter GGX", CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID); - SOCKET_ENUM( - distribution, "Distribution", distribution_enum, CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID); - - static NodeEnum subsurface_method_enum; - subsurface_method_enum.insert("burley", CLOSURE_BSSRDF_BURLEY_ID); - subsurface_method_enum.insert("random_walk_fixed_radius", - CLOSURE_BSSRDF_RANDOM_WALK_FIXED_RADIUS_ID); - subsurface_method_enum.insert("random_walk", CLOSURE_BSSRDF_RANDOM_WALK_ID); - SOCKET_ENUM(subsurface_method, - "Subsurface Method", - subsurface_method_enum, - CLOSURE_BSSRDF_RANDOM_WALK_ID); - - SOCKET_IN_COLOR(base_color, "Base Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_COLOR(subsurface_color, "Subsurface Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_FLOAT(metallic, "Metallic", 0.0f); - SOCKET_IN_FLOAT(subsurface, "Subsurface", 0.0f); - SOCKET_IN_VECTOR(subsurface_radius, "Subsurface Radius", make_float3(0.1f, 0.1f, 0.1f)); - SOCKET_IN_FLOAT(subsurface_ior, "Subsurface IOR", 1.4f); - SOCKET_IN_FLOAT(subsurface_anisotropy, "Subsurface Anisotropy", 0.0f); - SOCKET_IN_FLOAT(specular, "Specular", 0.0f); - SOCKET_IN_FLOAT(roughness, "Roughness", 0.5f); - SOCKET_IN_FLOAT(specular_tint, "Specular Tint", 0.0f); - SOCKET_IN_FLOAT(anisotropic, "Anisotropic", 0.0f); - SOCKET_IN_FLOAT(sheen, "Sheen", 0.0f); - SOCKET_IN_FLOAT(sheen_tint, "Sheen Tint", 0.0f); - SOCKET_IN_FLOAT(clearcoat, "Clearcoat", 0.0f); - SOCKET_IN_FLOAT(clearcoat_roughness, "Clearcoat Roughness", 0.03f); - SOCKET_IN_FLOAT(ior, "IOR", 0.0f); - SOCKET_IN_FLOAT(transmission, "Transmission", 0.0f); - SOCKET_IN_FLOAT(transmission_roughness, "Transmission Roughness", 0.0f); - SOCKET_IN_FLOAT(anisotropic_rotation, "Anisotropic Rotation", 0.0f); - SOCKET_IN_COLOR(emission, "Emission", zero_float3()); - SOCKET_IN_FLOAT(emission_strength, "Emission Strength", 1.0f); - SOCKET_IN_FLOAT(alpha, "Alpha", 1.0f); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_NORMAL(clearcoat_normal, "Clearcoat Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_NORMAL(tangent, "Tangent", zero_float3(), SocketType::LINK_TANGENT); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -PrincipledBsdfNode::PrincipledBsdfNode() : BsdfBaseNode(get_node_type()) -{ - closure = CLOSURE_BSDF_PRINCIPLED_ID; - distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID; - distribution_orig = NBUILTIN_CLOSURES; -} - -void PrincipledBsdfNode::expand(ShaderGraph *graph) -{ - ShaderOutput *principled_out = output("BSDF"); - - ShaderInput *emission_in = input("Emission"); - ShaderInput *emission_strength_in = input("Emission Strength"); - if ((emission_in->link || emission != zero_float3()) && - (emission_strength_in->link || emission_strength != 0.0f)) { - /* Create add closure and emission, and relink inputs. */ - AddClosureNode *add = graph->create_node<AddClosureNode>(); - EmissionNode *emission_node = graph->create_node<EmissionNode>(); - ShaderOutput *new_out = add->output("Closure"); - - graph->add(add); - graph->add(emission_node); - - graph->relink(emission_strength_in, emission_node->input("Strength")); - graph->relink(emission_in, emission_node->input("Color")); - graph->relink(principled_out, new_out); - graph->connect(emission_node->output("Emission"), add->input("Closure1")); - graph->connect(principled_out, add->input("Closure2")); - - principled_out = new_out; - } - else { - /* Disconnect unused links if the other value is zero, required before - * we remove the input from the node entirely. */ - if (emission_in->link) { - emission_in->disconnect(); - } - if (emission_strength_in->link) { - emission_strength_in->disconnect(); - } - } - - ShaderInput *alpha_in = input("Alpha"); - if (alpha_in->link || alpha != 1.0f) { - /* Create mix and transparent BSDF for alpha transparency. */ - MixClosureNode *mix = graph->create_node<MixClosureNode>(); - TransparentBsdfNode *transparent = graph->create_node<TransparentBsdfNode>(); - - graph->add(mix); - graph->add(transparent); - - graph->relink(alpha_in, mix->input("Fac")); - graph->relink(principled_out, mix->output("Closure")); - graph->connect(transparent->output("BSDF"), mix->input("Closure1")); - graph->connect(principled_out, mix->input("Closure2")); - } - - remove_input(emission_in); - remove_input(emission_strength_in); - remove_input(alpha_in); -} - -bool PrincipledBsdfNode::has_surface_bssrdf() -{ - ShaderInput *subsurface_in = input("Subsurface"); - return (subsurface_in->link != NULL || subsurface > CLOSURE_WEIGHT_CUTOFF); -} - -void PrincipledBsdfNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link()) { - ShaderInput *tangent_in = input("Tangent"); - - if (!tangent_in->link) - attributes->add(ATTR_STD_GENERATED); - } - - ShaderNode::attributes(shader, attributes); -} - -void PrincipledBsdfNode::compile(SVMCompiler &compiler, - ShaderInput *p_metallic, - ShaderInput *p_subsurface, - ShaderInput *p_subsurface_radius, - ShaderInput *p_subsurface_ior, - ShaderInput *p_subsurface_anisotropy, - ShaderInput *p_specular, - ShaderInput *p_roughness, - ShaderInput *p_specular_tint, - ShaderInput *p_anisotropic, - ShaderInput *p_sheen, - ShaderInput *p_sheen_tint, - ShaderInput *p_clearcoat, - ShaderInput *p_clearcoat_roughness, - ShaderInput *p_ior, - ShaderInput *p_transmission, - ShaderInput *p_anisotropic_rotation, - ShaderInput *p_transmission_roughness) -{ - ShaderInput *base_color_in = input("Base Color"); - ShaderInput *subsurface_color_in = input("Subsurface Color"); - ShaderInput *normal_in = input("Normal"); - ShaderInput *clearcoat_normal_in = input("Clearcoat Normal"); - ShaderInput *tangent_in = input("Tangent"); - - float3 weight = one_float3(); - - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, weight); - - int normal_offset = compiler.stack_assign_if_linked(normal_in); - int clearcoat_normal_offset = compiler.stack_assign_if_linked(clearcoat_normal_in); - int tangent_offset = compiler.stack_assign_if_linked(tangent_in); - int specular_offset = compiler.stack_assign(p_specular); - int roughness_offset = compiler.stack_assign(p_roughness); - int specular_tint_offset = compiler.stack_assign(p_specular_tint); - int anisotropic_offset = compiler.stack_assign(p_anisotropic); - int sheen_offset = compiler.stack_assign(p_sheen); - int sheen_tint_offset = compiler.stack_assign(p_sheen_tint); - int clearcoat_offset = compiler.stack_assign(p_clearcoat); - int clearcoat_roughness_offset = compiler.stack_assign(p_clearcoat_roughness); - int ior_offset = compiler.stack_assign(p_ior); - int transmission_offset = compiler.stack_assign(p_transmission); - int transmission_roughness_offset = compiler.stack_assign(p_transmission_roughness); - int anisotropic_rotation_offset = compiler.stack_assign(p_anisotropic_rotation); - int subsurface_radius_offset = compiler.stack_assign(p_subsurface_radius); - int subsurface_ior_offset = compiler.stack_assign(p_subsurface_ior); - int subsurface_anisotropy_offset = compiler.stack_assign(p_subsurface_anisotropy); - - compiler.add_node(NODE_CLOSURE_BSDF, - compiler.encode_uchar4(closure, - compiler.stack_assign(p_metallic), - compiler.stack_assign(p_subsurface), - compiler.closure_mix_weight_offset()), - __float_as_int((p_metallic) ? get_float(p_metallic->socket_type) : 0.0f), - __float_as_int((p_subsurface) ? get_float(p_subsurface->socket_type) : 0.0f)); - - compiler.add_node( - normal_offset, - tangent_offset, - compiler.encode_uchar4( - specular_offset, roughness_offset, specular_tint_offset, anisotropic_offset), - compiler.encode_uchar4( - sheen_offset, sheen_tint_offset, clearcoat_offset, clearcoat_roughness_offset)); - - compiler.add_node(compiler.encode_uchar4(ior_offset, - transmission_offset, - anisotropic_rotation_offset, - transmission_roughness_offset), - distribution, - subsurface_method, - SVM_STACK_INVALID); - - float3 bc_default = get_float3(base_color_in->socket_type); - - compiler.add_node( - ((base_color_in->link) ? compiler.stack_assign(base_color_in) : SVM_STACK_INVALID), - __float_as_int(bc_default.x), - __float_as_int(bc_default.y), - __float_as_int(bc_default.z)); - - compiler.add_node(clearcoat_normal_offset, - subsurface_radius_offset, - subsurface_ior_offset, - subsurface_anisotropy_offset); - - float3 ss_default = get_float3(subsurface_color_in->socket_type); - - compiler.add_node(((subsurface_color_in->link) ? compiler.stack_assign(subsurface_color_in) : - SVM_STACK_INVALID), - __float_as_int(ss_default.x), - __float_as_int(ss_default.y), - __float_as_int(ss_default.z)); -} - -bool PrincipledBsdfNode::has_integrator_dependency() -{ - ShaderInput *roughness_input = input("Roughness"); - return !roughness_input->link && roughness <= 1e-4f; -} - -void PrincipledBsdfNode::compile(SVMCompiler &compiler) -{ - compile(compiler, - input("Metallic"), - input("Subsurface"), - input("Subsurface Radius"), - input("Subsurface IOR"), - input("Subsurface Anisotropy"), - input("Specular"), - input("Roughness"), - input("Specular Tint"), - input("Anisotropic"), - input("Sheen"), - input("Sheen Tint"), - input("Clearcoat"), - input("Clearcoat Roughness"), - input("IOR"), - input("Transmission"), - input("Anisotropic Rotation"), - input("Transmission Roughness")); -} - -void PrincipledBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "distribution"); - compiler.parameter(this, "subsurface_method"); - compiler.add(this, "node_principled_bsdf"); -} - -bool PrincipledBsdfNode::has_bssrdf_bump() -{ - return has_surface_bssrdf() && has_bump(); -} - -/* Translucent BSDF Closure */ - -NODE_DEFINE(TranslucentBsdfNode) -{ - NodeType *type = NodeType::add("translucent_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -TranslucentBsdfNode::TranslucentBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_TRANSLUCENT_ID; -} - -void TranslucentBsdfNode::compile(SVMCompiler &compiler) -{ - BsdfNode::compile(compiler, NULL, NULL); -} - -void TranslucentBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_translucent_bsdf"); -} - -/* Transparent BSDF Closure */ - -NODE_DEFINE(TransparentBsdfNode) -{ - NodeType *type = NodeType::add("transparent_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", one_float3()); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -TransparentBsdfNode::TransparentBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_TRANSPARENT_ID; -} - -void TransparentBsdfNode::compile(SVMCompiler &compiler) -{ - BsdfNode::compile(compiler, NULL, NULL); -} - -void TransparentBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_transparent_bsdf"); -} - -/* Subsurface Scattering Closure */ - -NODE_DEFINE(SubsurfaceScatteringNode) -{ - NodeType *type = NodeType::add("subsurface_scattering", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum method_enum; - method_enum.insert("burley", CLOSURE_BSSRDF_BURLEY_ID); - method_enum.insert("random_walk_fixed_radius", CLOSURE_BSSRDF_RANDOM_WALK_FIXED_RADIUS_ID); - method_enum.insert("random_walk", CLOSURE_BSSRDF_RANDOM_WALK_ID); - SOCKET_ENUM(method, "Method", method_enum, CLOSURE_BSSRDF_RANDOM_WALK_ID); - - SOCKET_IN_FLOAT(scale, "Scale", 0.01f); - SOCKET_IN_VECTOR(radius, "Radius", make_float3(0.1f, 0.1f, 0.1f)); - - SOCKET_IN_FLOAT(subsurface_ior, "IOR", 1.4f); - SOCKET_IN_FLOAT(subsurface_anisotropy, "Anisotropy", 0.0f); - - SOCKET_OUT_CLOSURE(BSSRDF, "BSSRDF"); - - return type; -} - -SubsurfaceScatteringNode::SubsurfaceScatteringNode() : BsdfNode(get_node_type()) -{ - closure = method; -} - -void SubsurfaceScatteringNode::compile(SVMCompiler &compiler) -{ - closure = method; - BsdfNode::compile(compiler, input("Scale"), input("IOR"), input("Radius"), input("Anisotropy")); -} - -void SubsurfaceScatteringNode::compile(OSLCompiler &compiler) -{ - closure = method; - compiler.parameter(this, "method"); - compiler.add(this, "node_subsurface_scattering"); -} - -bool SubsurfaceScatteringNode::has_bssrdf_bump() -{ - /* detect if anything is plugged into the normal input besides the default */ - ShaderInput *normal_in = input("Normal"); - return (normal_in->link && - normal_in->link->parent->special_type != SHADER_SPECIAL_TYPE_GEOMETRY); -} - -/* Emissive Closure */ - -NODE_DEFINE(EmissionNode) -{ - NodeType *type = NodeType::add("emission", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_FLOAT(strength, "Strength", 10.0f); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(emission, "Emission"); - - return type; -} - -EmissionNode::EmissionNode() : ShaderNode(get_node_type()) -{ -} - -void EmissionNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *strength_in = input("Strength"); - - if (color_in->link || strength_in->link) { - compiler.add_node( - NODE_EMISSION_WEIGHT, compiler.stack_assign(color_in), compiler.stack_assign(strength_in)); - } - else - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, color * strength); - - compiler.add_node(NODE_CLOSURE_EMISSION, compiler.closure_mix_weight_offset()); -} - -void EmissionNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_emission"); -} - -void EmissionNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *strength_in = input("Strength"); - - if ((!color_in->link && color == zero_float3()) || (!strength_in->link && strength == 0.0f)) { - folder.discard(); - } -} - -/* Background Closure */ - -NODE_DEFINE(BackgroundNode) -{ - NodeType *type = NodeType::add("background_shader", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_FLOAT(strength, "Strength", 1.0f); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(background, "Background"); - - return type; -} - -BackgroundNode::BackgroundNode() : ShaderNode(get_node_type()) -{ -} - -void BackgroundNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *strength_in = input("Strength"); - - if (color_in->link || strength_in->link) { - compiler.add_node( - NODE_EMISSION_WEIGHT, compiler.stack_assign(color_in), compiler.stack_assign(strength_in)); - } - else - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, color * strength); - - compiler.add_node(NODE_CLOSURE_BACKGROUND, compiler.closure_mix_weight_offset()); -} - -void BackgroundNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_background"); -} - -void BackgroundNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *strength_in = input("Strength"); - - if ((!color_in->link && color == zero_float3()) || (!strength_in->link && strength == 0.0f)) { - folder.discard(); - } -} - -/* Holdout Closure */ - -NODE_DEFINE(HoldoutNode) -{ - NodeType *type = NodeType::add("holdout", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - SOCKET_IN_FLOAT(volume_mix_weight, "VolumeMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(holdout, "Holdout"); - - return type; -} - -HoldoutNode::HoldoutNode() : ShaderNode(get_node_type()) -{ -} - -void HoldoutNode::compile(SVMCompiler &compiler) -{ - float3 value = one_float3(); - - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, value); - compiler.add_node(NODE_CLOSURE_HOLDOUT, compiler.closure_mix_weight_offset()); -} - -void HoldoutNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_holdout"); -} - -/* Ambient Occlusion */ - -NODE_DEFINE(AmbientOcclusionNode) -{ - NodeType *type = NodeType::add("ambient_occlusion", create, NodeType::SHADER); - - SOCKET_INT(samples, "Samples", 16); - - SOCKET_IN_COLOR(color, "Color", one_float3()); - SOCKET_IN_FLOAT(distance, "Distance", 1.0f); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - - SOCKET_BOOLEAN(inside, "Inside", false); - SOCKET_BOOLEAN(only_local, "Only Local", false); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(ao, "AO"); - - return type; -} - -AmbientOcclusionNode::AmbientOcclusionNode() : ShaderNode(get_node_type()) -{ -} - -void AmbientOcclusionNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *distance_in = input("Distance"); - ShaderInput *normal_in = input("Normal"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *ao_out = output("AO"); - - int flags = (inside ? NODE_AO_INSIDE : 0) | (only_local ? NODE_AO_ONLY_LOCAL : 0); - - if (!distance_in->link && distance == 0.0f) { - flags |= NODE_AO_GLOBAL_RADIUS; - } - - compiler.add_node(NODE_AMBIENT_OCCLUSION, - compiler.encode_uchar4(flags, - compiler.stack_assign_if_linked(distance_in), - compiler.stack_assign_if_linked(normal_in), - compiler.stack_assign(ao_out)), - compiler.encode_uchar4(compiler.stack_assign(color_in), - compiler.stack_assign(color_out), - samples), - __float_as_uint(distance)); -} - -void AmbientOcclusionNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "samples"); - compiler.parameter(this, "inside"); - compiler.parameter(this, "only_local"); - compiler.add(this, "node_ambient_occlusion"); -} - -/* Volume Closure */ - -VolumeNode::VolumeNode(const NodeType *node_type) : ShaderNode(node_type) -{ - closure = CLOSURE_VOLUME_HENYEY_GREENSTEIN_ID; -} - -void VolumeNode::compile(SVMCompiler &compiler, ShaderInput *param1, ShaderInput *param2) -{ - ShaderInput *color_in = input("Color"); - - if (color_in->link) - compiler.add_node(NODE_CLOSURE_WEIGHT, compiler.stack_assign(color_in)); - else - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, color); - - compiler.add_node( - NODE_CLOSURE_VOLUME, - compiler.encode_uchar4(closure, - (param1) ? compiler.stack_assign(param1) : SVM_STACK_INVALID, - (param2) ? compiler.stack_assign(param2) : SVM_STACK_INVALID, - compiler.closure_mix_weight_offset()), - __float_as_int((param1) ? get_float(param1->socket_type) : 0.0f), - __float_as_int((param2) ? get_float(param2->socket_type) : 0.0f)); -} - -void VolumeNode::compile(SVMCompiler &compiler) -{ - compile(compiler, NULL, NULL); -} - -void VolumeNode::compile(OSLCompiler & /*compiler*/) -{ - assert(0); -} - -/* Absorption Volume Closure */ - -NODE_DEFINE(AbsorptionVolumeNode) -{ - NodeType *type = NodeType::add("absorption_volume", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_FLOAT(density, "Density", 1.0f); - SOCKET_IN_FLOAT(volume_mix_weight, "VolumeMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(volume, "Volume"); - - return type; -} - -AbsorptionVolumeNode::AbsorptionVolumeNode() : VolumeNode(get_node_type()) -{ - closure = CLOSURE_VOLUME_ABSORPTION_ID; -} - -void AbsorptionVolumeNode::compile(SVMCompiler &compiler) -{ - VolumeNode::compile(compiler, input("Density"), NULL); -} - -void AbsorptionVolumeNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_absorption_volume"); -} - -/* Scatter Volume Closure */ - -NODE_DEFINE(ScatterVolumeNode) -{ - NodeType *type = NodeType::add("scatter_volume", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_FLOAT(density, "Density", 1.0f); - SOCKET_IN_FLOAT(anisotropy, "Anisotropy", 0.0f); - SOCKET_IN_FLOAT(volume_mix_weight, "VolumeMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(volume, "Volume"); - - return type; -} - -ScatterVolumeNode::ScatterVolumeNode() : VolumeNode(get_node_type()) -{ - closure = CLOSURE_VOLUME_HENYEY_GREENSTEIN_ID; -} - -void ScatterVolumeNode::compile(SVMCompiler &compiler) -{ - VolumeNode::compile(compiler, input("Density"), input("Anisotropy")); -} - -void ScatterVolumeNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_scatter_volume"); -} - -/* Principled Volume Closure */ - -NODE_DEFINE(PrincipledVolumeNode) -{ - NodeType *type = NodeType::add("principled_volume", create, NodeType::SHADER); - - SOCKET_IN_STRING(density_attribute, "Density Attribute", ustring()); - SOCKET_IN_STRING(color_attribute, "Color Attribute", ustring()); - SOCKET_IN_STRING(temperature_attribute, "Temperature Attribute", ustring()); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.5f, 0.5f, 0.5f)); - SOCKET_IN_FLOAT(density, "Density", 1.0f); - SOCKET_IN_FLOAT(anisotropy, "Anisotropy", 0.0f); - SOCKET_IN_COLOR(absorption_color, "Absorption Color", zero_float3()); - SOCKET_IN_FLOAT(emission_strength, "Emission Strength", 0.0f); - SOCKET_IN_COLOR(emission_color, "Emission Color", one_float3()); - SOCKET_IN_FLOAT(blackbody_intensity, "Blackbody Intensity", 0.0f); - SOCKET_IN_COLOR(blackbody_tint, "Blackbody Tint", one_float3()); - SOCKET_IN_FLOAT(temperature, "Temperature", 1000.0f); - SOCKET_IN_FLOAT(volume_mix_weight, "VolumeMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(volume, "Volume"); - - return type; -} - -PrincipledVolumeNode::PrincipledVolumeNode() : VolumeNode(get_node_type()) -{ - closure = CLOSURE_VOLUME_HENYEY_GREENSTEIN_ID; - density_attribute = ustring("density"); - temperature_attribute = ustring("temperature"); -} - -void PrincipledVolumeNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_volume) { - ShaderInput *density_in = input("Density"); - ShaderInput *blackbody_in = input("Blackbody Intensity"); - - if (density_in->link || density > 0.0f) { - attributes->add_standard(density_attribute); - attributes->add_standard(color_attribute); - } - - if (blackbody_in->link || blackbody_intensity > 0.0f) { - attributes->add_standard(temperature_attribute); - } - - attributes->add(ATTR_STD_GENERATED_TRANSFORM); - } - - ShaderNode::attributes(shader, attributes); -} - -void PrincipledVolumeNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *density_in = input("Density"); - ShaderInput *anisotropy_in = input("Anisotropy"); - ShaderInput *absorption_color_in = input("Absorption Color"); - ShaderInput *emission_in = input("Emission Strength"); - ShaderInput *emission_color_in = input("Emission Color"); - ShaderInput *blackbody_in = input("Blackbody Intensity"); - ShaderInput *blackbody_tint_in = input("Blackbody Tint"); - ShaderInput *temperature_in = input("Temperature"); - - if (color_in->link) - compiler.add_node(NODE_CLOSURE_WEIGHT, compiler.stack_assign(color_in)); - else - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, color); - - compiler.add_node(NODE_PRINCIPLED_VOLUME, - compiler.encode_uchar4(compiler.stack_assign_if_linked(density_in), - compiler.stack_assign_if_linked(anisotropy_in), - compiler.stack_assign(absorption_color_in), - compiler.closure_mix_weight_offset()), - compiler.encode_uchar4(compiler.stack_assign_if_linked(emission_in), - compiler.stack_assign(emission_color_in), - compiler.stack_assign_if_linked(blackbody_in), - compiler.stack_assign(temperature_in)), - compiler.stack_assign(blackbody_tint_in)); - - int attr_density = compiler.attribute_standard(density_attribute); - int attr_color = compiler.attribute_standard(color_attribute); - int attr_temperature = compiler.attribute_standard(temperature_attribute); - - compiler.add_node(__float_as_int(density), - __float_as_int(anisotropy), - __float_as_int(emission_strength), - __float_as_int(blackbody_intensity)); - - compiler.add_node(attr_density, attr_color, attr_temperature); -} - -void PrincipledVolumeNode::compile(OSLCompiler &compiler) -{ - if (Attribute::name_standard(density_attribute.c_str())) { - density_attribute = ustring("geom:" + density_attribute.string()); - } - if (Attribute::name_standard(color_attribute.c_str())) { - color_attribute = ustring("geom:" + color_attribute.string()); - } - if (Attribute::name_standard(temperature_attribute.c_str())) { - temperature_attribute = ustring("geom:" + temperature_attribute.string()); - } - - compiler.add(this, "node_principled_volume"); -} - -/* Principled Hair BSDF Closure */ - -NODE_DEFINE(PrincipledHairBsdfNode) -{ - NodeType *type = NodeType::add("principled_hair_bsdf", create, NodeType::SHADER); - - /* Color parametrization specified as enum. */ - static NodeEnum parametrization_enum; - parametrization_enum.insert("Direct coloring", NODE_PRINCIPLED_HAIR_REFLECTANCE); - parametrization_enum.insert("Melanin concentration", NODE_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION); - parametrization_enum.insert("Absorption coefficient", NODE_PRINCIPLED_HAIR_DIRECT_ABSORPTION); - SOCKET_ENUM( - parametrization, "Parametrization", parametrization_enum, NODE_PRINCIPLED_HAIR_REFLECTANCE); - - /* Initialize sockets to their default values. */ - SOCKET_IN_COLOR(color, "Color", make_float3(0.017513f, 0.005763f, 0.002059f)); - SOCKET_IN_FLOAT(melanin, "Melanin", 0.8f); - SOCKET_IN_FLOAT(melanin_redness, "Melanin Redness", 1.0f); - SOCKET_IN_COLOR(tint, "Tint", make_float3(1.f, 1.f, 1.f)); - SOCKET_IN_VECTOR(absorption_coefficient, - "Absorption Coefficient", - make_float3(0.245531f, 0.52f, 1.365f), - SocketType::VECTOR); - - SOCKET_IN_FLOAT(offset, "Offset", 2.f * M_PI_F / 180.f); - SOCKET_IN_FLOAT(roughness, "Roughness", 0.3f); - SOCKET_IN_FLOAT(radial_roughness, "Radial Roughness", 0.3f); - SOCKET_IN_FLOAT(coat, "Coat", 0.0f); - SOCKET_IN_FLOAT(ior, "IOR", 1.55f); - - SOCKET_IN_FLOAT(random_roughness, "Random Roughness", 0.0f); - SOCKET_IN_FLOAT(random_color, "Random Color", 0.0f); - SOCKET_IN_FLOAT(random, "Random", 0.0f); - - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -PrincipledHairBsdfNode::PrincipledHairBsdfNode() : BsdfBaseNode(get_node_type()) -{ - closure = CLOSURE_BSDF_HAIR_PRINCIPLED_ID; -} - -/* Enable retrieving Hair Info -> Random if Random isn't linked. */ -void PrincipledHairBsdfNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (!input("Random")->link) { - attributes->add(ATTR_STD_CURVE_RANDOM); - } - ShaderNode::attributes(shader, attributes); -} - -/* Prepares the input data for the SVM shader. */ -void PrincipledHairBsdfNode::compile(SVMCompiler &compiler) -{ - compiler.add_node(NODE_CLOSURE_SET_WEIGHT, one_float3()); - - ShaderInput *roughness_in = input("Roughness"); - ShaderInput *radial_roughness_in = input("Radial Roughness"); - ShaderInput *random_roughness_in = input("Random Roughness"); - ShaderInput *offset_in = input("Offset"); - ShaderInput *coat_in = input("Coat"); - ShaderInput *ior_in = input("IOR"); - ShaderInput *melanin_in = input("Melanin"); - ShaderInput *melanin_redness_in = input("Melanin Redness"); - ShaderInput *random_color_in = input("Random Color"); - - int color_ofs = compiler.stack_assign(input("Color")); - int tint_ofs = compiler.stack_assign(input("Tint")); - int absorption_coefficient_ofs = compiler.stack_assign(input("Absorption Coefficient")); - - ShaderInput *random_in = input("Random"); - int attr_random = random_in->link ? SVM_STACK_INVALID : - compiler.attribute(ATTR_STD_CURVE_RANDOM); - - /* Encode all parameters into data nodes. */ - compiler.add_node(NODE_CLOSURE_BSDF, - /* Socket IDs can be packed 4 at a time into a single data packet */ - compiler.encode_uchar4(closure, - compiler.stack_assign_if_linked(roughness_in), - compiler.stack_assign_if_linked(radial_roughness_in), - compiler.closure_mix_weight_offset()), - /* The rest are stored as unsigned integers */ - __float_as_uint(roughness), - __float_as_uint(radial_roughness)); - - compiler.add_node(compiler.stack_assign_if_linked(input("Normal")), - compiler.encode_uchar4(compiler.stack_assign_if_linked(offset_in), - compiler.stack_assign_if_linked(ior_in), - color_ofs, - parametrization), - __float_as_uint(offset), - __float_as_uint(ior)); - - compiler.add_node(compiler.encode_uchar4(compiler.stack_assign_if_linked(coat_in), - compiler.stack_assign_if_linked(melanin_in), - compiler.stack_assign_if_linked(melanin_redness_in), - absorption_coefficient_ofs), - __float_as_uint(coat), - __float_as_uint(melanin), - __float_as_uint(melanin_redness)); - - compiler.add_node(compiler.encode_uchar4(tint_ofs, - compiler.stack_assign_if_linked(random_in), - compiler.stack_assign_if_linked(random_color_in), - compiler.stack_assign_if_linked(random_roughness_in)), - __float_as_uint(random), - __float_as_uint(random_color), - __float_as_uint(random_roughness)); - - compiler.add_node( - compiler.encode_uchar4( - SVM_STACK_INVALID, SVM_STACK_INVALID, SVM_STACK_INVALID, SVM_STACK_INVALID), - attr_random, - SVM_STACK_INVALID, - SVM_STACK_INVALID); -} - -/* Prepares the input data for the OSL shader. */ -void PrincipledHairBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "parametrization"); - compiler.add(this, "node_principled_hair_bsdf"); -} - -/* Hair BSDF Closure */ - -NODE_DEFINE(HairBsdfNode) -{ - NodeType *type = NodeType::add("hair_bsdf", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", make_float3(0.8f, 0.8f, 0.8f)); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(surface_mix_weight, "SurfaceMixWeight", 0.0f, SocketType::SVM_INTERNAL); - - static NodeEnum component_enum; - component_enum.insert("reflection", CLOSURE_BSDF_HAIR_REFLECTION_ID); - component_enum.insert("transmission", CLOSURE_BSDF_HAIR_TRANSMISSION_ID); - SOCKET_ENUM(component, "Component", component_enum, CLOSURE_BSDF_HAIR_REFLECTION_ID); - SOCKET_IN_FLOAT(offset, "Offset", 0.0f); - SOCKET_IN_FLOAT(roughness_u, "RoughnessU", 0.2f); - SOCKET_IN_FLOAT(roughness_v, "RoughnessV", 0.2f); - SOCKET_IN_VECTOR(tangent, "Tangent", zero_float3()); - - SOCKET_OUT_CLOSURE(BSDF, "BSDF"); - - return type; -} - -HairBsdfNode::HairBsdfNode() : BsdfNode(get_node_type()) -{ - closure = CLOSURE_BSDF_HAIR_REFLECTION_ID; -} - -void HairBsdfNode::compile(SVMCompiler &compiler) -{ - closure = component; - - BsdfNode::compile(compiler, input("RoughnessU"), input("RoughnessV"), input("Offset")); -} - -void HairBsdfNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "component"); - compiler.add(this, "node_hair_bsdf"); -} - -/* Geometry */ - -NODE_DEFINE(GeometryNode) -{ - NodeType *type = NodeType::add("geometry", create, NodeType::SHADER); - - SOCKET_IN_NORMAL( - normal_osl, "NormalIn", zero_float3(), SocketType::LINK_NORMAL | SocketType::OSL_INTERNAL); - - SOCKET_OUT_POINT(position, "Position"); - SOCKET_OUT_NORMAL(normal, "Normal"); - SOCKET_OUT_NORMAL(tangent, "Tangent"); - SOCKET_OUT_NORMAL(true_normal, "True Normal"); - SOCKET_OUT_VECTOR(incoming, "Incoming"); - SOCKET_OUT_POINT(parametric, "Parametric"); - SOCKET_OUT_FLOAT(backfacing, "Backfacing"); - SOCKET_OUT_FLOAT(pointiness, "Pointiness"); - SOCKET_OUT_FLOAT(random_per_island, "Random Per Island"); - - return type; -} - -GeometryNode::GeometryNode() : ShaderNode(get_node_type()) -{ - special_type = SHADER_SPECIAL_TYPE_GEOMETRY; -} - -void GeometryNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link()) { - if (!output("Tangent")->links.empty()) { - attributes->add(ATTR_STD_GENERATED); - } - if (!output("Pointiness")->links.empty()) { - attributes->add(ATTR_STD_POINTINESS); - } - if (!output("Random Per Island")->links.empty()) { - attributes->add(ATTR_STD_RANDOM_PER_ISLAND); - } - } - - ShaderNode::attributes(shader, attributes); -} - -void GeometryNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out; - ShaderNodeType geom_node = NODE_GEOMETRY; - ShaderNodeType attr_node = NODE_ATTR; - - if (bump == SHADER_BUMP_DX) { - geom_node = NODE_GEOMETRY_BUMP_DX; - attr_node = NODE_ATTR_BUMP_DX; - } - else if (bump == SHADER_BUMP_DY) { - geom_node = NODE_GEOMETRY_BUMP_DY; - attr_node = NODE_ATTR_BUMP_DY; - } - - out = output("Position"); - if (!out->links.empty()) { - compiler.add_node(geom_node, NODE_GEOM_P, compiler.stack_assign(out)); - } - - out = output("Normal"); - if (!out->links.empty()) { - compiler.add_node(geom_node, NODE_GEOM_N, compiler.stack_assign(out)); - } - - out = output("Tangent"); - if (!out->links.empty()) { - compiler.add_node(geom_node, NODE_GEOM_T, compiler.stack_assign(out)); - } - - out = output("True Normal"); - if (!out->links.empty()) { - compiler.add_node(geom_node, NODE_GEOM_Ng, compiler.stack_assign(out)); - } - - out = output("Incoming"); - if (!out->links.empty()) { - compiler.add_node(geom_node, NODE_GEOM_I, compiler.stack_assign(out)); - } - - out = output("Parametric"); - if (!out->links.empty()) { - compiler.add_node(geom_node, NODE_GEOM_uv, compiler.stack_assign(out)); - } - - out = output("Backfacing"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_backfacing, compiler.stack_assign(out)); - } - - out = output("Pointiness"); - if (!out->links.empty()) { - if (compiler.output_type() != SHADER_TYPE_VOLUME) { - compiler.add_node( - attr_node, ATTR_STD_POINTINESS, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT); - } - else { - compiler.add_node(NODE_VALUE_F, __float_as_int(0.0f), compiler.stack_assign(out)); - } - } - - out = output("Random Per Island"); - if (!out->links.empty()) { - if (compiler.output_type() != SHADER_TYPE_VOLUME) { - compiler.add_node(attr_node, - ATTR_STD_RANDOM_PER_ISLAND, - compiler.stack_assign(out), - NODE_ATTR_OUTPUT_FLOAT); - } - else { - compiler.add_node(NODE_VALUE_F, __float_as_int(0.0f), compiler.stack_assign(out)); - } - } -} - -void GeometryNode::compile(OSLCompiler &compiler) -{ - if (bump == SHADER_BUMP_DX) - compiler.parameter("bump_offset", "dx"); - else if (bump == SHADER_BUMP_DY) - compiler.parameter("bump_offset", "dy"); - else - compiler.parameter("bump_offset", "center"); - - compiler.add(this, "node_geometry"); -} - -/* TextureCoordinate */ - -NODE_DEFINE(TextureCoordinateNode) -{ - NodeType *type = NodeType::add("texture_coordinate", create, NodeType::SHADER); - - SOCKET_BOOLEAN(from_dupli, "From Dupli", false); - SOCKET_BOOLEAN(use_transform, "Use Transform", false); - SOCKET_TRANSFORM(ob_tfm, "Object Transform", transform_identity()); - - SOCKET_IN_NORMAL( - normal_osl, "NormalIn", zero_float3(), SocketType::LINK_NORMAL | SocketType::OSL_INTERNAL); - - SOCKET_OUT_POINT(generated, "Generated"); - SOCKET_OUT_NORMAL(normal, "Normal"); - SOCKET_OUT_POINT(UV, "UV"); - SOCKET_OUT_POINT(object, "Object"); - SOCKET_OUT_POINT(camera, "Camera"); - SOCKET_OUT_POINT(window, "Window"); - SOCKET_OUT_NORMAL(reflection, "Reflection"); - - return type; -} - -TextureCoordinateNode::TextureCoordinateNode() : ShaderNode(get_node_type()) -{ -} - -void TextureCoordinateNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link()) { - if (!from_dupli) { - if (!output("Generated")->links.empty()) - attributes->add(ATTR_STD_GENERATED); - if (!output("UV")->links.empty()) - attributes->add(ATTR_STD_UV); - } - } - - if (shader->has_volume) { - if (!from_dupli) { - if (!output("Generated")->links.empty()) { - attributes->add(ATTR_STD_GENERATED_TRANSFORM); - } - } - } - - ShaderNode::attributes(shader, attributes); -} - -void TextureCoordinateNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out; - ShaderNodeType texco_node = NODE_TEX_COORD; - ShaderNodeType attr_node = NODE_ATTR; - ShaderNodeType geom_node = NODE_GEOMETRY; - - if (bump == SHADER_BUMP_DX) { - texco_node = NODE_TEX_COORD_BUMP_DX; - attr_node = NODE_ATTR_BUMP_DX; - geom_node = NODE_GEOMETRY_BUMP_DX; - } - else if (bump == SHADER_BUMP_DY) { - texco_node = NODE_TEX_COORD_BUMP_DY; - attr_node = NODE_ATTR_BUMP_DY; - geom_node = NODE_GEOMETRY_BUMP_DY; - } - - out = output("Generated"); - if (!out->links.empty()) { - if (compiler.background) { - compiler.add_node(geom_node, NODE_GEOM_P, compiler.stack_assign(out)); - } - else { - if (from_dupli) { - compiler.add_node(texco_node, NODE_TEXCO_DUPLI_GENERATED, compiler.stack_assign(out)); - } - else if (compiler.output_type() == SHADER_TYPE_VOLUME) { - compiler.add_node(texco_node, NODE_TEXCO_VOLUME_GENERATED, compiler.stack_assign(out)); - } - else { - int attr = compiler.attribute(ATTR_STD_GENERATED); - compiler.add_node(attr_node, attr, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT3); - } - } - } - - out = output("Normal"); - if (!out->links.empty()) { - compiler.add_node(texco_node, NODE_TEXCO_NORMAL, compiler.stack_assign(out)); - } - - out = output("UV"); - if (!out->links.empty()) { - if (from_dupli) { - compiler.add_node(texco_node, NODE_TEXCO_DUPLI_UV, compiler.stack_assign(out)); - } - else { - int attr = compiler.attribute(ATTR_STD_UV); - compiler.add_node(attr_node, attr, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT3); - } - } - - out = output("Object"); - if (!out->links.empty()) { - compiler.add_node(texco_node, NODE_TEXCO_OBJECT, compiler.stack_assign(out), use_transform); - if (use_transform) { - Transform ob_itfm = transform_inverse(ob_tfm); - compiler.add_node(ob_itfm.x); - compiler.add_node(ob_itfm.y); - compiler.add_node(ob_itfm.z); - } - } - - out = output("Camera"); - if (!out->links.empty()) { - compiler.add_node(texco_node, NODE_TEXCO_CAMERA, compiler.stack_assign(out)); - } - - out = output("Window"); - if (!out->links.empty()) { - compiler.add_node(texco_node, NODE_TEXCO_WINDOW, compiler.stack_assign(out)); - } - - out = output("Reflection"); - if (!out->links.empty()) { - if (compiler.background) { - compiler.add_node(geom_node, NODE_GEOM_I, compiler.stack_assign(out)); - } - else { - compiler.add_node(texco_node, NODE_TEXCO_REFLECTION, compiler.stack_assign(out)); - } - } -} - -void TextureCoordinateNode::compile(OSLCompiler &compiler) -{ - if (bump == SHADER_BUMP_DX) - compiler.parameter("bump_offset", "dx"); - else if (bump == SHADER_BUMP_DY) - compiler.parameter("bump_offset", "dy"); - else - compiler.parameter("bump_offset", "center"); - - if (compiler.background) - compiler.parameter("is_background", true); - if (compiler.output_type() == SHADER_TYPE_VOLUME) - compiler.parameter("is_volume", true); - compiler.parameter(this, "use_transform"); - Transform ob_itfm = transform_inverse(ob_tfm); - compiler.parameter("object_itfm", ob_itfm); - - compiler.parameter(this, "from_dupli"); - - compiler.add(this, "node_texture_coordinate"); -} - -/* UV Map */ - -NODE_DEFINE(UVMapNode) -{ - NodeType *type = NodeType::add("uvmap", create, NodeType::SHADER); - - SOCKET_STRING(attribute, "attribute", ustring()); - SOCKET_IN_BOOLEAN(from_dupli, "from dupli", false); - - SOCKET_OUT_POINT(UV, "UV"); - - return type; -} - -UVMapNode::UVMapNode() : ShaderNode(get_node_type()) -{ -} - -void UVMapNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface) { - if (!from_dupli) { - if (!output("UV")->links.empty()) { - if (attribute != "") - attributes->add(attribute); - else - attributes->add(ATTR_STD_UV); - } - } - } - - ShaderNode::attributes(shader, attributes); -} - -void UVMapNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out = output("UV"); - ShaderNodeType texco_node = NODE_TEX_COORD; - ShaderNodeType attr_node = NODE_ATTR; - int attr; - - if (bump == SHADER_BUMP_DX) { - texco_node = NODE_TEX_COORD_BUMP_DX; - attr_node = NODE_ATTR_BUMP_DX; - } - else if (bump == SHADER_BUMP_DY) { - texco_node = NODE_TEX_COORD_BUMP_DY; - attr_node = NODE_ATTR_BUMP_DY; - } - - if (!out->links.empty()) { - if (from_dupli) { - compiler.add_node(texco_node, NODE_TEXCO_DUPLI_UV, compiler.stack_assign(out)); - } - else { - if (attribute != "") - attr = compiler.attribute(attribute); - else - attr = compiler.attribute(ATTR_STD_UV); - - compiler.add_node(attr_node, attr, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT3); - } - } -} - -void UVMapNode::compile(OSLCompiler &compiler) -{ - if (bump == SHADER_BUMP_DX) - compiler.parameter("bump_offset", "dx"); - else if (bump == SHADER_BUMP_DY) - compiler.parameter("bump_offset", "dy"); - else - compiler.parameter("bump_offset", "center"); - - compiler.parameter(this, "from_dupli"); - compiler.parameter(this, "attribute"); - compiler.add(this, "node_uv_map"); -} - -/* Light Path */ - -NODE_DEFINE(LightPathNode) -{ - NodeType *type = NodeType::add("light_path", create, NodeType::SHADER); - - SOCKET_OUT_FLOAT(is_camera_ray, "Is Camera Ray"); - SOCKET_OUT_FLOAT(is_shadow_ray, "Is Shadow Ray"); - SOCKET_OUT_FLOAT(is_diffuse_ray, "Is Diffuse Ray"); - SOCKET_OUT_FLOAT(is_glossy_ray, "Is Glossy Ray"); - SOCKET_OUT_FLOAT(is_singular_ray, "Is Singular Ray"); - SOCKET_OUT_FLOAT(is_reflection_ray, "Is Reflection Ray"); - SOCKET_OUT_FLOAT(is_transmission_ray, "Is Transmission Ray"); - SOCKET_OUT_FLOAT(is_volume_scatter_ray, "Is Volume Scatter Ray"); - SOCKET_OUT_FLOAT(ray_length, "Ray Length"); - SOCKET_OUT_FLOAT(ray_depth, "Ray Depth"); - SOCKET_OUT_FLOAT(diffuse_depth, "Diffuse Depth"); - SOCKET_OUT_FLOAT(glossy_depth, "Glossy Depth"); - SOCKET_OUT_FLOAT(transparent_depth, "Transparent Depth"); - SOCKET_OUT_FLOAT(transmission_depth, "Transmission Depth"); - - return type; -} - -LightPathNode::LightPathNode() : ShaderNode(get_node_type()) -{ -} - -void LightPathNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out; - - out = output("Is Camera Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_camera, compiler.stack_assign(out)); - } - - out = output("Is Shadow Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_shadow, compiler.stack_assign(out)); - } - - out = output("Is Diffuse Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_diffuse, compiler.stack_assign(out)); - } - - out = output("Is Glossy Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_glossy, compiler.stack_assign(out)); - } - - out = output("Is Singular Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_singular, compiler.stack_assign(out)); - } - - out = output("Is Reflection Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_reflection, compiler.stack_assign(out)); - } - - out = output("Is Transmission Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_transmission, compiler.stack_assign(out)); - } - - out = output("Is Volume Scatter Ray"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_volume_scatter, compiler.stack_assign(out)); - } - - out = output("Ray Length"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_length, compiler.stack_assign(out)); - } - - out = output("Ray Depth"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_depth, compiler.stack_assign(out)); - } - - out = output("Diffuse Depth"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_diffuse, compiler.stack_assign(out)); - } - - out = output("Glossy Depth"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_glossy, compiler.stack_assign(out)); - } - - out = output("Transparent Depth"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_transparent, compiler.stack_assign(out)); - } - - out = output("Transmission Depth"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_PATH, NODE_LP_ray_transmission, compiler.stack_assign(out)); - } -} - -void LightPathNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_light_path"); -} - -/* Light Falloff */ - -NODE_DEFINE(LightFalloffNode) -{ - NodeType *type = NodeType::add("light_falloff", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(strength, "Strength", 100.0f); - SOCKET_IN_FLOAT(smooth, "Smooth", 0.0f); - - SOCKET_OUT_FLOAT(quadratic, "Quadratic"); - SOCKET_OUT_FLOAT(linear, "Linear"); - SOCKET_OUT_FLOAT(constant, "Constant"); - - return type; -} - -LightFalloffNode::LightFalloffNode() : ShaderNode(get_node_type()) -{ -} - -void LightFalloffNode::compile(SVMCompiler &compiler) -{ - ShaderInput *strength_in = input("Strength"); - ShaderInput *smooth_in = input("Smooth"); - - ShaderOutput *out = output("Quadratic"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_FALLOFF, - NODE_LIGHT_FALLOFF_QUADRATIC, - compiler.encode_uchar4(compiler.stack_assign(strength_in), - compiler.stack_assign(smooth_in), - compiler.stack_assign(out))); - } - - out = output("Linear"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_FALLOFF, - NODE_LIGHT_FALLOFF_LINEAR, - compiler.encode_uchar4(compiler.stack_assign(strength_in), - compiler.stack_assign(smooth_in), - compiler.stack_assign(out))); - } - - out = output("Constant"); - if (!out->links.empty()) { - compiler.add_node(NODE_LIGHT_FALLOFF, - NODE_LIGHT_FALLOFF_CONSTANT, - compiler.encode_uchar4(compiler.stack_assign(strength_in), - compiler.stack_assign(smooth_in), - compiler.stack_assign(out))); - } -} - -void LightFalloffNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_light_falloff"); -} - -/* Object Info */ - -NODE_DEFINE(ObjectInfoNode) -{ - NodeType *type = NodeType::add("object_info", create, NodeType::SHADER); - - SOCKET_OUT_VECTOR(location, "Location"); - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(object_index, "Object Index"); - SOCKET_OUT_FLOAT(material_index, "Material Index"); - SOCKET_OUT_FLOAT(random, "Random"); - - return type; -} - -ObjectInfoNode::ObjectInfoNode() : ShaderNode(get_node_type()) -{ -} - -void ObjectInfoNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out = output("Location"); - if (!out->links.empty()) { - compiler.add_node(NODE_OBJECT_INFO, NODE_INFO_OB_LOCATION, compiler.stack_assign(out)); - } - - out = output("Color"); - if (!out->links.empty()) { - compiler.add_node(NODE_OBJECT_INFO, NODE_INFO_OB_COLOR, compiler.stack_assign(out)); - } - - out = output("Object Index"); - if (!out->links.empty()) { - compiler.add_node(NODE_OBJECT_INFO, NODE_INFO_OB_INDEX, compiler.stack_assign(out)); - } - - out = output("Material Index"); - if (!out->links.empty()) { - compiler.add_node(NODE_OBJECT_INFO, NODE_INFO_MAT_INDEX, compiler.stack_assign(out)); - } - - out = output("Random"); - if (!out->links.empty()) { - compiler.add_node(NODE_OBJECT_INFO, NODE_INFO_OB_RANDOM, compiler.stack_assign(out)); - } -} - -void ObjectInfoNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_object_info"); -} - -/* Particle Info */ - -NODE_DEFINE(ParticleInfoNode) -{ - NodeType *type = NodeType::add("particle_info", create, NodeType::SHADER); - - SOCKET_OUT_FLOAT(index, "Index"); - SOCKET_OUT_FLOAT(random, "Random"); - SOCKET_OUT_FLOAT(age, "Age"); - SOCKET_OUT_FLOAT(lifetime, "Lifetime"); - SOCKET_OUT_POINT(location, "Location"); -#if 0 /* not yet supported */ - SOCKET_OUT_QUATERNION(rotation, "Rotation"); -#endif - SOCKET_OUT_FLOAT(size, "Size"); - SOCKET_OUT_VECTOR(velocity, "Velocity"); - SOCKET_OUT_VECTOR(angular_velocity, "Angular Velocity"); - - return type; -} - -ParticleInfoNode::ParticleInfoNode() : ShaderNode(get_node_type()) -{ -} - -void ParticleInfoNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (!output("Index")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - if (!output("Random")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - if (!output("Age")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - if (!output("Lifetime")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - if (!output("Location")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); -#if 0 /* not yet supported */ - if (!output("Rotation")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); -#endif - if (!output("Size")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - if (!output("Velocity")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - if (!output("Angular Velocity")->links.empty()) - attributes->add(ATTR_STD_PARTICLE); - - ShaderNode::attributes(shader, attributes); -} - -void ParticleInfoNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out; - - out = output("Index"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_INDEX, compiler.stack_assign(out)); - } - - out = output("Random"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_RANDOM, compiler.stack_assign(out)); - } - - out = output("Age"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_AGE, compiler.stack_assign(out)); - } - - out = output("Lifetime"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_LIFETIME, compiler.stack_assign(out)); - } - - out = output("Location"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_LOCATION, compiler.stack_assign(out)); - } - - /* quaternion data is not yet supported by Cycles */ -#if 0 - out = output("Rotation"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_ROTATION, compiler.stack_assign(out)); - } -#endif - - out = output("Size"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_SIZE, compiler.stack_assign(out)); - } - - out = output("Velocity"); - if (!out->links.empty()) { - compiler.add_node(NODE_PARTICLE_INFO, NODE_INFO_PAR_VELOCITY, compiler.stack_assign(out)); - } - - out = output("Angular Velocity"); - if (!out->links.empty()) { - compiler.add_node( - NODE_PARTICLE_INFO, NODE_INFO_PAR_ANGULAR_VELOCITY, compiler.stack_assign(out)); - } -} - -void ParticleInfoNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_particle_info"); -} - -/* Hair Info */ - -NODE_DEFINE(HairInfoNode) -{ - NodeType *type = NodeType::add("hair_info", create, NodeType::SHADER); - - SOCKET_OUT_FLOAT(is_strand, "Is Strand"); - SOCKET_OUT_FLOAT(intercept, "Intercept"); - SOCKET_OUT_FLOAT(size, "Length"); - SOCKET_OUT_FLOAT(thickness, "Thickness"); - SOCKET_OUT_NORMAL(tangent_normal, "Tangent Normal"); -#if 0 /* Output for minimum hair width transparency - deactivated. */ - SOCKET_OUT_FLOAT(fade, "Fade"); -#endif - SOCKET_OUT_FLOAT(index, "Random"); - - return type; -} - -HairInfoNode::HairInfoNode() : ShaderNode(get_node_type()) -{ -} - -void HairInfoNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link()) { - ShaderOutput *intercept_out = output("Intercept"); - - if (!intercept_out->links.empty()) - attributes->add(ATTR_STD_CURVE_INTERCEPT); - - if (!output("Length")->links.empty()) - attributes->add(ATTR_STD_CURVE_LENGTH); - - if (!output("Random")->links.empty()) - attributes->add(ATTR_STD_CURVE_RANDOM); - } - - ShaderNode::attributes(shader, attributes); -} - -void HairInfoNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *out; - - out = output("Is Strand"); - if (!out->links.empty()) { - compiler.add_node(NODE_HAIR_INFO, NODE_INFO_CURVE_IS_STRAND, compiler.stack_assign(out)); - } - - out = output("Intercept"); - if (!out->links.empty()) { - int attr = compiler.attribute(ATTR_STD_CURVE_INTERCEPT); - compiler.add_node(NODE_ATTR, attr, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT); - } - - out = output("Length"); - if (!out->links.empty()) { - int attr = compiler.attribute(ATTR_STD_CURVE_LENGTH); - compiler.add_node(NODE_ATTR, attr, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT); - } - - out = output("Thickness"); - if (!out->links.empty()) { - compiler.add_node(NODE_HAIR_INFO, NODE_INFO_CURVE_THICKNESS, compiler.stack_assign(out)); - } - - out = output("Tangent Normal"); - if (!out->links.empty()) { - compiler.add_node(NODE_HAIR_INFO, NODE_INFO_CURVE_TANGENT_NORMAL, compiler.stack_assign(out)); - } -#if 0 - out = output("Fade"); - if(!out->links.empty()) { - compiler.add_node(NODE_HAIR_INFO, NODE_INFO_CURVE_FADE, compiler.stack_assign(out)); - } -#endif - out = output("Random"); - if (!out->links.empty()) { - int attr = compiler.attribute(ATTR_STD_CURVE_RANDOM); - compiler.add_node(NODE_ATTR, attr, compiler.stack_assign(out), NODE_ATTR_OUTPUT_FLOAT); - } -} - -void HairInfoNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_hair_info"); -} - -/* Volume Info */ - -NODE_DEFINE(VolumeInfoNode) -{ - NodeType *type = NodeType::add("volume_info", create, NodeType::SHADER); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(density, "Density"); - SOCKET_OUT_FLOAT(flame, "Flame"); - SOCKET_OUT_FLOAT(temperature, "Temperature"); - - return type; -} - -VolumeInfoNode::VolumeInfoNode() : ShaderNode(get_node_type()) -{ -} - -/* The requested attributes are not updated after node expansion. - * So we explicitly request the required attributes. - */ -void VolumeInfoNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_volume) { - if (!output("Color")->links.empty()) { - attributes->add(ATTR_STD_VOLUME_COLOR); - } - if (!output("Density")->links.empty()) { - attributes->add(ATTR_STD_VOLUME_DENSITY); - } - if (!output("Flame")->links.empty()) { - attributes->add(ATTR_STD_VOLUME_FLAME); - } - if (!output("Temperature")->links.empty()) { - attributes->add(ATTR_STD_VOLUME_TEMPERATURE); - } - attributes->add(ATTR_STD_GENERATED_TRANSFORM); - } - ShaderNode::attributes(shader, attributes); -} - -void VolumeInfoNode::expand(ShaderGraph *graph) -{ - ShaderOutput *color_out = output("Color"); - if (!color_out->links.empty()) { - AttributeNode *attr = graph->create_node<AttributeNode>(); - attr->set_attribute(ustring("color")); - graph->add(attr); - graph->relink(color_out, attr->output("Color")); - } - - ShaderOutput *density_out = output("Density"); - if (!density_out->links.empty()) { - AttributeNode *attr = graph->create_node<AttributeNode>(); - attr->set_attribute(ustring("density")); - graph->add(attr); - graph->relink(density_out, attr->output("Fac")); - } - - ShaderOutput *flame_out = output("Flame"); - if (!flame_out->links.empty()) { - AttributeNode *attr = graph->create_node<AttributeNode>(); - attr->set_attribute(ustring("flame")); - graph->add(attr); - graph->relink(flame_out, attr->output("Fac")); - } - - ShaderOutput *temperature_out = output("Temperature"); - if (!temperature_out->links.empty()) { - AttributeNode *attr = graph->create_node<AttributeNode>(); - attr->set_attribute(ustring("temperature")); - graph->add(attr); - graph->relink(temperature_out, attr->output("Fac")); - } -} - -void VolumeInfoNode::compile(SVMCompiler &) -{ -} - -void VolumeInfoNode::compile(OSLCompiler &) -{ -} - -NODE_DEFINE(VertexColorNode) -{ - NodeType *type = NodeType::add("vertex_color", create, NodeType::SHADER); - - SOCKET_STRING(layer_name, "Layer Name", ustring()); - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(alpha, "Alpha"); - - return type; -} - -VertexColorNode::VertexColorNode() : ShaderNode(get_node_type()) -{ -} - -void VertexColorNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (!(output("Color")->links.empty() && output("Alpha")->links.empty())) { - if (layer_name != "") - attributes->add_standard(layer_name); - else - attributes->add(ATTR_STD_VERTEX_COLOR); - } - ShaderNode::attributes(shader, attributes); -} - -void VertexColorNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *color_out = output("Color"); - ShaderOutput *alpha_out = output("Alpha"); - int layer_id = 0; - - if (layer_name != "") { - layer_id = compiler.attribute(layer_name); - } - else { - layer_id = compiler.attribute(ATTR_STD_VERTEX_COLOR); - } - - ShaderNodeType node; - - if (bump == SHADER_BUMP_DX) - node = NODE_VERTEX_COLOR_BUMP_DX; - else if (bump == SHADER_BUMP_DY) - node = NODE_VERTEX_COLOR_BUMP_DY; - else { - node = NODE_VERTEX_COLOR; - } - - compiler.add_node( - node, layer_id, compiler.stack_assign(color_out), compiler.stack_assign(alpha_out)); -} - -void VertexColorNode::compile(OSLCompiler &compiler) -{ - if (bump == SHADER_BUMP_DX) { - compiler.parameter("bump_offset", "dx"); - } - else if (bump == SHADER_BUMP_DY) { - compiler.parameter("bump_offset", "dy"); - } - else { - compiler.parameter("bump_offset", "center"); - } - - if (layer_name.empty()) { - compiler.parameter("layer_name", ustring("geom:vertex_color")); - } - else { - if (Attribute::name_standard(layer_name.c_str()) != ATTR_STD_NONE) { - compiler.parameter("name", (string("geom:") + layer_name.c_str()).c_str()); - } - else { - compiler.parameter("layer_name", layer_name.c_str()); - } - } - - compiler.add(this, "node_vertex_color"); -} - -/* Value */ - -NODE_DEFINE(ValueNode) -{ - NodeType *type = NodeType::add("value", create, NodeType::SHADER); - - SOCKET_FLOAT(value, "Value", 0.0f); - SOCKET_OUT_FLOAT(value, "Value"); - - return type; -} - -ValueNode::ValueNode() : ShaderNode(get_node_type()) -{ -} - -void ValueNode::constant_fold(const ConstantFolder &folder) -{ - folder.make_constant(value); -} - -void ValueNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *val_out = output("Value"); - - compiler.add_node(NODE_VALUE_F, __float_as_int(value), compiler.stack_assign(val_out)); -} - -void ValueNode::compile(OSLCompiler &compiler) -{ - compiler.parameter("value_value", value); - compiler.add(this, "node_value"); -} - -/* Color */ - -NODE_DEFINE(ColorNode) -{ - NodeType *type = NodeType::add("color", create, NodeType::SHADER); - - SOCKET_COLOR(value, "Value", zero_float3()); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -ColorNode::ColorNode() : ShaderNode(get_node_type()) -{ -} - -void ColorNode::constant_fold(const ConstantFolder &folder) -{ - folder.make_constant(value); -} - -void ColorNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *color_out = output("Color"); - - if (!color_out->links.empty()) { - compiler.add_node(NODE_VALUE_V, compiler.stack_assign(color_out)); - compiler.add_node(NODE_VALUE_V, value); - } -} - -void ColorNode::compile(OSLCompiler &compiler) -{ - compiler.parameter_color("color_value", value); - - compiler.add(this, "node_value"); -} - -/* Add Closure */ - -NODE_DEFINE(AddClosureNode) -{ - NodeType *type = NodeType::add("add_closure", create, NodeType::SHADER); - - SOCKET_IN_CLOSURE(closure1, "Closure1"); - SOCKET_IN_CLOSURE(closure2, "Closure2"); - SOCKET_OUT_CLOSURE(closure, "Closure"); - - return type; -} - -AddClosureNode::AddClosureNode() : ShaderNode(get_node_type()) -{ - special_type = SHADER_SPECIAL_TYPE_COMBINE_CLOSURE; -} - -void AddClosureNode::compile(SVMCompiler & /*compiler*/) -{ - /* handled in the SVM compiler */ -} - -void AddClosureNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_add_closure"); -} - -void AddClosureNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *closure1_in = input("Closure1"); - ShaderInput *closure2_in = input("Closure2"); - - /* remove useless add closures nodes */ - if (!closure1_in->link) { - folder.bypass_or_discard(closure2_in); - } - else if (!closure2_in->link) { - folder.bypass_or_discard(closure1_in); - } -} - -/* Mix Closure */ - -NODE_DEFINE(MixClosureNode) -{ - NodeType *type = NodeType::add("mix_closure", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(fac, "Fac", 0.5f); - SOCKET_IN_CLOSURE(closure1, "Closure1"); - SOCKET_IN_CLOSURE(closure2, "Closure2"); - - SOCKET_OUT_CLOSURE(closure, "Closure"); - - return type; -} - -MixClosureNode::MixClosureNode() : ShaderNode(get_node_type()) -{ - special_type = SHADER_SPECIAL_TYPE_COMBINE_CLOSURE; -} - -void MixClosureNode::compile(SVMCompiler & /*compiler*/) -{ - /* handled in the SVM compiler */ -} - -void MixClosureNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_mix_closure"); -} - -void MixClosureNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *fac_in = input("Fac"); - ShaderInput *closure1_in = input("Closure1"); - ShaderInput *closure2_in = input("Closure2"); - - /* remove useless mix closures nodes */ - if (closure1_in->link == closure2_in->link) { - folder.bypass_or_discard(closure1_in); - } - /* remove unused mix closure input when factor is 0.0 or 1.0 - * check for closure links and make sure factor link is disconnected */ - else if (!fac_in->link) { - /* factor 0.0 */ - if (fac <= 0.0f) { - folder.bypass_or_discard(closure1_in); - } - /* factor 1.0 */ - else if (fac >= 1.0f) { - folder.bypass_or_discard(closure2_in); - } - } -} - -/* Mix Closure */ - -NODE_DEFINE(MixClosureWeightNode) -{ - NodeType *type = NodeType::add("mix_closure_weight", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(weight, "Weight", 1.0f); - SOCKET_IN_FLOAT(fac, "Fac", 1.0f); - - SOCKET_OUT_FLOAT(weight1, "Weight1"); - SOCKET_OUT_FLOAT(weight2, "Weight2"); - - return type; -} - -MixClosureWeightNode::MixClosureWeightNode() : ShaderNode(get_node_type()) -{ -} - -void MixClosureWeightNode::compile(SVMCompiler &compiler) -{ - ShaderInput *weight_in = input("Weight"); - ShaderInput *fac_in = input("Fac"); - ShaderOutput *weight1_out = output("Weight1"); - ShaderOutput *weight2_out = output("Weight2"); - - compiler.add_node(NODE_MIX_CLOSURE, - compiler.encode_uchar4(compiler.stack_assign(fac_in), - compiler.stack_assign(weight_in), - compiler.stack_assign(weight1_out), - compiler.stack_assign(weight2_out))); -} - -void MixClosureWeightNode::compile(OSLCompiler & /*compiler*/) -{ - assert(0); -} - -/* Invert */ - -NODE_DEFINE(InvertNode) -{ - NodeType *type = NodeType::add("invert", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(fac, "Fac", 1.0f); - SOCKET_IN_COLOR(color, "Color", zero_float3()); - - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -InvertNode::InvertNode() : ShaderNode(get_node_type()) -{ -} - -void InvertNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *fac_in = input("Fac"); - ShaderInput *color_in = input("Color"); - - if (!fac_in->link) { - /* evaluate fully constant node */ - if (!color_in->link) { - folder.make_constant(interp(color, one_float3() - color, fac)); - } - /* remove no-op node */ - else if (fac == 0.0f) { - folder.bypass(color_in->link); - } - } -} - -void InvertNode::compile(SVMCompiler &compiler) -{ - ShaderInput *fac_in = input("Fac"); - ShaderInput *color_in = input("Color"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node(NODE_INVERT, - compiler.stack_assign(fac_in), - compiler.stack_assign(color_in), - compiler.stack_assign(color_out)); -} - -void InvertNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_invert"); -} - -/* Mix */ - -NODE_DEFINE(MixNode) -{ - NodeType *type = NodeType::add("mix", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("mix", NODE_MIX_BLEND); - type_enum.insert("add", NODE_MIX_ADD); - type_enum.insert("multiply", NODE_MIX_MUL); - type_enum.insert("screen", NODE_MIX_SCREEN); - type_enum.insert("overlay", NODE_MIX_OVERLAY); - type_enum.insert("subtract", NODE_MIX_SUB); - type_enum.insert("divide", NODE_MIX_DIV); - type_enum.insert("difference", NODE_MIX_DIFF); - type_enum.insert("darken", NODE_MIX_DARK); - type_enum.insert("lighten", NODE_MIX_LIGHT); - type_enum.insert("dodge", NODE_MIX_DODGE); - type_enum.insert("burn", NODE_MIX_BURN); - type_enum.insert("hue", NODE_MIX_HUE); - type_enum.insert("saturation", NODE_MIX_SAT); - type_enum.insert("value", NODE_MIX_VAL); - type_enum.insert("color", NODE_MIX_COLOR); - type_enum.insert("soft_light", NODE_MIX_SOFT); - type_enum.insert("linear_light", NODE_MIX_LINEAR); - SOCKET_ENUM(mix_type, "Type", type_enum, NODE_MIX_BLEND); - - SOCKET_BOOLEAN(use_clamp, "Use Clamp", false); - - SOCKET_IN_FLOAT(fac, "Fac", 0.5f); - SOCKET_IN_COLOR(color1, "Color1", zero_float3()); - SOCKET_IN_COLOR(color2, "Color2", zero_float3()); - - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -MixNode::MixNode() : ShaderNode(get_node_type()) -{ -} - -void MixNode::compile(SVMCompiler &compiler) -{ - ShaderInput *fac_in = input("Fac"); - ShaderInput *color1_in = input("Color1"); - ShaderInput *color2_in = input("Color2"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node(NODE_MIX, - compiler.stack_assign(fac_in), - compiler.stack_assign(color1_in), - compiler.stack_assign(color2_in)); - compiler.add_node(NODE_MIX, mix_type, compiler.stack_assign(color_out)); - - if (use_clamp) { - compiler.add_node(NODE_MIX, 0, compiler.stack_assign(color_out)); - compiler.add_node(NODE_MIX, NODE_MIX_CLAMP, compiler.stack_assign(color_out)); - } -} - -void MixNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "mix_type"); - compiler.parameter(this, "use_clamp"); - compiler.add(this, "node_mix"); -} - -void MixNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant_clamp(svm_mix(mix_type, fac, color1, color2), use_clamp); - } - else { - folder.fold_mix(mix_type, use_clamp); - } -} - -/* Combine RGB */ - -NODE_DEFINE(CombineRGBNode) -{ - NodeType *type = NodeType::add("combine_rgb", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(r, "R", 0.0f); - SOCKET_IN_FLOAT(g, "G", 0.0f); - SOCKET_IN_FLOAT(b, "B", 0.0f); - - SOCKET_OUT_COLOR(image, "Image"); - - return type; -} - -CombineRGBNode::CombineRGBNode() : ShaderNode(get_node_type()) -{ -} - -void CombineRGBNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(make_float3(r, g, b)); - } -} - -void CombineRGBNode::compile(SVMCompiler &compiler) -{ - ShaderInput *red_in = input("R"); - ShaderInput *green_in = input("G"); - ShaderInput *blue_in = input("B"); - ShaderOutput *color_out = output("Image"); - - compiler.add_node( - NODE_COMBINE_VECTOR, compiler.stack_assign(red_in), 0, compiler.stack_assign(color_out)); - - compiler.add_node( - NODE_COMBINE_VECTOR, compiler.stack_assign(green_in), 1, compiler.stack_assign(color_out)); - - compiler.add_node( - NODE_COMBINE_VECTOR, compiler.stack_assign(blue_in), 2, compiler.stack_assign(color_out)); -} - -void CombineRGBNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_combine_rgb"); -} - -/* Combine XYZ */ - -NODE_DEFINE(CombineXYZNode) -{ - NodeType *type = NodeType::add("combine_xyz", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(x, "X", 0.0f); - SOCKET_IN_FLOAT(y, "Y", 0.0f); - SOCKET_IN_FLOAT(z, "Z", 0.0f); - - SOCKET_OUT_VECTOR(vector, "Vector"); - - return type; -} - -CombineXYZNode::CombineXYZNode() : ShaderNode(get_node_type()) -{ -} - -void CombineXYZNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(make_float3(x, y, z)); - } -} - -void CombineXYZNode::compile(SVMCompiler &compiler) -{ - ShaderInput *x_in = input("X"); - ShaderInput *y_in = input("Y"); - ShaderInput *z_in = input("Z"); - ShaderOutput *vector_out = output("Vector"); - - compiler.add_node( - NODE_COMBINE_VECTOR, compiler.stack_assign(x_in), 0, compiler.stack_assign(vector_out)); - - compiler.add_node( - NODE_COMBINE_VECTOR, compiler.stack_assign(y_in), 1, compiler.stack_assign(vector_out)); - - compiler.add_node( - NODE_COMBINE_VECTOR, compiler.stack_assign(z_in), 2, compiler.stack_assign(vector_out)); -} - -void CombineXYZNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_combine_xyz"); -} - -/* Combine HSV */ - -NODE_DEFINE(CombineHSVNode) -{ - NodeType *type = NodeType::add("combine_hsv", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(h, "H", 0.0f); - SOCKET_IN_FLOAT(s, "S", 0.0f); - SOCKET_IN_FLOAT(v, "V", 0.0f); - - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -CombineHSVNode::CombineHSVNode() : ShaderNode(get_node_type()) -{ -} - -void CombineHSVNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(hsv_to_rgb(make_float3(h, s, v))); - } -} - -void CombineHSVNode::compile(SVMCompiler &compiler) -{ - ShaderInput *hue_in = input("H"); - ShaderInput *saturation_in = input("S"); - ShaderInput *value_in = input("V"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node(NODE_COMBINE_HSV, - compiler.stack_assign(hue_in), - compiler.stack_assign(saturation_in), - compiler.stack_assign(value_in)); - compiler.add_node(NODE_COMBINE_HSV, compiler.stack_assign(color_out)); -} - -void CombineHSVNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_combine_hsv"); -} - -/* Gamma */ - -NODE_DEFINE(GammaNode) -{ - NodeType *type = NodeType::add("gamma", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", zero_float3()); - SOCKET_IN_FLOAT(gamma, "Gamma", 1.0f); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -GammaNode::GammaNode() : ShaderNode(get_node_type()) -{ -} - -void GammaNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(svm_math_gamma_color(color, gamma)); - } - else { - ShaderInput *color_in = input("Color"); - ShaderInput *gamma_in = input("Gamma"); - - /* 1 ^ X == X ^ 0 == 1 */ - if (folder.is_one(color_in) || folder.is_zero(gamma_in)) { - folder.make_one(); - } - /* X ^ 1 == X */ - else if (folder.is_one(gamma_in)) { - folder.try_bypass_or_make_constant(color_in, false); - } - } -} - -void GammaNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *gamma_in = input("Gamma"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node(NODE_GAMMA, - compiler.stack_assign(gamma_in), - compiler.stack_assign(color_in), - compiler.stack_assign(color_out)); -} - -void GammaNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_gamma"); -} - -/* Bright Contrast */ - -NODE_DEFINE(BrightContrastNode) -{ - NodeType *type = NodeType::add("brightness_contrast", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", zero_float3()); - SOCKET_IN_FLOAT(bright, "Bright", 0.0f); - SOCKET_IN_FLOAT(contrast, "Contrast", 0.0f); - - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -BrightContrastNode::BrightContrastNode() : ShaderNode(get_node_type()) -{ -} - -void BrightContrastNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(svm_brightness_contrast(color, bright, contrast)); - } -} - -void BrightContrastNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *bright_in = input("Bright"); - ShaderInput *contrast_in = input("Contrast"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node(NODE_BRIGHTCONTRAST, - compiler.stack_assign(color_in), - compiler.stack_assign(color_out), - compiler.encode_uchar4(compiler.stack_assign(bright_in), - compiler.stack_assign(contrast_in))); -} - -void BrightContrastNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_brightness"); -} - -/* Separate RGB */ - -NODE_DEFINE(SeparateRGBNode) -{ - NodeType *type = NodeType::add("separate_rgb", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Image", zero_float3()); - - SOCKET_OUT_FLOAT(r, "R"); - SOCKET_OUT_FLOAT(g, "G"); - SOCKET_OUT_FLOAT(b, "B"); - - return type; -} - -SeparateRGBNode::SeparateRGBNode() : ShaderNode(get_node_type()) -{ -} - -void SeparateRGBNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - for (int channel = 0; channel < 3; channel++) { - if (outputs[channel] == folder.output) { - folder.make_constant(color[channel]); - return; - } - } - } -} - -void SeparateRGBNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Image"); - ShaderOutput *red_out = output("R"); - ShaderOutput *green_out = output("G"); - ShaderOutput *blue_out = output("B"); - - compiler.add_node( - NODE_SEPARATE_VECTOR, compiler.stack_assign(color_in), 0, compiler.stack_assign(red_out)); - - compiler.add_node( - NODE_SEPARATE_VECTOR, compiler.stack_assign(color_in), 1, compiler.stack_assign(green_out)); - - compiler.add_node( - NODE_SEPARATE_VECTOR, compiler.stack_assign(color_in), 2, compiler.stack_assign(blue_out)); -} - -void SeparateRGBNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_separate_rgb"); -} - -/* Separate XYZ */ - -NODE_DEFINE(SeparateXYZNode) -{ - NodeType *type = NodeType::add("separate_xyz", create, NodeType::SHADER); - - SOCKET_IN_COLOR(vector, "Vector", zero_float3()); - - SOCKET_OUT_FLOAT(x, "X"); - SOCKET_OUT_FLOAT(y, "Y"); - SOCKET_OUT_FLOAT(z, "Z"); - - return type; -} - -SeparateXYZNode::SeparateXYZNode() : ShaderNode(get_node_type()) -{ -} - -void SeparateXYZNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - for (int channel = 0; channel < 3; channel++) { - if (outputs[channel] == folder.output) { - folder.make_constant(vector[channel]); - return; - } - } - } -} - -void SeparateXYZNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *x_out = output("X"); - ShaderOutput *y_out = output("Y"); - ShaderOutput *z_out = output("Z"); - - compiler.add_node( - NODE_SEPARATE_VECTOR, compiler.stack_assign(vector_in), 0, compiler.stack_assign(x_out)); - - compiler.add_node( - NODE_SEPARATE_VECTOR, compiler.stack_assign(vector_in), 1, compiler.stack_assign(y_out)); - - compiler.add_node( - NODE_SEPARATE_VECTOR, compiler.stack_assign(vector_in), 2, compiler.stack_assign(z_out)); -} - -void SeparateXYZNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_separate_xyz"); -} - -/* Separate HSV */ - -NODE_DEFINE(SeparateHSVNode) -{ - NodeType *type = NodeType::add("separate_hsv", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", zero_float3()); - - SOCKET_OUT_FLOAT(h, "H"); - SOCKET_OUT_FLOAT(s, "S"); - SOCKET_OUT_FLOAT(v, "V"); - - return type; -} - -SeparateHSVNode::SeparateHSVNode() : ShaderNode(get_node_type()) -{ -} - -void SeparateHSVNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - float3 hsv = rgb_to_hsv(color); - - for (int channel = 0; channel < 3; channel++) { - if (outputs[channel] == folder.output) { - folder.make_constant(hsv[channel]); - return; - } - } - } -} - -void SeparateHSVNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderOutput *hue_out = output("H"); - ShaderOutput *saturation_out = output("S"); - ShaderOutput *value_out = output("V"); - - compiler.add_node(NODE_SEPARATE_HSV, - compiler.stack_assign(color_in), - compiler.stack_assign(hue_out), - compiler.stack_assign(saturation_out)); - compiler.add_node(NODE_SEPARATE_HSV, compiler.stack_assign(value_out)); -} - -void SeparateHSVNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_separate_hsv"); -} - -/* Hue Saturation Value */ - -NODE_DEFINE(HSVNode) -{ - NodeType *type = NodeType::add("hsv", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(hue, "Hue", 0.5f); - SOCKET_IN_FLOAT(saturation, "Saturation", 1.0f); - SOCKET_IN_FLOAT(value, "Value", 1.0f); - SOCKET_IN_FLOAT(fac, "Fac", 1.0f); - SOCKET_IN_COLOR(color, "Color", zero_float3()); - - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -HSVNode::HSVNode() : ShaderNode(get_node_type()) -{ -} - -void HSVNode::compile(SVMCompiler &compiler) -{ - ShaderInput *hue_in = input("Hue"); - ShaderInput *saturation_in = input("Saturation"); - ShaderInput *value_in = input("Value"); - ShaderInput *fac_in = input("Fac"); - ShaderInput *color_in = input("Color"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node(NODE_HSV, - compiler.encode_uchar4(compiler.stack_assign(color_in), - compiler.stack_assign(fac_in), - compiler.stack_assign(color_out)), - compiler.encode_uchar4(compiler.stack_assign(hue_in), - compiler.stack_assign(saturation_in), - compiler.stack_assign(value_in))); -} - -void HSVNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_hsv"); -} - -/* Attribute */ - -NODE_DEFINE(AttributeNode) -{ - NodeType *type = NodeType::add("attribute", create, NodeType::SHADER); - - SOCKET_STRING(attribute, "Attribute", ustring()); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_VECTOR(vector, "Vector"); - SOCKET_OUT_FLOAT(fac, "Fac"); - SOCKET_OUT_FLOAT(alpha, "Alpha"); - - return type; -} - -AttributeNode::AttributeNode() : ShaderNode(get_node_type()) -{ -} - -void AttributeNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - ShaderOutput *color_out = output("Color"); - ShaderOutput *vector_out = output("Vector"); - ShaderOutput *fac_out = output("Fac"); - ShaderOutput *alpha_out = output("Alpha"); - - if (!color_out->links.empty() || !vector_out->links.empty() || !fac_out->links.empty() || - !alpha_out->links.empty()) { - attributes->add_standard(attribute); - } - - if (shader->has_volume) { - attributes->add(ATTR_STD_GENERATED_TRANSFORM); - } - - ShaderNode::attributes(shader, attributes); -} - -void AttributeNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *color_out = output("Color"); - ShaderOutput *vector_out = output("Vector"); - ShaderOutput *fac_out = output("Fac"); - ShaderOutput *alpha_out = output("Alpha"); - ShaderNodeType attr_node = NODE_ATTR; - int attr = compiler.attribute_standard(attribute); - - if (bump == SHADER_BUMP_DX) - attr_node = NODE_ATTR_BUMP_DX; - else if (bump == SHADER_BUMP_DY) - attr_node = NODE_ATTR_BUMP_DY; - - if (!color_out->links.empty() || !vector_out->links.empty()) { - if (!color_out->links.empty()) { - compiler.add_node( - attr_node, attr, compiler.stack_assign(color_out), NODE_ATTR_OUTPUT_FLOAT3); - } - if (!vector_out->links.empty()) { - compiler.add_node( - attr_node, attr, compiler.stack_assign(vector_out), NODE_ATTR_OUTPUT_FLOAT3); - } - } - - if (!fac_out->links.empty()) { - compiler.add_node(attr_node, attr, compiler.stack_assign(fac_out), NODE_ATTR_OUTPUT_FLOAT); - } - - if (!alpha_out->links.empty()) { - compiler.add_node( - attr_node, attr, compiler.stack_assign(alpha_out), NODE_ATTR_OUTPUT_FLOAT_ALPHA); - } -} - -void AttributeNode::compile(OSLCompiler &compiler) -{ - if (bump == SHADER_BUMP_DX) - compiler.parameter("bump_offset", "dx"); - else if (bump == SHADER_BUMP_DY) - compiler.parameter("bump_offset", "dy"); - else - compiler.parameter("bump_offset", "center"); - - if (Attribute::name_standard(attribute.c_str()) != ATTR_STD_NONE) - compiler.parameter("name", (string("geom:") + attribute.c_str()).c_str()); - else - compiler.parameter("name", attribute.c_str()); - - compiler.add(this, "node_attribute"); -} - -/* Camera */ - -NODE_DEFINE(CameraNode) -{ - NodeType *type = NodeType::add("camera_info", create, NodeType::SHADER); - - SOCKET_OUT_VECTOR(view_vector, "View Vector"); - SOCKET_OUT_FLOAT(view_z_depth, "View Z Depth"); - SOCKET_OUT_FLOAT(view_distance, "View Distance"); - - return type; -} - -CameraNode::CameraNode() : ShaderNode(get_node_type()) -{ -} - -void CameraNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *vector_out = output("View Vector"); - ShaderOutput *z_depth_out = output("View Z Depth"); - ShaderOutput *distance_out = output("View Distance"); - - compiler.add_node(NODE_CAMERA, - compiler.stack_assign(vector_out), - compiler.stack_assign(z_depth_out), - compiler.stack_assign(distance_out)); -} - -void CameraNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_camera"); -} - -/* Fresnel */ - -NODE_DEFINE(FresnelNode) -{ - NodeType *type = NodeType::add("fresnel", create, NodeType::SHADER); - - SOCKET_IN_NORMAL( - normal, "Normal", zero_float3(), SocketType::LINK_NORMAL | SocketType::OSL_INTERNAL); - SOCKET_IN_FLOAT(IOR, "IOR", 1.45f); - - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -FresnelNode::FresnelNode() : ShaderNode(get_node_type()) -{ -} - -void FresnelNode::compile(SVMCompiler &compiler) -{ - ShaderInput *normal_in = input("Normal"); - ShaderInput *IOR_in = input("IOR"); - ShaderOutput *fac_out = output("Fac"); - - compiler.add_node(NODE_FRESNEL, - compiler.stack_assign(IOR_in), - __float_as_int(IOR), - compiler.encode_uchar4(compiler.stack_assign_if_linked(normal_in), - compiler.stack_assign(fac_out))); -} - -void FresnelNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_fresnel"); -} - -/* Layer Weight */ - -NODE_DEFINE(LayerWeightNode) -{ - NodeType *type = NodeType::add("layer_weight", create, NodeType::SHADER); - - SOCKET_IN_NORMAL( - normal, "Normal", zero_float3(), SocketType::LINK_NORMAL | SocketType::OSL_INTERNAL); - SOCKET_IN_FLOAT(blend, "Blend", 0.5f); - - SOCKET_OUT_FLOAT(fresnel, "Fresnel"); - SOCKET_OUT_FLOAT(facing, "Facing"); - - return type; -} - -LayerWeightNode::LayerWeightNode() : ShaderNode(get_node_type()) -{ -} - -void LayerWeightNode::compile(SVMCompiler &compiler) -{ - ShaderInput *normal_in = input("Normal"); - ShaderInput *blend_in = input("Blend"); - ShaderOutput *fresnel_out = output("Fresnel"); - ShaderOutput *facing_out = output("Facing"); - - if (!fresnel_out->links.empty()) { - compiler.add_node(NODE_LAYER_WEIGHT, - compiler.stack_assign_if_linked(blend_in), - __float_as_int(blend), - compiler.encode_uchar4(NODE_LAYER_WEIGHT_FRESNEL, - compiler.stack_assign_if_linked(normal_in), - compiler.stack_assign(fresnel_out))); - } - - if (!facing_out->links.empty()) { - compiler.add_node(NODE_LAYER_WEIGHT, - compiler.stack_assign_if_linked(blend_in), - __float_as_int(blend), - compiler.encode_uchar4(NODE_LAYER_WEIGHT_FACING, - compiler.stack_assign_if_linked(normal_in), - compiler.stack_assign(facing_out))); - } -} - -void LayerWeightNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_layer_weight"); -} - -/* Wireframe */ - -NODE_DEFINE(WireframeNode) -{ - NodeType *type = NodeType::add("wireframe", create, NodeType::SHADER); - - SOCKET_BOOLEAN(use_pixel_size, "Use Pixel Size", false); - SOCKET_IN_FLOAT(size, "Size", 0.01f); - SOCKET_OUT_FLOAT(fac, "Fac"); - - return type; -} - -WireframeNode::WireframeNode() : ShaderNode(get_node_type()) -{ -} - -void WireframeNode::compile(SVMCompiler &compiler) -{ - ShaderInput *size_in = input("Size"); - ShaderOutput *fac_out = output("Fac"); - NodeBumpOffset bump_offset = NODE_BUMP_OFFSET_CENTER; - if (bump == SHADER_BUMP_DX) { - bump_offset = NODE_BUMP_OFFSET_DX; - } - else if (bump == SHADER_BUMP_DY) { - bump_offset = NODE_BUMP_OFFSET_DY; - } - compiler.add_node(NODE_WIREFRAME, - compiler.stack_assign(size_in), - compiler.stack_assign(fac_out), - compiler.encode_uchar4(use_pixel_size, bump_offset, 0, 0)); -} - -void WireframeNode::compile(OSLCompiler &compiler) -{ - if (bump == SHADER_BUMP_DX) { - compiler.parameter("bump_offset", "dx"); - } - else if (bump == SHADER_BUMP_DY) { - compiler.parameter("bump_offset", "dy"); - } - else { - compiler.parameter("bump_offset", "center"); - } - compiler.parameter(this, "use_pixel_size"); - compiler.add(this, "node_wireframe"); -} - -/* Wavelength */ - -NODE_DEFINE(WavelengthNode) -{ - NodeType *type = NodeType::add("wavelength", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(wavelength, "Wavelength", 500.0f); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -WavelengthNode::WavelengthNode() : ShaderNode(get_node_type()) -{ -} - -void WavelengthNode::compile(SVMCompiler &compiler) -{ - ShaderInput *wavelength_in = input("Wavelength"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node( - NODE_WAVELENGTH, compiler.stack_assign(wavelength_in), compiler.stack_assign(color_out)); -} - -void WavelengthNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_wavelength"); -} - -/* Blackbody */ - -NODE_DEFINE(BlackbodyNode) -{ - NodeType *type = NodeType::add("blackbody", create, NodeType::SHADER); - - SOCKET_IN_FLOAT(temperature, "Temperature", 1200.0f); - SOCKET_OUT_COLOR(color, "Color"); - - return type; -} - -BlackbodyNode::BlackbodyNode() : ShaderNode(get_node_type()) -{ -} - -void BlackbodyNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(svm_math_blackbody_color(temperature)); - } -} - -void BlackbodyNode::compile(SVMCompiler &compiler) -{ - ShaderInput *temperature_in = input("Temperature"); - ShaderOutput *color_out = output("Color"); - - compiler.add_node( - NODE_BLACKBODY, compiler.stack_assign(temperature_in), compiler.stack_assign(color_out)); -} - -void BlackbodyNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_blackbody"); -} - -/* Output */ - -NODE_DEFINE(OutputNode) -{ - NodeType *type = NodeType::add("output", create, NodeType::SHADER); - - SOCKET_IN_CLOSURE(surface, "Surface"); - SOCKET_IN_CLOSURE(volume, "Volume"); - SOCKET_IN_VECTOR(displacement, "Displacement", zero_float3()); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3()); - - return type; -} - -OutputNode::OutputNode() : ShaderNode(get_node_type()) -{ - special_type = SHADER_SPECIAL_TYPE_OUTPUT; -} - -void OutputNode::compile(SVMCompiler &compiler) -{ - if (compiler.output_type() == SHADER_TYPE_DISPLACEMENT) { - ShaderInput *displacement_in = input("Displacement"); - - if (displacement_in->link) { - compiler.add_node(NODE_SET_DISPLACEMENT, compiler.stack_assign(displacement_in)); - } - } -} - -void OutputNode::compile(OSLCompiler &compiler) -{ - if (compiler.output_type() == SHADER_TYPE_SURFACE) - compiler.add(this, "node_output_surface"); - else if (compiler.output_type() == SHADER_TYPE_VOLUME) - compiler.add(this, "node_output_volume"); - else if (compiler.output_type() == SHADER_TYPE_DISPLACEMENT) - compiler.add(this, "node_output_displacement"); -} - -/* Map Range Node */ - -NODE_DEFINE(MapRangeNode) -{ - NodeType *type = NodeType::add("map_range", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("linear", NODE_MAP_RANGE_LINEAR); - type_enum.insert("stepped", NODE_MAP_RANGE_STEPPED); - type_enum.insert("smoothstep", NODE_MAP_RANGE_SMOOTHSTEP); - type_enum.insert("smootherstep", NODE_MAP_RANGE_SMOOTHERSTEP); - SOCKET_ENUM(range_type, "Type", type_enum, NODE_MAP_RANGE_LINEAR); - - SOCKET_IN_FLOAT(value, "Value", 1.0f); - SOCKET_IN_FLOAT(from_min, "From Min", 0.0f); - SOCKET_IN_FLOAT(from_max, "From Max", 1.0f); - SOCKET_IN_FLOAT(to_min, "To Min", 0.0f); - SOCKET_IN_FLOAT(to_max, "To Max", 1.0f); - SOCKET_IN_FLOAT(steps, "Steps", 4.0f); - SOCKET_IN_BOOLEAN(clamp, "Clamp", false); - - SOCKET_OUT_FLOAT(result, "Result"); - - return type; -} - -MapRangeNode::MapRangeNode() : ShaderNode(get_node_type()) -{ -} - -void MapRangeNode::expand(ShaderGraph *graph) -{ - if (clamp) { - ShaderOutput *result_out = output("Result"); - if (!result_out->links.empty()) { - ClampNode *clamp_node = graph->create_node<ClampNode>(); - clamp_node->set_clamp_type(NODE_CLAMP_RANGE); - graph->add(clamp_node); - graph->relink(result_out, clamp_node->output("Result")); - graph->connect(result_out, clamp_node->input("Value")); - if (input("To Min")->link) { - graph->connect(input("To Min")->link, clamp_node->input("Min")); - } - else { - clamp_node->set_min(to_min); - } - if (input("To Max")->link) { - graph->connect(input("To Max")->link, clamp_node->input("Max")); - } - else { - clamp_node->set_max(to_max); - } - } - } -} - -void MapRangeNode::compile(SVMCompiler &compiler) -{ - ShaderInput *value_in = input("Value"); - ShaderInput *from_min_in = input("From Min"); - ShaderInput *from_max_in = input("From Max"); - ShaderInput *to_min_in = input("To Min"); - ShaderInput *to_max_in = input("To Max"); - ShaderInput *steps_in = input("Steps"); - ShaderOutput *result_out = output("Result"); - - int value_stack_offset = compiler.stack_assign(value_in); - int from_min_stack_offset = compiler.stack_assign_if_linked(from_min_in); - int from_max_stack_offset = compiler.stack_assign_if_linked(from_max_in); - int to_min_stack_offset = compiler.stack_assign_if_linked(to_min_in); - int to_max_stack_offset = compiler.stack_assign_if_linked(to_max_in); - int steps_stack_offset = compiler.stack_assign(steps_in); - int result_stack_offset = compiler.stack_assign(result_out); - - compiler.add_node( - NODE_MAP_RANGE, - value_stack_offset, - compiler.encode_uchar4( - from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset), - compiler.encode_uchar4(range_type, steps_stack_offset, result_stack_offset)); - - compiler.add_node(__float_as_int(from_min), - __float_as_int(from_max), - __float_as_int(to_min), - __float_as_int(to_max)); - compiler.add_node(__float_as_int(steps)); -} - -void MapRangeNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "range_type"); - compiler.add(this, "node_map_range"); -} - -/* Clamp Node */ - -NODE_DEFINE(ClampNode) -{ - NodeType *type = NodeType::add("clamp", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("minmax", NODE_CLAMP_MINMAX); - type_enum.insert("range", NODE_CLAMP_RANGE); - SOCKET_ENUM(clamp_type, "Type", type_enum, NODE_CLAMP_MINMAX); - - SOCKET_IN_FLOAT(value, "Value", 1.0f); - SOCKET_IN_FLOAT(min, "Min", 0.0f); - SOCKET_IN_FLOAT(max, "Max", 1.0f); - - SOCKET_OUT_FLOAT(result, "Result"); - - return type; -} - -ClampNode::ClampNode() : ShaderNode(get_node_type()) -{ -} - -void ClampNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - if (clamp_type == NODE_CLAMP_RANGE && (min > max)) { - folder.make_constant(clamp(value, max, min)); - } - else { - folder.make_constant(clamp(value, min, max)); - } - } -} - -void ClampNode::compile(SVMCompiler &compiler) -{ - ShaderInput *value_in = input("Value"); - ShaderInput *min_in = input("Min"); - ShaderInput *max_in = input("Max"); - ShaderOutput *result_out = output("Result"); - - int value_stack_offset = compiler.stack_assign(value_in); - int min_stack_offset = compiler.stack_assign(min_in); - int max_stack_offset = compiler.stack_assign(max_in); - int result_stack_offset = compiler.stack_assign(result_out); - - compiler.add_node(NODE_CLAMP, - value_stack_offset, - compiler.encode_uchar4(min_stack_offset, max_stack_offset, clamp_type), - result_stack_offset); - compiler.add_node(__float_as_int(min), __float_as_int(max)); -} - -void ClampNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "clamp_type"); - compiler.add(this, "node_clamp"); -} - -/* AOV Output */ - -NODE_DEFINE(OutputAOVNode) -{ - NodeType *type = NodeType::add("aov_output", create, NodeType::SHADER); - - SOCKET_IN_COLOR(color, "Color", zero_float3()); - SOCKET_IN_FLOAT(value, "Value", 0.0f); - - SOCKET_STRING(name, "AOV Name", ustring("")); - - return type; -} - -OutputAOVNode::OutputAOVNode() : ShaderNode(get_node_type()) -{ - special_type = SHADER_SPECIAL_TYPE_OUTPUT_AOV; - offset = -1; -} - -void OutputAOVNode::simplify_settings(Scene *scene) -{ - offset = scene->film->get_aov_offset(scene, name.string(), is_color); - if (offset == -1) { - offset = scene->film->get_aov_offset(scene, name.string(), is_color); - } - - if (offset == -1 || is_color) { - input("Value")->disconnect(); - } - if (offset == -1 || !is_color) { - input("Color")->disconnect(); - } -} - -void OutputAOVNode::compile(SVMCompiler &compiler) -{ - assert(offset >= 0); - - if (is_color) { - compiler.add_node(NODE_AOV_COLOR, compiler.stack_assign(input("Color")), offset); - } - else { - compiler.add_node(NODE_AOV_VALUE, compiler.stack_assign(input("Value")), offset); - } -} - -void OutputAOVNode::compile(OSLCompiler & /*compiler*/) -{ - /* TODO */ -} - -/* Math */ - -NODE_DEFINE(MathNode) -{ - NodeType *type = NodeType::add("math", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("add", NODE_MATH_ADD); - type_enum.insert("subtract", NODE_MATH_SUBTRACT); - type_enum.insert("multiply", NODE_MATH_MULTIPLY); - type_enum.insert("divide", NODE_MATH_DIVIDE); - type_enum.insert("multiply_add", NODE_MATH_MULTIPLY_ADD); - type_enum.insert("sine", NODE_MATH_SINE); - type_enum.insert("cosine", NODE_MATH_COSINE); - type_enum.insert("tangent", NODE_MATH_TANGENT); - type_enum.insert("sinh", NODE_MATH_SINH); - type_enum.insert("cosh", NODE_MATH_COSH); - type_enum.insert("tanh", NODE_MATH_TANH); - type_enum.insert("arcsine", NODE_MATH_ARCSINE); - type_enum.insert("arccosine", NODE_MATH_ARCCOSINE); - type_enum.insert("arctangent", NODE_MATH_ARCTANGENT); - type_enum.insert("power", NODE_MATH_POWER); - type_enum.insert("logarithm", NODE_MATH_LOGARITHM); - type_enum.insert("minimum", NODE_MATH_MINIMUM); - type_enum.insert("maximum", NODE_MATH_MAXIMUM); - type_enum.insert("round", NODE_MATH_ROUND); - type_enum.insert("less_than", NODE_MATH_LESS_THAN); - type_enum.insert("greater_than", NODE_MATH_GREATER_THAN); - type_enum.insert("modulo", NODE_MATH_MODULO); - type_enum.insert("absolute", NODE_MATH_ABSOLUTE); - type_enum.insert("arctan2", NODE_MATH_ARCTAN2); - type_enum.insert("floor", NODE_MATH_FLOOR); - type_enum.insert("ceil", NODE_MATH_CEIL); - type_enum.insert("fraction", NODE_MATH_FRACTION); - type_enum.insert("trunc", NODE_MATH_TRUNC); - type_enum.insert("snap", NODE_MATH_SNAP); - type_enum.insert("wrap", NODE_MATH_WRAP); - type_enum.insert("pingpong", NODE_MATH_PINGPONG); - type_enum.insert("sqrt", NODE_MATH_SQRT); - type_enum.insert("inversesqrt", NODE_MATH_INV_SQRT); - type_enum.insert("sign", NODE_MATH_SIGN); - type_enum.insert("exponent", NODE_MATH_EXPONENT); - type_enum.insert("radians", NODE_MATH_RADIANS); - type_enum.insert("degrees", NODE_MATH_DEGREES); - type_enum.insert("smoothmin", NODE_MATH_SMOOTH_MIN); - type_enum.insert("smoothmax", NODE_MATH_SMOOTH_MAX); - type_enum.insert("compare", NODE_MATH_COMPARE); - SOCKET_ENUM(math_type, "Type", type_enum, NODE_MATH_ADD); - - SOCKET_BOOLEAN(use_clamp, "Use Clamp", false); - - SOCKET_IN_FLOAT(value1, "Value1", 0.5f); - SOCKET_IN_FLOAT(value2, "Value2", 0.5f); - SOCKET_IN_FLOAT(value3, "Value3", 0.0f); - - SOCKET_OUT_FLOAT(value, "Value"); - - return type; -} - -MathNode::MathNode() : ShaderNode(get_node_type()) -{ -} - -void MathNode::expand(ShaderGraph *graph) -{ - if (use_clamp) { - ShaderOutput *result_out = output("Value"); - if (!result_out->links.empty()) { - ClampNode *clamp_node = graph->create_node<ClampNode>(); - clamp_node->set_clamp_type(NODE_CLAMP_MINMAX); - clamp_node->set_min(0.0f); - clamp_node->set_max(1.0f); - graph->add(clamp_node); - graph->relink(result_out, clamp_node->output("Result")); - graph->connect(result_out, clamp_node->input("Value")); - } - } -} - -void MathNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - folder.make_constant(svm_math(math_type, value1, value2, value3)); - } - else { - folder.fold_math(math_type); - } -} - -void MathNode::compile(SVMCompiler &compiler) -{ - ShaderInput *value1_in = input("Value1"); - ShaderInput *value2_in = input("Value2"); - ShaderInput *value3_in = input("Value3"); - ShaderOutput *value_out = output("Value"); - - int value1_stack_offset = compiler.stack_assign(value1_in); - int value2_stack_offset = compiler.stack_assign(value2_in); - int value3_stack_offset = compiler.stack_assign(value3_in); - int value_stack_offset = compiler.stack_assign(value_out); - - compiler.add_node( - NODE_MATH, - math_type, - compiler.encode_uchar4(value1_stack_offset, value2_stack_offset, value3_stack_offset), - value_stack_offset); -} - -void MathNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "math_type"); - compiler.add(this, "node_math"); -} - -/* VectorMath */ - -NODE_DEFINE(VectorMathNode) -{ - NodeType *type = NodeType::add("vector_math", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("add", NODE_VECTOR_MATH_ADD); - type_enum.insert("subtract", NODE_VECTOR_MATH_SUBTRACT); - type_enum.insert("multiply", NODE_VECTOR_MATH_MULTIPLY); - type_enum.insert("divide", NODE_VECTOR_MATH_DIVIDE); - - type_enum.insert("cross_product", NODE_VECTOR_MATH_CROSS_PRODUCT); - type_enum.insert("project", NODE_VECTOR_MATH_PROJECT); - type_enum.insert("reflect", NODE_VECTOR_MATH_REFLECT); - type_enum.insert("refract", NODE_VECTOR_MATH_REFRACT); - type_enum.insert("faceforward", NODE_VECTOR_MATH_FACEFORWARD); - type_enum.insert("multiply_add", NODE_VECTOR_MATH_MULTIPLY_ADD); - - type_enum.insert("dot_product", NODE_VECTOR_MATH_DOT_PRODUCT); - - type_enum.insert("distance", NODE_VECTOR_MATH_DISTANCE); - type_enum.insert("length", NODE_VECTOR_MATH_LENGTH); - type_enum.insert("scale", NODE_VECTOR_MATH_SCALE); - type_enum.insert("normalize", NODE_VECTOR_MATH_NORMALIZE); - - type_enum.insert("snap", NODE_VECTOR_MATH_SNAP); - type_enum.insert("floor", NODE_VECTOR_MATH_FLOOR); - type_enum.insert("ceil", NODE_VECTOR_MATH_CEIL); - type_enum.insert("modulo", NODE_VECTOR_MATH_MODULO); - type_enum.insert("wrap", NODE_VECTOR_MATH_WRAP); - type_enum.insert("fraction", NODE_VECTOR_MATH_FRACTION); - type_enum.insert("absolute", NODE_VECTOR_MATH_ABSOLUTE); - type_enum.insert("minimum", NODE_VECTOR_MATH_MINIMUM); - type_enum.insert("maximum", NODE_VECTOR_MATH_MAXIMUM); - - type_enum.insert("sine", NODE_VECTOR_MATH_SINE); - type_enum.insert("cosine", NODE_VECTOR_MATH_COSINE); - type_enum.insert("tangent", NODE_VECTOR_MATH_TANGENT); - SOCKET_ENUM(math_type, "Type", type_enum, NODE_VECTOR_MATH_ADD); - - SOCKET_IN_VECTOR(vector1, "Vector1", zero_float3()); - SOCKET_IN_VECTOR(vector2, "Vector2", zero_float3()); - SOCKET_IN_VECTOR(vector3, "Vector3", zero_float3()); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - - SOCKET_OUT_FLOAT(value, "Value"); - SOCKET_OUT_VECTOR(vector, "Vector"); - - return type; -} - -VectorMathNode::VectorMathNode() : ShaderNode(get_node_type()) -{ -} - -void VectorMathNode::constant_fold(const ConstantFolder &folder) -{ - float value = 0.0f; - float3 vector = zero_float3(); - - if (folder.all_inputs_constant()) { - svm_vector_math(&value, &vector, math_type, vector1, vector2, vector3, scale); - if (folder.output == output("Value")) { - folder.make_constant(value); - } - else if (folder.output == output("Vector")) { - folder.make_constant(vector); - } - } - else { - folder.fold_vector_math(math_type); - } -} - -void VectorMathNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector1_in = input("Vector1"); - ShaderInput *vector2_in = input("Vector2"); - ShaderInput *param1_in = input("Scale"); - ShaderOutput *value_out = output("Value"); - ShaderOutput *vector_out = output("Vector"); - - int vector1_stack_offset = compiler.stack_assign(vector1_in); - int vector2_stack_offset = compiler.stack_assign(vector2_in); - int param1_stack_offset = compiler.stack_assign(param1_in); - int value_stack_offset = compiler.stack_assign_if_linked(value_out); - int vector_stack_offset = compiler.stack_assign_if_linked(vector_out); - - /* 3 Vector Operators */ - if (math_type == NODE_VECTOR_MATH_WRAP || math_type == NODE_VECTOR_MATH_FACEFORWARD || - math_type == NODE_VECTOR_MATH_MULTIPLY_ADD) { - ShaderInput *vector3_in = input("Vector3"); - int vector3_stack_offset = compiler.stack_assign(vector3_in); - compiler.add_node( - NODE_VECTOR_MATH, - math_type, - compiler.encode_uchar4(vector1_stack_offset, vector2_stack_offset, param1_stack_offset), - compiler.encode_uchar4(value_stack_offset, vector_stack_offset)); - compiler.add_node(vector3_stack_offset); - } - else { - compiler.add_node( - NODE_VECTOR_MATH, - math_type, - compiler.encode_uchar4(vector1_stack_offset, vector2_stack_offset, param1_stack_offset), - compiler.encode_uchar4(value_stack_offset, vector_stack_offset)); - } -} - -void VectorMathNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "math_type"); - compiler.add(this, "node_vector_math"); -} - -/* Vector Rotate */ - -NODE_DEFINE(VectorRotateNode) -{ - NodeType *type = NodeType::add("vector_rotate", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("axis", NODE_VECTOR_ROTATE_TYPE_AXIS); - type_enum.insert("x_axis", NODE_VECTOR_ROTATE_TYPE_AXIS_X); - type_enum.insert("y_axis", NODE_VECTOR_ROTATE_TYPE_AXIS_Y); - type_enum.insert("z_axis", NODE_VECTOR_ROTATE_TYPE_AXIS_Z); - type_enum.insert("euler_xyz", NODE_VECTOR_ROTATE_TYPE_EULER_XYZ); - SOCKET_ENUM(rotate_type, "Type", type_enum, NODE_VECTOR_ROTATE_TYPE_AXIS); - - SOCKET_BOOLEAN(invert, "Invert", false); - - SOCKET_IN_VECTOR(vector, "Vector", zero_float3()); - SOCKET_IN_POINT(rotation, "Rotation", zero_float3()); - SOCKET_IN_POINT(center, "Center", zero_float3()); - SOCKET_IN_VECTOR(axis, "Axis", make_float3(0.0f, 0.0f, 1.0f)); - SOCKET_IN_FLOAT(angle, "Angle", 0.0f); - SOCKET_OUT_VECTOR(vector, "Vector"); - - return type; -} - -VectorRotateNode::VectorRotateNode() : ShaderNode(get_node_type()) -{ -} - -void VectorRotateNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *rotation_in = input("Rotation"); - ShaderInput *center_in = input("Center"); - ShaderInput *axis_in = input("Axis"); - ShaderInput *angle_in = input("Angle"); - ShaderOutput *vector_out = output("Vector"); - - compiler.add_node(NODE_VECTOR_ROTATE, - compiler.encode_uchar4(rotate_type, - compiler.stack_assign(vector_in), - compiler.stack_assign(rotation_in), - invert), - compiler.encode_uchar4(compiler.stack_assign(center_in), - compiler.stack_assign(axis_in), - compiler.stack_assign(angle_in)), - compiler.stack_assign(vector_out)); -} - -void VectorRotateNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "rotate_type"); - compiler.parameter(this, "invert"); - compiler.add(this, "node_vector_rotate"); -} - -/* VectorTransform */ - -NODE_DEFINE(VectorTransformNode) -{ - NodeType *type = NodeType::add("vector_transform", create, NodeType::SHADER); - - static NodeEnum type_enum; - type_enum.insert("vector", NODE_VECTOR_TRANSFORM_TYPE_VECTOR); - type_enum.insert("point", NODE_VECTOR_TRANSFORM_TYPE_POINT); - type_enum.insert("normal", NODE_VECTOR_TRANSFORM_TYPE_NORMAL); - SOCKET_ENUM(transform_type, "Type", type_enum, NODE_VECTOR_TRANSFORM_TYPE_VECTOR); - - static NodeEnum space_enum; - space_enum.insert("world", NODE_VECTOR_TRANSFORM_CONVERT_SPACE_WORLD); - space_enum.insert("object", NODE_VECTOR_TRANSFORM_CONVERT_SPACE_OBJECT); - space_enum.insert("camera", NODE_VECTOR_TRANSFORM_CONVERT_SPACE_CAMERA); - SOCKET_ENUM(convert_from, "Convert From", space_enum, NODE_VECTOR_TRANSFORM_CONVERT_SPACE_WORLD); - SOCKET_ENUM(convert_to, "Convert To", space_enum, NODE_VECTOR_TRANSFORM_CONVERT_SPACE_OBJECT); - - SOCKET_IN_VECTOR(vector, "Vector", zero_float3()); - SOCKET_OUT_VECTOR(vector, "Vector"); - - return type; -} - -VectorTransformNode::VectorTransformNode() : ShaderNode(get_node_type()) -{ -} - -void VectorTransformNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderOutput *vector_out = output("Vector"); - - compiler.add_node( - NODE_VECTOR_TRANSFORM, - compiler.encode_uchar4(transform_type, convert_from, convert_to), - compiler.encode_uchar4(compiler.stack_assign(vector_in), compiler.stack_assign(vector_out))); -} - -void VectorTransformNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "transform_type"); - compiler.parameter(this, "convert_from"); - compiler.parameter(this, "convert_to"); - compiler.add(this, "node_vector_transform"); -} - -/* BumpNode */ - -NODE_DEFINE(BumpNode) -{ - NodeType *type = NodeType::add("bump", create, NodeType::SHADER); - - SOCKET_BOOLEAN(invert, "Invert", false); - SOCKET_BOOLEAN(use_object_space, "UseObjectSpace", false); - - /* this input is used by the user, but after graph transform it is no longer - * used and moved to sampler center/x/y instead */ - SOCKET_IN_FLOAT(height, "Height", 1.0f); - - SOCKET_IN_FLOAT(sample_center, "SampleCenter", 0.0f); - SOCKET_IN_FLOAT(sample_x, "SampleX", 0.0f); - SOCKET_IN_FLOAT(sample_y, "SampleY", 0.0f); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - SOCKET_IN_FLOAT(strength, "Strength", 1.0f); - SOCKET_IN_FLOAT(distance, "Distance", 0.1f); - - SOCKET_OUT_NORMAL(normal, "Normal"); - - return type; -} - -BumpNode::BumpNode() : ShaderNode(get_node_type()) -{ - special_type = SHADER_SPECIAL_TYPE_BUMP; -} - -void BumpNode::compile(SVMCompiler &compiler) -{ - ShaderInput *center_in = input("SampleCenter"); - ShaderInput *dx_in = input("SampleX"); - ShaderInput *dy_in = input("SampleY"); - ShaderInput *normal_in = input("Normal"); - ShaderInput *strength_in = input("Strength"); - ShaderInput *distance_in = input("Distance"); - ShaderOutput *normal_out = output("Normal"); - - /* pack all parameters in the node */ - compiler.add_node(NODE_SET_BUMP, - compiler.encode_uchar4(compiler.stack_assign_if_linked(normal_in), - compiler.stack_assign(distance_in), - invert, - use_object_space), - compiler.encode_uchar4(compiler.stack_assign(center_in), - compiler.stack_assign(dx_in), - compiler.stack_assign(dy_in), - compiler.stack_assign(strength_in)), - compiler.stack_assign(normal_out)); -} - -void BumpNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "invert"); - compiler.parameter(this, "use_object_space"); - compiler.add(this, "node_bump"); -} - -void BumpNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *height_in = input("Height"); - ShaderInput *normal_in = input("Normal"); - - if (height_in->link == NULL) { - if (normal_in->link == NULL) { - GeometryNode *geom = folder.graph->create_node<GeometryNode>(); - folder.graph->add(geom); - folder.bypass(geom->output("Normal")); - } - else { - folder.bypass(normal_in->link); - } - } - - /* TODO(sergey): Ignore bump with zero strength. */ -} - -/* Curves node */ - -CurvesNode::CurvesNode(const NodeType *node_type) : ShaderNode(node_type) -{ -} - -void CurvesNode::constant_fold(const ConstantFolder &folder, ShaderInput *value_in) -{ - ShaderInput *fac_in = input("Fac"); - - /* evaluate fully constant node */ - if (folder.all_inputs_constant()) { - if (curves.size() == 0) { - return; - } - - float3 pos = (value - make_float3(min_x, min_x, min_x)) / (max_x - min_x); - float3 result; - - result[0] = rgb_ramp_lookup(curves.data(), pos[0], true, true, curves.size()).x; - result[1] = rgb_ramp_lookup(curves.data(), pos[1], true, true, curves.size()).y; - result[2] = rgb_ramp_lookup(curves.data(), pos[2], true, true, curves.size()).z; - - folder.make_constant(interp(value, result, fac)); - } - /* remove no-op node */ - else if (!fac_in->link && fac == 0.0f) { - /* link is not null because otherwise all inputs are constant */ - folder.bypass(value_in->link); - } -} - -void CurvesNode::compile(SVMCompiler &compiler, - int type, - ShaderInput *value_in, - ShaderOutput *value_out) -{ - if (curves.size() == 0) - return; - - ShaderInput *fac_in = input("Fac"); - - compiler.add_node(type, - compiler.encode_uchar4(compiler.stack_assign(fac_in), - compiler.stack_assign(value_in), - compiler.stack_assign(value_out)), - __float_as_int(min_x), - __float_as_int(max_x)); - - compiler.add_node(curves.size()); - for (int i = 0; i < curves.size(); i++) - compiler.add_node(float3_to_float4(curves[i])); -} - -void CurvesNode::compile(OSLCompiler &compiler, const char *name) -{ - if (curves.size() == 0) - return; - - compiler.parameter_color_array("ramp", curves); - compiler.parameter(this, "min_x"); - compiler.parameter(this, "max_x"); - compiler.add(this, name); -} - -void CurvesNode::compile(SVMCompiler & /*compiler*/) -{ - assert(0); -} - -void CurvesNode::compile(OSLCompiler & /*compiler*/) -{ - assert(0); -} - -/* RGBCurvesNode */ - -NODE_DEFINE(RGBCurvesNode) -{ - NodeType *type = NodeType::add("rgb_curves", create, NodeType::SHADER); - - SOCKET_COLOR_ARRAY(curves, "Curves", array<float3>()); - SOCKET_FLOAT(min_x, "Min X", 0.0f); - SOCKET_FLOAT(max_x, "Max X", 1.0f); - - SOCKET_IN_FLOAT(fac, "Fac", 0.0f); - SOCKET_IN_COLOR(value, "Color", zero_float3()); - - SOCKET_OUT_COLOR(value, "Color"); - - return type; -} - -RGBCurvesNode::RGBCurvesNode() : CurvesNode(get_node_type()) -{ -} - -void RGBCurvesNode::constant_fold(const ConstantFolder &folder) -{ - CurvesNode::constant_fold(folder, input("Color")); -} - -void RGBCurvesNode::compile(SVMCompiler &compiler) -{ - CurvesNode::compile(compiler, NODE_RGB_CURVES, input("Color"), output("Color")); -} - -void RGBCurvesNode::compile(OSLCompiler &compiler) -{ - CurvesNode::compile(compiler, "node_rgb_curves"); -} - -/* VectorCurvesNode */ - -NODE_DEFINE(VectorCurvesNode) -{ - NodeType *type = NodeType::add("vector_curves", create, NodeType::SHADER); - - SOCKET_VECTOR_ARRAY(curves, "Curves", array<float3>()); - SOCKET_FLOAT(min_x, "Min X", 0.0f); - SOCKET_FLOAT(max_x, "Max X", 1.0f); - - SOCKET_IN_FLOAT(fac, "Fac", 0.0f); - SOCKET_IN_VECTOR(value, "Vector", zero_float3()); - - SOCKET_OUT_VECTOR(value, "Vector"); - - return type; -} - -VectorCurvesNode::VectorCurvesNode() : CurvesNode(get_node_type()) -{ -} - -void VectorCurvesNode::constant_fold(const ConstantFolder &folder) -{ - CurvesNode::constant_fold(folder, input("Vector")); -} - -void VectorCurvesNode::compile(SVMCompiler &compiler) -{ - CurvesNode::compile(compiler, NODE_VECTOR_CURVES, input("Vector"), output("Vector")); -} - -void VectorCurvesNode::compile(OSLCompiler &compiler) -{ - CurvesNode::compile(compiler, "node_vector_curves"); -} - -/* FloatCurveNode */ - -NODE_DEFINE(FloatCurveNode) -{ - NodeType *type = NodeType::add("float_curve", create, NodeType::SHADER); - - SOCKET_FLOAT_ARRAY(curve, "Curve", array<float>()); - SOCKET_FLOAT(min_x, "Min X", 0.0f); - SOCKET_FLOAT(max_x, "Max X", 1.0f); - - SOCKET_IN_FLOAT(fac, "Factor", 0.0f); - SOCKET_IN_FLOAT(value, "Value", 0.0f); - - SOCKET_OUT_FLOAT(value, "Value"); - - return type; -} - -FloatCurveNode::FloatCurveNode() : ShaderNode(get_node_type()) -{ -} - -void FloatCurveNode::constant_fold(const ConstantFolder &folder) -{ - ShaderInput *value_in = input("Value"); - ShaderInput *fac_in = input("Factor"); - - /* evaluate fully constant node */ - if (folder.all_inputs_constant()) { - if (curve.size() == 0) { - return; - } - - float pos = (value - min_x) / (max_x - min_x); - float result = float_ramp_lookup(curve.data(), pos, true, true, curve.size()); - - folder.make_constant(value + fac * (result - value)); - } - /* remove no-op node */ - else if (!fac_in->link && fac == 0.0f) { - /* link is not null because otherwise all inputs are constant */ - folder.bypass(value_in->link); - } -} - -void FloatCurveNode::compile(SVMCompiler &compiler) -{ - if (curve.size() == 0) - return; - - ShaderInput *value_in = input("Value"); - ShaderInput *fac_in = input("Factor"); - ShaderOutput *value_out = output("Value"); - - compiler.add_node(NODE_FLOAT_CURVE, - compiler.encode_uchar4(compiler.stack_assign(fac_in), - compiler.stack_assign(value_in), - compiler.stack_assign(value_out)), - __float_as_int(min_x), - __float_as_int(max_x)); - - compiler.add_node(curve.size()); - for (int i = 0; i < curve.size(); i++) - compiler.add_node(make_float4(curve[i])); -} - -void FloatCurveNode::compile(OSLCompiler &compiler) -{ - if (curve.size() == 0) - return; - - compiler.parameter_array("ramp", curve.data(), curve.size()); - compiler.parameter(this, "min_x"); - compiler.parameter(this, "max_x"); - compiler.add(this, "node_float_curve"); -} - -/* RGBRampNode */ - -NODE_DEFINE(RGBRampNode) -{ - NodeType *type = NodeType::add("rgb_ramp", create, NodeType::SHADER); - - SOCKET_COLOR_ARRAY(ramp, "Ramp", array<float3>()); - SOCKET_FLOAT_ARRAY(ramp_alpha, "Ramp Alpha", array<float>()); - SOCKET_BOOLEAN(interpolate, "Interpolate", true); - - SOCKET_IN_FLOAT(fac, "Fac", 0.0f); - - SOCKET_OUT_COLOR(color, "Color"); - SOCKET_OUT_FLOAT(alpha, "Alpha"); - - return type; -} - -RGBRampNode::RGBRampNode() : ShaderNode(get_node_type()) -{ -} - -void RGBRampNode::constant_fold(const ConstantFolder &folder) -{ - if (ramp.size() == 0 || ramp.size() != ramp_alpha.size()) - return; - - if (folder.all_inputs_constant()) { - float f = clamp(fac, 0.0f, 1.0f) * (ramp.size() - 1); - - /* clamp int as well in case of NaN */ - int i = clamp((int)f, 0, ramp.size() - 1); - float t = f - (float)i; - - bool use_lerp = interpolate && t > 0.0f; - - if (folder.output == output("Color")) { - float3 color = rgb_ramp_lookup(ramp.data(), fac, use_lerp, false, ramp.size()); - folder.make_constant(color); - } - else if (folder.output == output("Alpha")) { - float alpha = float_ramp_lookup(ramp_alpha.data(), fac, use_lerp, false, ramp_alpha.size()); - folder.make_constant(alpha); - } - } -} - -void RGBRampNode::compile(SVMCompiler &compiler) -{ - if (ramp.size() == 0 || ramp.size() != ramp_alpha.size()) - return; - - ShaderInput *fac_in = input("Fac"); - ShaderOutput *color_out = output("Color"); - ShaderOutput *alpha_out = output("Alpha"); - - compiler.add_node(NODE_RGB_RAMP, - compiler.encode_uchar4(compiler.stack_assign(fac_in), - compiler.stack_assign_if_linked(color_out), - compiler.stack_assign_if_linked(alpha_out)), - interpolate); - - compiler.add_node(ramp.size()); - for (int i = 0; i < ramp.size(); i++) - compiler.add_node(make_float4(ramp[i].x, ramp[i].y, ramp[i].z, ramp_alpha[i])); -} - -void RGBRampNode::compile(OSLCompiler &compiler) -{ - if (ramp.size() == 0 || ramp.size() != ramp_alpha.size()) - return; - - compiler.parameter_color_array("ramp_color", ramp); - compiler.parameter_array("ramp_alpha", ramp_alpha.data(), ramp_alpha.size()); - compiler.parameter(this, "interpolate"); - - compiler.add(this, "node_rgb_ramp"); -} - -/* Set Normal Node */ - -NODE_DEFINE(SetNormalNode) -{ - NodeType *type = NodeType::add("set_normal", create, NodeType::SHADER); - - SOCKET_IN_VECTOR(direction, "Direction", zero_float3()); - SOCKET_OUT_NORMAL(normal, "Normal"); - - return type; -} - -SetNormalNode::SetNormalNode() : ShaderNode(get_node_type()) -{ -} - -void SetNormalNode::compile(SVMCompiler &compiler) -{ - ShaderInput *direction_in = input("Direction"); - ShaderOutput *normal_out = output("Normal"); - - compiler.add_node(NODE_CLOSURE_SET_NORMAL, - compiler.stack_assign(direction_in), - compiler.stack_assign(normal_out)); -} - -void SetNormalNode::compile(OSLCompiler &compiler) -{ - compiler.add(this, "node_set_normal"); -} - -/* OSLNode */ - -OSLNode::OSLNode() : ShaderNode(new NodeType(NodeType::SHADER)) -{ - special_type = SHADER_SPECIAL_TYPE_OSL; -} - -OSLNode::~OSLNode() -{ - delete type; -} - -ShaderNode *OSLNode::clone(ShaderGraph *graph) const -{ - return OSLNode::create(graph, this->inputs.size(), this); -} - -OSLNode *OSLNode::create(ShaderGraph *graph, size_t num_inputs, const OSLNode *from) -{ - /* allocate space for the node itself and parameters, aligned to 16 bytes - * assuming that's the most parameter types need */ - size_t node_size = align_up(sizeof(OSLNode), 16); - size_t inputs_size = align_up(SocketType::max_size(), 16) * num_inputs; - - char *node_memory = (char *)operator new(node_size + inputs_size); - memset(node_memory, 0, node_size + inputs_size); - - if (!from) { - OSLNode *node = new (node_memory) OSLNode(); - node->set_owner(graph); - return node; - } - else { - /* copy input default values and node type for cloning */ - memcpy(node_memory + node_size, (char *)from + node_size, inputs_size); - - OSLNode *node = new (node_memory) OSLNode(*from); - node->type = new NodeType(*(from->type)); - node->set_owner(from->owner); - return node; - } -} - -char *OSLNode::input_default_value() -{ - /* pointer to default value storage, which is the same as our actual value */ - size_t num_inputs = type->inputs.size(); - size_t inputs_size = align_up(SocketType::max_size(), 16) * num_inputs; - return (char *)this + align_up(sizeof(OSLNode), 16) + inputs_size; -} - -void OSLNode::add_input(ustring name, SocketType::Type socket_type) -{ - char *memory = input_default_value(); - size_t offset = memory - (char *)this; - const_cast<NodeType *>(type)->register_input( - name, name, socket_type, offset, memory, NULL, NULL, SocketType::LINKABLE); -} - -void OSLNode::add_output(ustring name, SocketType::Type socket_type) -{ - const_cast<NodeType *>(type)->register_output(name, name, socket_type); -} - -void OSLNode::compile(SVMCompiler &) -{ - /* doesn't work for SVM, obviously ... */ -} - -void OSLNode::compile(OSLCompiler &compiler) -{ - if (!filepath.empty()) - compiler.add(this, filepath.c_str(), true); - else - compiler.add(this, bytecode_hash.c_str(), false); -} - -/* Normal Map */ - -NODE_DEFINE(NormalMapNode) -{ - NodeType *type = NodeType::add("normal_map", create, NodeType::SHADER); - - static NodeEnum space_enum; - space_enum.insert("tangent", NODE_NORMAL_MAP_TANGENT); - space_enum.insert("object", NODE_NORMAL_MAP_OBJECT); - space_enum.insert("world", NODE_NORMAL_MAP_WORLD); - space_enum.insert("blender_object", NODE_NORMAL_MAP_BLENDER_OBJECT); - space_enum.insert("blender_world", NODE_NORMAL_MAP_BLENDER_WORLD); - SOCKET_ENUM(space, "Space", space_enum, NODE_NORMAL_MAP_TANGENT); - - SOCKET_STRING(attribute, "Attribute", ustring()); - - SOCKET_IN_NORMAL( - normal_osl, "NormalIn", zero_float3(), SocketType::LINK_NORMAL | SocketType::OSL_INTERNAL); - SOCKET_IN_FLOAT(strength, "Strength", 1.0f); - SOCKET_IN_COLOR(color, "Color", make_float3(0.5f, 0.5f, 1.0f)); - - SOCKET_OUT_NORMAL(normal, "Normal"); - - return type; -} - -NormalMapNode::NormalMapNode() : ShaderNode(get_node_type()) -{ -} - -void NormalMapNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link() && space == NODE_NORMAL_MAP_TANGENT) { - if (attribute.empty()) { - attributes->add(ATTR_STD_UV_TANGENT); - attributes->add(ATTR_STD_UV_TANGENT_SIGN); - } - else { - attributes->add(ustring((string(attribute.c_str()) + ".tangent").c_str())); - attributes->add(ustring((string(attribute.c_str()) + ".tangent_sign").c_str())); - } - } - - ShaderNode::attributes(shader, attributes); -} - -void NormalMapNode::compile(SVMCompiler &compiler) -{ - ShaderInput *color_in = input("Color"); - ShaderInput *strength_in = input("Strength"); - ShaderOutput *normal_out = output("Normal"); - int attr = 0, attr_sign = 0; - - if (space == NODE_NORMAL_MAP_TANGENT) { - if (attribute.empty()) { - attr = compiler.attribute(ATTR_STD_UV_TANGENT); - attr_sign = compiler.attribute(ATTR_STD_UV_TANGENT_SIGN); - } - else { - attr = compiler.attribute(ustring((string(attribute.c_str()) + ".tangent").c_str())); - attr_sign = compiler.attribute( - ustring((string(attribute.c_str()) + ".tangent_sign").c_str())); - } - } - - compiler.add_node(NODE_NORMAL_MAP, - compiler.encode_uchar4(compiler.stack_assign(color_in), - compiler.stack_assign(strength_in), - compiler.stack_assign(normal_out), - space), - attr, - attr_sign); -} - -void NormalMapNode::compile(OSLCompiler &compiler) -{ - if (space == NODE_NORMAL_MAP_TANGENT) { - if (attribute.empty()) { - compiler.parameter("attr_name", ustring("geom:tangent")); - compiler.parameter("attr_sign_name", ustring("geom:tangent_sign")); - } - else { - compiler.parameter("attr_name", ustring((string(attribute.c_str()) + ".tangent").c_str())); - compiler.parameter("attr_sign_name", - ustring((string(attribute.c_str()) + ".tangent_sign").c_str())); - } - } - - compiler.parameter(this, "space"); - compiler.add(this, "node_normal_map"); -} - -/* Tangent */ - -NODE_DEFINE(TangentNode) -{ - NodeType *type = NodeType::add("tangent", create, NodeType::SHADER); - - static NodeEnum direction_type_enum; - direction_type_enum.insert("radial", NODE_TANGENT_RADIAL); - direction_type_enum.insert("uv_map", NODE_TANGENT_UVMAP); - SOCKET_ENUM(direction_type, "Direction Type", direction_type_enum, NODE_TANGENT_RADIAL); - - static NodeEnum axis_enum; - axis_enum.insert("x", NODE_TANGENT_AXIS_X); - axis_enum.insert("y", NODE_TANGENT_AXIS_Y); - axis_enum.insert("z", NODE_TANGENT_AXIS_Z); - SOCKET_ENUM(axis, "Axis", axis_enum, NODE_TANGENT_AXIS_X); - - SOCKET_STRING(attribute, "Attribute", ustring()); - - SOCKET_IN_NORMAL( - normal_osl, "NormalIn", zero_float3(), SocketType::LINK_NORMAL | SocketType::OSL_INTERNAL); - SOCKET_OUT_NORMAL(tangent, "Tangent"); - - return type; -} - -TangentNode::TangentNode() : ShaderNode(get_node_type()) -{ -} - -void TangentNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link()) { - if (direction_type == NODE_TANGENT_UVMAP) { - if (attribute.empty()) - attributes->add(ATTR_STD_UV_TANGENT); - else - attributes->add(ustring((string(attribute.c_str()) + ".tangent").c_str())); - } - else - attributes->add(ATTR_STD_GENERATED); - } - - ShaderNode::attributes(shader, attributes); -} - -void TangentNode::compile(SVMCompiler &compiler) -{ - ShaderOutput *tangent_out = output("Tangent"); - int attr; - - if (direction_type == NODE_TANGENT_UVMAP) { - if (attribute.empty()) - attr = compiler.attribute(ATTR_STD_UV_TANGENT); - else - attr = compiler.attribute(ustring((string(attribute.c_str()) + ".tangent").c_str())); - } - else - attr = compiler.attribute(ATTR_STD_GENERATED); - - compiler.add_node( - NODE_TANGENT, - compiler.encode_uchar4(compiler.stack_assign(tangent_out), direction_type, axis), - attr); -} - -void TangentNode::compile(OSLCompiler &compiler) -{ - if (direction_type == NODE_TANGENT_UVMAP) { - if (attribute.empty()) - compiler.parameter("attr_name", ustring("geom:tangent")); - else - compiler.parameter("attr_name", ustring((string(attribute.c_str()) + ".tangent").c_str())); - } - - compiler.parameter(this, "direction_type"); - compiler.parameter(this, "axis"); - compiler.add(this, "node_tangent"); -} - -/* Bevel */ - -NODE_DEFINE(BevelNode) -{ - NodeType *type = NodeType::add("bevel", create, NodeType::SHADER); - - SOCKET_INT(samples, "Samples", 4); - - SOCKET_IN_FLOAT(radius, "Radius", 0.05f); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - - SOCKET_OUT_NORMAL(bevel, "Normal"); - - return type; -} - -BevelNode::BevelNode() : ShaderNode(get_node_type()) -{ -} - -void BevelNode::compile(SVMCompiler &compiler) -{ - ShaderInput *radius_in = input("Radius"); - ShaderInput *normal_in = input("Normal"); - ShaderOutput *normal_out = output("Normal"); - - compiler.add_node(NODE_BEVEL, - compiler.encode_uchar4(samples, - compiler.stack_assign(radius_in), - compiler.stack_assign_if_linked(normal_in), - compiler.stack_assign(normal_out))); -} - -void BevelNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "samples"); - compiler.add(this, "node_bevel"); -} - -/* Displacement */ - -NODE_DEFINE(DisplacementNode) -{ - NodeType *type = NodeType::add("displacement", create, NodeType::SHADER); - - static NodeEnum space_enum; - space_enum.insert("object", NODE_NORMAL_MAP_OBJECT); - space_enum.insert("world", NODE_NORMAL_MAP_WORLD); - - SOCKET_ENUM(space, "Space", space_enum, NODE_NORMAL_MAP_OBJECT); - - SOCKET_IN_FLOAT(height, "Height", 0.0f); - SOCKET_IN_FLOAT(midlevel, "Midlevel", 0.5f); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - SOCKET_IN_NORMAL(normal, "Normal", zero_float3(), SocketType::LINK_NORMAL); - - SOCKET_OUT_VECTOR(displacement, "Displacement"); - - return type; -} - -DisplacementNode::DisplacementNode() : ShaderNode(get_node_type()) -{ -} - -void DisplacementNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - if ((height - midlevel == 0.0f) || (scale == 0.0f)) { - folder.make_zero(); - } - } -} - -void DisplacementNode::compile(SVMCompiler &compiler) -{ - ShaderInput *height_in = input("Height"); - ShaderInput *midlevel_in = input("Midlevel"); - ShaderInput *scale_in = input("Scale"); - ShaderInput *normal_in = input("Normal"); - ShaderOutput *displacement_out = output("Displacement"); - - compiler.add_node(NODE_DISPLACEMENT, - compiler.encode_uchar4(compiler.stack_assign(height_in), - compiler.stack_assign(midlevel_in), - compiler.stack_assign(scale_in), - compiler.stack_assign_if_linked(normal_in)), - compiler.stack_assign(displacement_out), - space); -} - -void DisplacementNode::compile(OSLCompiler &compiler) -{ - compiler.parameter(this, "space"); - compiler.add(this, "node_displacement"); -} - -/* Vector Displacement */ - -NODE_DEFINE(VectorDisplacementNode) -{ - NodeType *type = NodeType::add("vector_displacement", create, NodeType::SHADER); - - static NodeEnum space_enum; - space_enum.insert("tangent", NODE_NORMAL_MAP_TANGENT); - space_enum.insert("object", NODE_NORMAL_MAP_OBJECT); - space_enum.insert("world", NODE_NORMAL_MAP_WORLD); - - SOCKET_ENUM(space, "Space", space_enum, NODE_NORMAL_MAP_TANGENT); - SOCKET_STRING(attribute, "Attribute", ustring()); - - SOCKET_IN_COLOR(vector, "Vector", zero_float3()); - SOCKET_IN_FLOAT(midlevel, "Midlevel", 0.0f); - SOCKET_IN_FLOAT(scale, "Scale", 1.0f); - - SOCKET_OUT_VECTOR(displacement, "Displacement"); - - return type; -} - -VectorDisplacementNode::VectorDisplacementNode() : ShaderNode(get_node_type()) -{ -} - -void VectorDisplacementNode::constant_fold(const ConstantFolder &folder) -{ - if (folder.all_inputs_constant()) { - if ((vector == zero_float3() && midlevel == 0.0f) || (scale == 0.0f)) { - folder.make_zero(); - } - } -} - -void VectorDisplacementNode::attributes(Shader *shader, AttributeRequestSet *attributes) -{ - if (shader->has_surface_link() && space == NODE_NORMAL_MAP_TANGENT) { - if (attribute.empty()) { - attributes->add(ATTR_STD_UV_TANGENT); - attributes->add(ATTR_STD_UV_TANGENT_SIGN); - } - else { - attributes->add(ustring((string(attribute.c_str()) + ".tangent").c_str())); - attributes->add(ustring((string(attribute.c_str()) + ".tangent_sign").c_str())); - } - } - - ShaderNode::attributes(shader, attributes); -} - -void VectorDisplacementNode::compile(SVMCompiler &compiler) -{ - ShaderInput *vector_in = input("Vector"); - ShaderInput *midlevel_in = input("Midlevel"); - ShaderInput *scale_in = input("Scale"); - ShaderOutput *displacement_out = output("Displacement"); - int attr = 0, attr_sign = 0; - - if (space == NODE_NORMAL_MAP_TANGENT) { - if (attribute.empty()) { - attr = compiler.attribute(ATTR_STD_UV_TANGENT); - attr_sign = compiler.attribute(ATTR_STD_UV_TANGENT_SIGN); - } - else { - attr = compiler.attribute(ustring((string(attribute.c_str()) + ".tangent").c_str())); - attr_sign = compiler.attribute( - ustring((string(attribute.c_str()) + ".tangent_sign").c_str())); - } - } - - compiler.add_node(NODE_VECTOR_DISPLACEMENT, - compiler.encode_uchar4(compiler.stack_assign(vector_in), - compiler.stack_assign(midlevel_in), - compiler.stack_assign(scale_in), - compiler.stack_assign(displacement_out)), - attr, - attr_sign); - - compiler.add_node(space); -} - -void VectorDisplacementNode::compile(OSLCompiler &compiler) -{ - if (space == NODE_NORMAL_MAP_TANGENT) { - if (attribute.empty()) { - compiler.parameter("attr_name", ustring("geom:tangent")); - compiler.parameter("attr_sign_name", ustring("geom:tangent_sign")); - } - else { - compiler.parameter("attr_name", ustring((string(attribute.c_str()) + ".tangent").c_str())); - compiler.parameter("attr_sign_name", - ustring((string(attribute.c_str()) + ".tangent_sign").c_str())); - } - } - - compiler.parameter(this, "space"); - compiler.add(this, "node_vector_displacement"); -} - -CCL_NAMESPACE_END |