| /****************************************************************************** | |
| * Copyright 2024 NVIDIA Corporation. All rights reserved. | |
| ****************************************************************************** | |
| Permission is hereby granted by NVIDIA Corporation ("NVIDIA"), free of charge, | |
| to any person obtaining a copy of the sample definition code that uses our | |
| Material Definition Language (the "MDL Materials"), to reproduce and distribute | |
| the MDL Materials, including without limitation the rights to use, copy, merge, | |
| publish, distribute, and sell modified and unmodified copies of the MDL | |
| Materials, and to permit persons to whom the MDL Materials is furnished to do | |
| so, in all cases solely for use with NVIDIA's Material Definition Language, | |
| subject to the following further conditions: | |
| 1. The above copyright notices, this list of conditions, and the disclaimer | |
| that follows shall be retained in all copies of one or more of the MDL | |
| Materials, including in any software with which the MDL Materials are bundled, | |
| redistributed, and/or sold, and included either as stand-alone text files, | |
| human-readable headers or in the appropriate machine-readable metadata fields | |
| within text or binary files as long as those fields can be easily viewed by the | |
| user, as applicable. | |
| 2. The name of NVIDIA shall not be used to promote, endorse or advertise any | |
| Modified Version without specific prior written permission, except a) to comply | |
| with the notice requirements otherwise contained herein; or b) to acknowledge | |
| the contribution(s) of NVIDIA. | |
| THE MDL MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
| OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, | |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, | |
| TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR | |
| ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, | |
| INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF | |
| CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE | |
| THE MDL MATERIALS OR FROM OTHER DEALINGS IN THE MDL MATERIALS. | |
| */ | |
| // This file contains samples of very fast rendering SSS plastics for iray | |
| // | |
| mdl 1.4; | |
| import ::df::*; | |
| import ::math::*; | |
| import ::anno::*; | |
| import ::state::*; | |
| import ::base::*; | |
| import ::nvidia::core_definitions::dimension; | |
| const string COPYRIGHT = | |
| " Copyright 2024 NVIDIA Corporation. All rights reserved.\n" | |
| " MDL MATERIALS ARE PROVIDED PURSUANT TO AN END USER LICENSE AGREEMENT,\n" | |
| " WHICH WAS ACCEPTED IN ORDER TO GAIN ACCESS TO THIS FILE. IN PARTICULAR,\n" | |
| " THE MDL MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n" | |
| " EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF\n" | |
| " MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF\n" | |
| " COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL NVIDIA\n" | |
| " CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY\n" | |
| " GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN\n" | |
| " AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR\n" | |
| " INABILITY TO USE THE MDL MATERIALS OR FROM OTHER DEALINGS IN THE MDL MATERIALS.\n"; | |
| const string DESCRIPTION = | |
| "Translucent plastic material with integrated metal flakes. Features: Effective light scattering for dense " | |
| "plastic materials and metal flakes. The material was built to scatter light within the range of a few " | |
| "centimeters. If light scattering cannot be seen (which can be verified by setting 'Diffuse Weight' to 0.0), " | |
| "check the scene units scale or increase 'Distance Scale'."; | |
| // | |
| // flake noise utilities | |
| // | |
| int hash(int seed, int i) | |
| { | |
| return (i ^ seed) * 1075385539; | |
| } | |
| int rnd_init(int3 pos) | |
| { | |
| return hash(hash(hash(0, pos.x), pos.y), pos.z); | |
| } | |
| int rnd_next(int seed) { | |
| // xorshift32 using signed int | |
| seed ^= seed << 13; | |
| seed ^= seed >>> 17; | |
| seed ^= seed << 5; | |
| return seed; | |
| } | |
| float rnd_value(int seed) | |
| { | |
| return ::math::abs(float(seed) * 4.6566e-10f); | |
| } | |
| // apply random rotation (using "Fast Random Rotation Matrices" by James Arvo) | |
| float3 rotate_pos(float3 pos, float3 xi) | |
| { | |
| float theta = ::math::PI * 2.0f * xi.x; | |
| float phi = ::math::PI * 2.0f * xi.y; | |
| float z = xi.z * 2.0f; | |
| float r = ::math::sqrt(z); | |
| float[2] sp_cp = ::math::sincos(phi); | |
| float Vx = sp_cp[0] * r; | |
| float Vy = sp_cp[1] * r; | |
| float Vz = ::math::sqrt(2.0f - z); | |
| float[2] st_ct = ::math::sincos(theta); | |
| float Sx = Vx * st_ct[1] - Vy * st_ct[0]; | |
| float Sy = Vx * st_ct[0] + Vy * st_ct[1]; | |
| float3x3 M( | |
| Vx * Sx - st_ct[1], Vx * Sy - st_ct[0], Vx * Vz, | |
| Vy * Sx + st_ct[0], Vy * Sy - st_ct[1], Vy * Vz, | |
| Vz * Sx, Vz * Sy, 1.0f - z); | |
| return M * pos; | |
| } | |
| struct flake_noise_value { | |
| // flake priority (in [0..1], 0: no flake, flakes with higher priority shadow flakes "below" them) | |
| float priority; | |
| // Stores values from the functions (once normal, another time the color) | |
| // current pseudo random number generator seed | |
| int rnd_seed; | |
| float4 carrier; | |
| }; | |
| // flake noise function with controllable regularity, flake size, and probability | |
| flake_noise_value flake_noise( | |
| float3 pos, | |
| float jitter_scale = 1.0f, | |
| float flake_diameter = 0.75f, | |
| float flake_probability = 1.0f) | |
| { | |
| float3 base_pos = ::math::floor(pos); | |
| int3 base_pos_i = int3(base_pos); | |
| // limit the flake size to the allowed maximum (such that looking at all neighbors is sufficient) | |
| flake_diameter = ::math::min(flake_diameter, (1.5f - 0.5f * jitter_scale) / ::math::sqrt(3.0f)); | |
| flake_noise_value val(0.0f, 0, float4(0.0)); | |
| for (int i = -1; i < 2; ++i) { | |
| for (int j = -1; j < 2; ++j) { | |
| for (int k = -1; k < 2; ++k) { | |
| int seed = rnd_init(base_pos_i + int3(i, j, k)); | |
| seed = rnd_next(seed); | |
| if (rnd_value(seed) > flake_probability) | |
| continue; | |
| seed = rnd_next(seed); | |
| float priority = rnd_value(seed); | |
| if (priority < val.priority) | |
| continue; | |
| float3 flake_pos = base_pos + float3(i, j, k) + float3(0.5f); | |
| if (jitter_scale > 0.0f) { | |
| seed = rnd_next(seed); | |
| flake_pos.x += (rnd_value(seed) - 0.5f) * jitter_scale; | |
| seed = rnd_next(seed); | |
| flake_pos.y += (rnd_value(seed) - 0.5f) * jitter_scale; | |
| seed = rnd_next(seed); | |
| flake_pos.z += (rnd_value(seed) - 0.5f) * jitter_scale; | |
| } | |
| float3 p = pos - flake_pos; | |
| if (::math::dot(p, p) >= flake_diameter * flake_diameter * 4.0f) | |
| continue; | |
| float3 xi_rot; | |
| seed = rnd_next(seed); | |
| xi_rot.x = rnd_value(seed); | |
| seed = rnd_next(seed); | |
| xi_rot.y = rnd_value(seed); | |
| seed = rnd_next(seed); | |
| xi_rot.z = rnd_value(seed); | |
| p = rotate_pos(p, xi_rot); | |
| if (::math::abs(p.x) <= flake_diameter && | |
| ::math::abs(p.y) <= flake_diameter && | |
| ::math::abs(p.z) <= flake_diameter) | |
| { | |
| val.priority = priority; | |
| val.rnd_seed = seed; | |
| } | |
| } | |
| } | |
| } | |
| return val; | |
| } | |
| // constants for numerical fitted curve to observed flake noise density behavior | |
| // 1. no jitter, maximum flake diameter | |
| const float4 ABCD = float4(-26.19771808f, 26.39663835f, 85.53857017f, -102.35069432f); | |
| const float2 EF = float2(-101.42634862f, 118.45082288f); | |
| // 2. jitter scale of 0.5f, maximum flake diameter | |
| const float4 ABCD_J = float4(-0.87962159f, 0.91006603f, 0.76088203f, -0.24953308f); | |
| const float2 EF_J = float2(-3.11456809f, 2.63430594f); | |
| // compute a flake probability for a given flake coverage density x | |
| float density_to_probability( | |
| float4 abcd, | |
| float2 ef, | |
| float x) | |
| { | |
| float xx = x * x; | |
| return (abcd.x * xx + abcd.y * x) / (abcd.z * xx * x + abcd.w * xx + ef.x * x + ef.y); | |
| } | |
| // statistically controlled (area/volume coverage density) flake noise | |
| flake_noise_value flake_noise( | |
| float3 position, | |
| float density = 0.5f, | |
| bool jittered = false) // jittered: slightly slower and slightly less uniform | |
| { | |
| float probability = density_to_probability(jittered ? ABCD_J : ABCD, jittered ? EF_J : EF, ::math::saturate(density)); | |
| return flake_noise(pos: position, jitter_scale: jittered ? 0.5f : 0.0f, flake_diameter: (jittered ? 1.25f : 1.5f) / ::math::sqrt(3.0f), flake_probability: probability); | |
| } | |
| // create a flake normal by importance sampling the Beckmann distribution with given roughness | |
| flake_noise_value flake_normal( | |
| flake_noise_value val, | |
| float spread) | |
| { | |
| if (val.priority <= 0.0f) | |
| { | |
| val.carrier = float4(::state::normal().x, ::state::normal().y, ::state::normal().z, 1.0); | |
| return val; | |
| } | |
| // int seed0 = rnd_next(val.rnd_seed); | |
| // float xi0 = rnd_value(seed0); | |
| // float xi1 = rnd_value(rnd_next(seed0)); | |
| int seed = rnd_next(val.rnd_seed); | |
| float xi0 = rnd_value(seed); | |
| seed = rnd_next(seed); | |
| float xi1 = rnd_value(seed); | |
| float phi = ::math::PI * 2.0f * xi0; | |
| float roughness = spread * spread; | |
| float tantheta = ::math::sqrt(-roughness * roughness * ::math::log(1.0f - xi1)); | |
| float sintheta = tantheta / ::math::sqrt(1.0f + tantheta * tantheta); | |
| float costheta = ::math::sqrt(1.0f - sintheta * sintheta); | |
| float[2] scphi = ::math::sincos(phi); | |
| val.rnd_seed = seed; | |
| // return | |
| // ::state::texture_tangent_u(0) * scphi[1] * sintheta + | |
| // ::state::texture_tangent_v(0) * scphi[0] * sintheta + | |
| // ::state::normal() * costheta; | |
| float3 normal = ::state::texture_tangent_u(0) * scphi[1] * sintheta + | |
| ::state::texture_tangent_v(0) * scphi[0] * sintheta + | |
| ::state::normal() * costheta; | |
| val.carrier = float4(normal.x, normal.y, normal.z, 1.0); | |
| return val; | |
| } | |
| flake_noise_value random_flake_color(flake_noise_value val) | |
| { | |
| int seed = rnd_next(val.rnd_seed); | |
| float r = rnd_value(seed); | |
| seed = rnd_next(seed); | |
| float g = rnd_value(seed); | |
| seed = rnd_next(seed); | |
| float b = rnd_value(seed); | |
| seed = rnd_next(seed); | |
| float a = rnd_value(seed); | |
| val.carrier = float4(r, g, b, a); | |
| return val; | |
| } | |
| // Template for absorption and scattering, do not use directly | |
| material volume_absorption( | |
| color absorption = color(0.8665, 0.7769, 0.1559), | |
| color scattering = color(.5), | |
| float distance_scale = .03, | |
| float directional_bias = 0.0, | |
| uniform float ior = 1.2 | |
| ) | |
| [[ | |
| ::anno::author("NVIDIA vMaterials"), | |
| ::anno::display_name("Volume Absorption"), | |
| ::anno::description("Pure volume absorption material"), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.volume_absorption.png"), | |
| ::anno::copyright_notice(COPYRIGHT), | |
| ::anno::hidden() | |
| ]] = material ( | |
| ior: color(ior), | |
| surface: material_surface ( | |
| scattering: ::df::specular_bsdf ( | |
| tint: color (1.0, 1.0, 1.0), | |
| mode: ::df::scatter_reflect_transmit | |
| ) | |
| ), | |
| volume: material_volume ( | |
| scattering: ::df::anisotropic_vdf( | |
| directional_bias: directional_bias | |
| ), | |
| absorption_coefficient: (distance_scale <= 0)? color(0): ::math::log(absorption) / -distance_scale, | |
| scattering_coefficient: (distance_scale <= 0)? color(0): ::math::log(scattering) / -distance_scale | |
| ) | |
| ); | |
| // metallic_plastic_full_weighted_mix( ) | |
| // Plastic material using diffuse reflection, diffuse transmission | |
| // and SSS. Due to the diffuse transmission the volume absorption will | |
| // render faster and converge smoother than when using specular transmission. | |
| export material Plastic_Thick_Translucent_Flakes( | |
| color diffuse_color = color(0.6940f, 0.5831f, 0.0493f) | |
| [[ | |
| ::anno::display_name("Diffuse Color"), | |
| ::anno::description("The diffuse color of the plastic material"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| float diffuse_weight = 0.3f | |
| [[ | |
| ::anno::display_name("Diffuse Weight"), | |
| ::anno::description("The weight of the diffuse color of the plastic material. It is recommended to keep " | |
| "the value around 0.5, lower values make the material appear more transparent while higher values make " | |
| "it more opaque."), | |
| ::anno::in_group("Appearance"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]], | |
| color absorption = color(0.8665f, 0.7769f, 0.1559f) | |
| [[ | |
| ::anno::display_name("Absorption Color"), | |
| ::anno::description("Sets the absorption color (this is color when light goes extinct)of the plastic material"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| color scattering = color(.5f) | |
| [[ | |
| ::anno::display_name("Scattering Color"), | |
| ::anno::description("Sets the absorption color (this is color when light goes extinct)of the plastic material"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| float distance_scale = 1.5f | |
| [[ | |
| ::anno::display_name("Distance Scale"), | |
| ::anno::description("Scales how quickly light is absorbed. Set this value low enough to see " | |
| "some light extinction taking place. Tip: Set 'diffuse_weight' to 0.0 while adjusting this " | |
| "material parameter for your scene"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| color diffuse_transmission_tint = color(1.0000f, 0.7249f, 0.1972f) | |
| [[ | |
| ::anno::display_name("Diffuse Transmission Color"), | |
| ::anno::description("The tinting of light scattering through the plastic material"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| float reflection_roughness = 0.0f | |
| [[ | |
| ::anno::display_name("Roughness"), | |
| ::anno::description("The roughness of the reflection on the plastic"), | |
| ::anno::in_group("Appearance"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]], | |
| // Flakes Controls | |
| color flake_color_1 = color(1.0f, 1.0f, 1.0f) | |
| [[ | |
| ::anno::display_name("Flakes Color"), | |
| ::anno::description("Flakes Color"), | |
| ::anno::in_group("Flakes") | |
| ]], | |
| bool enable_color_randomization = true | |
| [[ | |
| ::anno::display_name("Flakes Color Randomization"), | |
| ::anno::description("Enables that a random flakes color will be chosen. Using 'Flakes Color Randomness' allows " | |
| "to blend between the chosen reflection color for the flakes and an purely random chosen color."), | |
| ::anno::in_group("Flakes") | |
| ]], | |
| float flake_color_randomness = 1.0f | |
| [[ | |
| ::anno::display_name("Flakes Color Randomness"), | |
| ::anno::description("Incresing this value will blend towards a randomly chosen flakes color."), | |
| ::anno::in_group("Flakes"), | |
| ::anno::hard_range(0.f, 1.f), | |
| ::anno::enable_if("enable_color_randomization == true") | |
| ]], | |
| uniform float flake_size = 0.1f | |
| [[ | |
| ::anno::display_name("Flakes Size"), | |
| ::anno::description("The size of the flakes in the material"), | |
| ::anno::in_group("Flakes") | |
| ]], | |
| uniform float3 texture_scale = float3 ( 1.f , 1.f, 1.f) | |
| [[ | |
| //::anno::hidden(), | |
| ::anno::display_name("Scale"), | |
| ::anno::description("Larger numbers increase the texture size."), | |
| ::nvidia::core_definitions::dimension(float3(1.0f, 1.0f, 1.0f)), | |
| ::anno::in_group("Transform") | |
| ]], | |
| uniform float flake_amount = 0.1f | |
| [[ | |
| ::anno::display_name("Flakes Amount"), | |
| ::anno::description("The number of flakes used in the material, 0 meaning no flakes, 1 meaning that flakes " | |
| "cover the entire surface"), | |
| ::anno::in_group("Flakes"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]], | |
| float flake_spread = 0.7f | |
| [[ | |
| ::anno::display_name("Flakes Spread"), | |
| ::anno::description("The amount of randomness in the orientation of the flakes. When set to zero, flakes are " | |
| "oriented along the surface normal. Higher values tilt the flakes stronger in a random direction."), | |
| ::anno::in_group("Flakes"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]] | |
| ) | |
| [[ | |
| ::anno::author("NVIDIA vMaterials"), | |
| ::anno::display_name("Plastic Full Control"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.Plastic_Thick_Translucent_Flakes.png"), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment")), | |
| ::anno::copyright_notice(COPYRIGHT), | |
| ::anno::hidden() | |
| ]] = let { | |
| // Hardcoded plastic parameters | |
| float reflection_weight = 1.0f; | |
| float normal_reflectivity = 0.04f; | |
| float grazing_reflectivity = 1.0f; | |
| float reflectivity_exponent = 5.0f; | |
| uniform float ior = 1.4f; | |
| // Hardcoded flake parameters | |
| uniform float flake_roughness = 0.4f; | |
| float flake_transparency_randomness = 1.0f; | |
| float flakes_opacity = 0.8; | |
| // Flakes | |
| float3 flake_uvw_scale = float3(1.0f); | |
| ::base::texture_coordinate_info uvw = ::base::coordinate_source( | |
| coordinate_system: ::base::texture_coordinate_world, | |
| texture_space: 0 | |
| ); | |
| ::base::texture_coordinate_info transformed_uvw = uvw; | |
| float3 flake_uvw = (texture_scale * transformed_uvw.position * flake_uvw_scale) / (flake_size * 0.001f); | |
| flake_noise_value val = flake_noise(flake_uvw, flake_amount, true); | |
| bool is_flake = val.priority > 0.0f; | |
| flake_noise_value val2 = flake_normal(val, flake_spread); | |
| float3 flake_normal = float3(val2.carrier.x, val2.carrier.y, val2.carrier.z); | |
| flake_noise_value val3 = random_flake_color(val2); | |
| color random_color = color(val3.carrier.x, val3.carrier.y, val3.carrier.z); | |
| float flakes_transparency_value = ::math::lerp(flakes_opacity, val3.carrier.w * flakes_opacity, flake_transparency_randomness); | |
| color flake_color = enable_color_randomization ? | |
| ::math::lerp(flake_color_1, random_color, flake_color_randomness) : flake_color_1; | |
| bsdf flakes = ::df::simple_glossy_bsdf(mode: ::df::scatter_reflect, roughness_u: flake_roughness * flake_roughness, tint: flake_color); | |
| // Plastic | |
| material plastic = volume_absorption( | |
| absorption: absorption, | |
| scattering: scattering, | |
| distance_scale: distance_scale, | |
| ior: ior | |
| ); | |
| bsdf transdiff = ::df::diffuse_transmission_bsdf( | |
| tint: diffuse_transmission_tint | |
| ); | |
| bsdf diffuse = ::df::diffuse_reflection_bsdf( | |
| tint: diffuse_color | |
| ); | |
| bsdf diffuse_mix_layer = ::df::weighted_layer( | |
| base: transdiff, | |
| layer: diffuse, | |
| weight: diffuse_weight | |
| ); | |
| bsdf plastic_with_flakes = ::df::weighted_layer( | |
| base: diffuse_mix_layer, | |
| layer: flakes, | |
| weight: is_flake ? flakes_transparency_value : 0.0f, | |
| normal: flake_normal | |
| ); | |
| bsdf glossy_reflection = ::df::simple_glossy_bsdf( | |
| tint: color(1.0), | |
| roughness_u: reflection_roughness, | |
| mode: ::df::scatter_reflect | |
| ); | |
| bsdf final_layer = ::df::custom_curve_layer( | |
| normal_reflectivity: normal_reflectivity, | |
| grazing_reflectivity: grazing_reflectivity, | |
| layer: glossy_reflection, | |
| base: plastic_with_flakes, | |
| weight: reflection_weight, | |
| exponent: reflectivity_exponent | |
| ); | |
| } in material ( | |
| surface: material_surface( | |
| scattering: final_layer | |
| ), | |
| volume: plastic.volume | |
| ); | |
| export material metallic_plastic_simple_controls( | |
| color diffuse_color = color(0.6940, 0.5831, 0.0493) | |
| [[ | |
| ::anno::display_name("Diffuse Color"), | |
| ::anno::description("The diffuse color of the plastic material"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| float diffuse_weight = 0.5 | |
| [[ | |
| ::anno::display_name("Diffuse Weight"), | |
| ::anno::description("The weight of the diffuse color of the plastic material. It is recommended to keep " | |
| "the value around 0.5, lower values make the material appear more transparent while higher values make " | |
| "it more opaque."), | |
| ::anno::in_group("Appearance"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]], | |
| color transmissive_color = color(0.8665, 0.7769, 0.1559) | |
| [[ | |
| ::anno::display_name("Transmissive Color"), | |
| ::anno::description("The tinting of light scattering through the plastic material"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| float reflection_roughness = 0.0 | |
| [[ | |
| ::anno::display_name("Roughness"), | |
| ::anno::description("The roughness of the reflection on the plastic"), | |
| ::anno::in_group("Appearance"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]], | |
| float distance_scale = 0.005 | |
| [[ | |
| ::anno::display_name("Distance Scale"), | |
| ::anno::description("Scales how quickly light is absorbed. Set this value low enough to see " | |
| "some light extinction taking place. Tip: Set 'diffuse_weight' to 0.0 while adjusting this " | |
| "material parameter for your scene"), | |
| ::anno::in_group("Appearance") | |
| ]], | |
| // Flakes Controls | |
| color flake_color_1 = color(1.0f, 1.0f, 1.0f) | |
| [[ | |
| ::anno::display_name("Flakes Color"), | |
| ::anno::description("Flakes Color"), | |
| ::anno::in_group("Flakes") | |
| ]], | |
| bool enable_color_randomization = true | |
| [[ | |
| ::anno::display_name("Flakes Color Randomization"), | |
| ::anno::description("Enables that a random flakes color will be chosen. Using 'Flakes Color Randomness' allows " | |
| "to blend between the chosen reflection color for the flakes and an purely random chosen color."), | |
| ::anno::in_group("Flakes") | |
| ]], | |
| float flake_color_randomness = 1.0 | |
| [[ | |
| ::anno::display_name("Flakes Color Randomness"), | |
| ::anno::description("Incresing this value will blend towards a randomly chosen flakes color."), | |
| ::anno::in_group("Flakes"), | |
| ::anno::hard_range(0.f, 1.f), | |
| ::anno::enable_if("enable_color_randomization == true") | |
| ]], | |
| uniform float flake_size = 0.1f | |
| [[ | |
| ::anno::display_name("Flakes Size"), | |
| ::anno::description("The size of the flakes in the material"), | |
| ::anno::in_group("Flakes") | |
| ]], | |
| uniform float3 texture_scale = float3 ( 1.f , 1.f, 1.f) | |
| [[ | |
| //::anno::hidden(), | |
| ::anno::display_name("Scale"), | |
| ::anno::description("Larger numbers increase the texture size."), | |
| ::nvidia::core_definitions::dimension(float3(1.0f, 1.0f, 1.0f)), | |
| ::anno::in_group("Transform") | |
| ]], | |
| uniform float flake_amount = 0.1f | |
| [[ | |
| ::anno::display_name("Flakes Amount"), | |
| ::anno::description("The number of flakes used in the material, 0 meaning no flakes, 1 meaning that flakes cover the entire surface"), | |
| ::anno::in_group("Flakes"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]], | |
| float flake_spread = 0.7f | |
| [[ | |
| ::anno::display_name("Flakes Spread"), | |
| ::anno::description("The amount of randomness in the orientation of the flakes. When set to zero, flakes are oriented along the surface normal. Higher values tilt the flakes stronger in a random direction."), | |
| ::anno::in_group("Flakes"), | |
| ::anno::hard_range(0.f, 1.f) | |
| ]] | |
| ) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Plastic"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.metallic_plastic_simple_controls.png"), | |
| ::anno::copyright_notice(COPYRIGHT), | |
| ::anno::hidden() | |
| ]] = Plastic_Thick_Translucent_Flakes( | |
| absorption: ::math::pow(transmissive_color, 0.2), | |
| scattering: color(0.5), | |
| distance_scale: distance_scale, | |
| diffuse_transmission_tint: ::math::pow(transmissive_color, 0.2), | |
| diffuse_color: diffuse_color, | |
| diffuse_weight: diffuse_weight, | |
| reflection_roughness: reflection_roughness, | |
| flake_color_1: flake_color_1, | |
| enable_color_randomization: enable_color_randomization, | |
| flake_color_randomness: flake_color_randomness, | |
| flake_size: flake_size, | |
| texture_scale: texture_scale, | |
| flake_amount: flake_amount, | |
| flake_spread: flake_spread | |
| ); | |
| // 01 - Black | |
| export material plastic_black(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Black"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "dark", "black", "neutral")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_black.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.034230), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.034230), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 02 - Dark Gray | |
| export material plastic_dark_gray(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Dark Gray"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "dark", "gray", "neutral")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_dark_gray.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.127530), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.089194), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 03 - Light Gray | |
| export material plastic_light_gray(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Light Gray"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "light", "gray", "neutral")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_light_gray.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.464741), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.358654), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 04 - White | |
| export material plastic_white(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic White"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "light", "white", "neutral")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_white.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.915750), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.812241), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 05 - Ivory White | |
| export material plastic_ivory_white(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Ivory White"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "white", "bright", "ivory", "warm")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_ivory_white.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.899385, 0.843370, 0.694081), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.722672, 0.708298, 0.547994), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 06 - Lemon | |
| export material plastic_lemon(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Lemon"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "lemon", "yellow", "light", "warm")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_lemon.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.859174, 0.875138, 0.039947), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.98211, 0.843370, 0.031551), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 07 - Yellow Orange | |
| export material plastic_yellow_orange(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Yellow"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "light", "orange", "yellow", "warm")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_yellow_orange.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.875138, 0.612066, 0.039947), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.899385, 0.373615, 0.030257), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 08 - Orange | |
| export material plastic_orange(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Orange"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "orange", "warm")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_orange.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.875138, 0.353741, 0.030257), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.891262, 0.420508, 0.022013), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 09 - Dark Orange | |
| export material plastic_dark_orange(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Dark Orange"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "dark", "orange", "warm")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_dark_orange.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.535642, 0.127530, 0.022013), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.827726, 0.267358, 0.022013), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 10 - Red | |
| export material plastic_red(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Red"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "red", "cherry", "warm")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_red.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.547994, 0.027755, 0.027755), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.875138, 0.022013, 0.022013), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 11 - Magenta | |
| export material plastic_magenta(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Magenta"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "magenta")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_magenta.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.547994, 0.047776, 0.554227), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.722672, 0.030257, 0.566810), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 12 - Purple | |
| export material plastic_purple(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Purple"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "purple")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_purple.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.193972, 0.017936, 0.464741), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.701170, 0.018913, 0.645555), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 13 - Dark Blue | |
| export material plastic_dark_blue(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Dark Blue"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "dark", "blue", "cool")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_dark_blue.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.027755, 0.058187, 0.311180), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.027755, 0.058187, 0.311180), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 14 - Blue | |
| export material plastic_blue(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Blue"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "blue", "cool")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_blue.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.034230, 0.173439, 0.843370), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.034230, 0.124741, 0.659224), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 15 - Sky Blue | |
| export material plastic_sky_blue(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Sky Blue"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "blue", "sky", "cool")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_sky_blue.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.061907, 0.535642, 0.875138), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.028991, 0.358654, 0.673049), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 16 - Light Blue | |
| export material plastic_light_blue(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Light Blue"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "light", "blue", "cool")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_light_blue.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.263175, 0.774227, 0.827726), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.163641, 0.592438, 0.759300), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 17 - Teal | |
| export material plastic_teal(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Teal"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "teal", "cool")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_teal.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.037029, 0.579547, 0.329729), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.022013, 0.476177, 0.353741), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 18 - Dark Green | |
| export material plastic_dark_green(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Dark Green"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "dark", "green")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_dark_green.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.034230, 0.141980, 0.034230), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.016988, 0.141980, 0.016988), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 19 - Green | |
| export material plastic_green(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Green"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "green")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_green.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.016988, 0.311180, 0.016988), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.012664, 0.358654, 0.012664), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 20 - Light Green | |
| export material plastic_light_green(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Light Green"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "light", "green")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_light_green.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.030257, 0.687031, 0.027755), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.030257, 0.701170, 0.027755), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); | |
| // 21 - Lime Green | |
| export material plastic_lime_green(*) | |
| [[ | |
| ::anno::author("NVIDIA ARC"), | |
| ::anno::display_name("Metallic Plastic Lime Green"), | |
| ::anno::description(DESCRIPTION), | |
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "lime", "green", "light")), | |
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_lime_green.png"), | |
| ::anno::copyright_notice(COPYRIGHT) | |
| ]] = metallic_plastic_simple_controls( | |
| diffuse_color: color(0.186989, 0.605484, 0.027755), | |
| diffuse_weight: .5, | |
| transmissive_color: color(0.204710, 0.701170, 0.022013), | |
| distance_scale: 0.002, | |
| reflection_roughness: 0.05 | |
| ); |