| /******************************************************************************
|
| * 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
|
| );
|
|
|
|
|
| // 22
|
| export material plastic_gray_63666A(*)
|
| [[
|
| ::anno::author("NVIDIA ARC"),
|
| ::anno::display_name("Plastic Gray 63666A"),
|
| ::anno::description(DESCRIPTION),
|
| ::anno::key_words(string[]("plastic", "artificial", "scattering", "SSS", "diffuse", "translucent", "new", "shiny", "flakes", "metallic", "glitter", "pigment", "lime", "gray", "light")),
|
| ::anno::thumbnail("./.thumbs/Plastic_Thick_Translucent_Flakes.plastic_light_gray.png"),
|
| ::anno::copyright_notice(COPYRIGHT)
|
| ]] = metallic_plastic_simple_controls(
|
| diffuse_color: color(0.1255, 0.1295, 0.1333),
|
| diffuse_weight: .99,
|
| transmissive_color: color(0.1255, 0.1295, 0.1333),
|
| distance_scale: 0.002,
|
| reflection_roughness: 0.05
|
| ); |
