944 lines
25 KiB
Plaintext
944 lines
25 KiB
Plaintext
// Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
|
|
//
|
|
// NVIDIA CORPORATION and its licensors retain all intellectual property
|
|
// and proprietary rights in and to this software, related documentation
|
|
// and any modifications thereto. Any use, reproduction, disclosure or
|
|
// distribution of this software and related documentation without an express
|
|
// license agreement from NVIDIA CORPORATION is strictly prohibited.
|
|
|
|
mdl 1.6;
|
|
|
|
import ::anno::*;
|
|
import ::base::*;
|
|
import ::math::*;
|
|
import ::state::*;
|
|
import ::tex::*;
|
|
|
|
export using ::base import texture_return;
|
|
|
|
// Returns the normal n in tangent space, given n is in internal space.
|
|
float3 transform_internal_to_tangent(float3 n)
|
|
{
|
|
return
|
|
n.x * float3(state::texture_tangent_u(0).x, state::texture_tangent_v(0).x, state::normal().x) +
|
|
n.y * float3(state::texture_tangent_u(0).y, state::texture_tangent_v(0).y, state::normal().y) +
|
|
n.z * float3(state::texture_tangent_u(0).z, state::texture_tangent_v(0).z, state::normal().z);
|
|
}
|
|
|
|
// 3dsmax Bitmap Transformation Matrix
|
|
uniform float4x4 max_rotation_translation_scale
|
|
(
|
|
uniform float3 rotation = float3(0.)
|
|
[[ anno::description("Rotation applied to every UVW coordinate") ]],
|
|
uniform float3 translation = float3(0.)
|
|
[[ anno::description("Offset applied to every UVW coordinate") ]],
|
|
uniform float3 scaling = float3(1.)
|
|
[[ anno::description("Scale applied to every UVW coordinate") ]],
|
|
uniform bool u_mirror = false
|
|
[[ anno::description("Mirror repeat has twice the number of textures in the same space") ]],
|
|
uniform bool v_mirror = false
|
|
[[ anno::description("Mirror repeat has twice the number of textures in the same space") ]]
|
|
)
|
|
[[
|
|
anno::description("Construct transformation matrix from Euler rotation, translation and scale")
|
|
]]
|
|
{
|
|
float4x4 scale =
|
|
float4x4(u_mirror?scaling.x*2.:scaling.x , 0. , 0. , 0.,
|
|
0. , v_mirror?scaling.y*2.:scaling.y , 0. , 0.,
|
|
0. , 0. , scaling.z , 0.,
|
|
u_mirror?1.:.5 , v_mirror?1.:.5 , .5 , 1.);
|
|
|
|
float4x4 translate =
|
|
float4x4(1. , 0. , 0. , 0.,
|
|
0. , 1. , 0. , 0.,
|
|
0. , 0. , 1. , 0.,
|
|
-0.5-translation.x, -0.5-translation.y, -0.5-translation.z, 1.);
|
|
|
|
|
|
// Euler rotation matrix xyz order
|
|
float3 s = math::sin(rotation);
|
|
float3 c = math::cos(rotation);
|
|
float4x4 rotate =
|
|
float4x4( c.y*c.z , c.y*s.z , -s.y , 0.0,
|
|
-c.x*s.z + s.x*s.y*c.z, c.x*c.z + s.x*s.y*s.z , s.x*c.y , 0.0,
|
|
s.x*s.z + c.x*s.y*c.z , -s.x*c.z + c.x*s.y*s.z, c.x*c.y , 0.0,
|
|
0. , 0. , 0. , 1.);
|
|
return scale *rotate*translate;
|
|
}
|
|
|
|
export enum vray_color_mode
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
mode_color,
|
|
mode_temperature
|
|
};
|
|
|
|
export enum vray_color_primaries
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
primaries_none,
|
|
primaries_sRGB,
|
|
primaries_ACEScg
|
|
};
|
|
|
|
export enum vray_bitmap_primaries
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
bm_primaries_default,
|
|
bm_primaries_sRGB,
|
|
bm_primaries_ACEScg,
|
|
bm_primaries_raw
|
|
};
|
|
|
|
export enum vray_rgb_output
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
rgb_output_rgb_color,
|
|
rgb_output_alpha_as_grey,
|
|
rgb_output_intensity_as_grey
|
|
};
|
|
|
|
export enum vray_mono_output
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
mono_output_rgb_intensity,
|
|
mono_output_alpha
|
|
};
|
|
|
|
export enum vray_alpha_source
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
alpha_source_image_alpha,
|
|
alpha_source_intensity,
|
|
alpha_source_opaque
|
|
};
|
|
|
|
// VRayBitmap map
|
|
export texture_return VRayBitmap
|
|
(
|
|
// UVW Coordinates
|
|
uniform int mapChannel=1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map channel")
|
|
]],
|
|
uniform float U_Offset = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Offset")
|
|
]],
|
|
uniform float V_Offset = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Offset")
|
|
]],
|
|
uniform float U_Tiling = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Tiling")
|
|
]],
|
|
uniform float V_Tiling = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Tiling")
|
|
]],
|
|
uniform bool U_Tile=true //it is actually an error if both mirror and tile are true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Tile")
|
|
]],
|
|
uniform bool U_Mirror=false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Mirror")
|
|
]],
|
|
uniform bool V_Tile=true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Tile")
|
|
]],
|
|
uniform bool V_Mirror=false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Mirror")
|
|
]],
|
|
uniform float U_angle = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Angle")
|
|
]],
|
|
uniform float V_angle = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Angle")
|
|
]],
|
|
uniform float W_angle = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("W Angle")
|
|
]],
|
|
uniform int UVW_Type = 0 //enum?
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("UVW Type"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
|
|
// Bitmap
|
|
uniform texture_2d filename = texture_2d()
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bitmap")
|
|
]],
|
|
uniform float multiplier = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Overall multiplier")
|
|
]],
|
|
uniform vray_rgb_output rgb_output = rgb_output_rgb_color
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("RGB output")
|
|
]],
|
|
uniform vray_mono_output mono_output = mono_output_rgb_intensity
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Mono output")
|
|
]],
|
|
uniform vray_alpha_source alpha_source = alpha_source_image_alpha
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Alpha source")
|
|
]],
|
|
uniform vray_bitmap_primaries rgb_primaries = bm_primaries_raw
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("RGB primaries"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool crop_enable = false
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Crop")
|
|
]],
|
|
uniform float crop_u = 0.f //u+w and v+h are always <=1.0
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("U Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float crop_w = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("W Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float crop_v = 0.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("V Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float crop_h = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("H Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
|
|
// Output
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Bump amount"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool clamp = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Clamp"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool invert = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Invert")
|
|
]],
|
|
uniform bool alphaFromRGB = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Alpha from RGB intensity"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Output amount")
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB level")
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Offset")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
uniform float clip_u = crop_enable ? crop_u : 0.f;
|
|
uniform float clip_w = crop_enable ? crop_w : 1.f;
|
|
uniform float clip_v = crop_enable ? crop_v : 0.f;
|
|
uniform float clip_h = crop_enable ? crop_h : 1.f;
|
|
|
|
texture_return bitmap_sample = base::file_texture
|
|
(
|
|
texture : filename,
|
|
mono_source : (alpha_source == alpha_source_image_alpha) ? base::mono_alpha : base::mono_average,
|
|
crop_u : float2(clip_u, clip_w + clip_u),
|
|
crop_v : float2(1.f - clip_v - clip_h, 1.f - clip_v),
|
|
uvw : base::transform_coordinate
|
|
(
|
|
transform : max_rotation_translation_scale
|
|
(
|
|
scaling : float3(U_Tiling, V_Tiling, 1.f),
|
|
rotation : float3(U_angle, V_angle, W_angle)/180.f*math::PI ,
|
|
translation : float3(U_Offset, V_Offset, 0.f), u_mirror : U_Mirror, v_mirror : V_Mirror
|
|
),
|
|
coordinate : base::coordinate_source(texture_space: mapChannel-1)
|
|
),
|
|
wrap_u : U_Tile ? tex::wrap_repeat : U_Mirror ? tex::wrap_mirrored_repeat : tex::wrap_clip,
|
|
wrap_v : V_Tile ? tex::wrap_repeat : V_Mirror ? tex::wrap_mirrored_repeat : tex::wrap_clip
|
|
);
|
|
|
|
bitmap_sample.tint = invert ?
|
|
bitmap_sample.tint * (-rgb_level * output_amount * multiplier ) + (1.f - rgb_offset) :
|
|
bitmap_sample.tint * (rgb_level * output_amount * multiplier) + rgb_offset;
|
|
|
|
float alpha = (alpha_source != alpha_source_opaque) ? bitmap_sample.mono : 1.f;
|
|
bitmap_sample.tint = bitmap_sample.tint*alpha;
|
|
|
|
// determinate mono output
|
|
if(mono_output == mono_output_alpha)
|
|
bitmap_sample.mono = alpha;
|
|
else
|
|
bitmap_sample.mono = math::average(bitmap_sample.tint);
|
|
|
|
// determinate rgb output
|
|
if(rgb_output == rgb_output_alpha_as_grey)
|
|
bitmap_sample.tint = color(alpha);
|
|
else if(rgb_output == rgb_output_intensity_as_grey)
|
|
bitmap_sample.tint = color(math::average(bitmap_sample.tint));
|
|
|
|
return bitmap_sample;
|
|
}
|
|
// VRayBitmap Map for Bump
|
|
export float3 VRayBitmap_bump
|
|
(
|
|
// UVW Coordinates
|
|
uniform int mapChannel=1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map channel")
|
|
]],
|
|
uniform bool U_Tile=true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Tile")
|
|
]],
|
|
uniform bool U_Mirror=false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Mirror")
|
|
]],
|
|
uniform bool V_Tile=true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Tile")
|
|
]],
|
|
uniform bool V_Mirror=false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Mirror")
|
|
]],
|
|
uniform float U_angle = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Angle")
|
|
]],
|
|
uniform float V_angle = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Angle")
|
|
]],
|
|
uniform float W_angle = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("W Angle")
|
|
]],
|
|
uniform float U_Offset = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Offset")
|
|
]],
|
|
uniform float V_Offset = 0.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Offset")
|
|
]],
|
|
uniform float U_Tiling = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Tiling")
|
|
]],
|
|
uniform float V_Tiling = 1.
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Tiling")
|
|
]],
|
|
uniform int UVW_Type = 0 //enum?
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("UVW Type"),
|
|
anno::unused()
|
|
]],
|
|
|
|
// Bitmap
|
|
uniform texture_2d filename = texture_2d()
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bitmap")
|
|
]],
|
|
uniform bool crop_enable = false
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Crop")
|
|
]],
|
|
uniform float crop_u = 0.f //u+w and v+h are always <=1.0
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("U Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float crop_w = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("W Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float crop_v = 0.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("V Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float crop_h = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("H Crop"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bump amount")
|
|
]],
|
|
|
|
// Output
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Bump output")
|
|
]],
|
|
uniform bool clamp = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Clamp"),
|
|
anno::unused()
|
|
]],
|
|
uniform bool invert = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Invert")
|
|
]],
|
|
uniform bool alphaFromRGB = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Alpha from RGB intensity"),
|
|
anno::unused()
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Output amount"),
|
|
anno::unused()
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB level"),
|
|
anno::unused()
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Offset"),
|
|
anno::unused()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
uniform float clip_u = crop_enable ? crop_u : 0.f;
|
|
uniform float clip_w = crop_enable ? crop_w : 1.f;
|
|
uniform float clip_v = crop_enable ? crop_v : 0.f;
|
|
uniform float clip_h = crop_enable ? crop_h : 1.f;
|
|
|
|
return base::file_bump_texture
|
|
(
|
|
texture : filename,
|
|
crop_u : float2(clip_u, clip_w + clip_u),
|
|
crop_v : float2(1.f - clip_v - clip_h, 1.f - clip_v),
|
|
uvw : base::transform_coordinate
|
|
(
|
|
transform : max_rotation_translation_scale
|
|
(
|
|
scaling : float3(U_Tiling, V_Tiling, 1.f),
|
|
rotation : float3(U_angle, V_angle,W_angle)/(180.*math::PI),
|
|
translation : float3(U_Offset, V_Offset, 0.f), u_mirror : U_Mirror, v_mirror : V_Mirror
|
|
),
|
|
coordinate : base::coordinate_source(texture_space: mapChannel - 1)
|
|
),
|
|
wrap_u : U_Tile ? tex::wrap_repeat : U_Mirror ? tex::wrap_mirrored_repeat : tex::wrap_clip,
|
|
wrap_v : V_Tile ? tex::wrap_repeat : V_Mirror ? tex::wrap_mirrored_repeat : tex::wrap_clip,
|
|
factor : invert ? -10.f*factor*bump_amount : 10.f*factor*bump_amount
|
|
);
|
|
}
|
|
|
|
// VRayBump2Normal Map for Bump
|
|
export enum vray_bump2normal_mode
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
b2n_tangent_space,
|
|
b2n_local_XYZ,
|
|
b2n_screen_space,
|
|
b2n_world_space
|
|
};
|
|
|
|
export texture_return VRayBump2Normal
|
|
(
|
|
float3 bump_map = state::normal()
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Bump map")
|
|
]],
|
|
uniform float bump_map_mult = 100.f
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Bump map multiplier"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
uniform vray_bump2normal_mode mode = b2n_tangent_space
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Mode"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform int map_channel=1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map channel"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
texture_return normal_tex;
|
|
|
|
float3 normal_tangent_space =
|
|
transform_internal_to_tangent(math::normalize(state::normal() + (bump_map - state::normal())*(bump_map_mult*0.01f)));
|
|
|
|
normal_tex.tint = color( (normal_tangent_space + float3(1.f))*0.5f );
|
|
normal_tex.mono = 1.f;
|
|
return normal_tex;
|
|
}
|
|
|
|
// VRayColor Map
|
|
export texture_return VRayColor
|
|
(
|
|
uniform vray_color_mode color_mode = mode_color
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Color mode")
|
|
]],
|
|
uniform float temperature = 6500.f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Temperature"),
|
|
anno::hard_range(350.f, 1000000000.f)
|
|
]],
|
|
uniform float red = 0.5f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Red"),
|
|
anno::soft_range(0.f, 1.f)
|
|
]],
|
|
uniform float green = 0.5f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Green"),
|
|
anno::soft_range(0.f, 1.f)
|
|
]],
|
|
uniform float blue = 0.5f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Blue"),
|
|
anno::soft_range(0.f, 1.f)
|
|
]],
|
|
uniform float rgb_multiplier = 1.f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("RGB Multiplier")
|
|
]],
|
|
uniform float alpha = 1.f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Alpha"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float color_gamma = 1.0f
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("Color gamma"),
|
|
anno::hard_range(0.05f, 20.f)
|
|
]],
|
|
uniform vray_color_primaries rgb_primaries = primaries_none
|
|
[[
|
|
anno::in_group("VRayColor Parameters"),
|
|
anno::display_name("RGB primaries"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 rgb(red, green, blue);
|
|
|
|
// using temperature?. Then convert from Kelvin to RGB
|
|
if(color_mode == mode_temperature)
|
|
{
|
|
float k = temperature*0.01f;
|
|
|
|
// red
|
|
if (temperature < 6600.f)
|
|
{
|
|
rgb.x = 1.f;
|
|
}
|
|
else
|
|
{
|
|
float r = k - 55.f;
|
|
r = (351.9769f + 0.1142f * r - 40.2537f * math::log(r))/255.f;
|
|
rgb.x = math::clamp(r, 0.f, 1.f);
|
|
}
|
|
|
|
// green
|
|
if (temperature < 6600.f)
|
|
{
|
|
float g = k - 2.f;
|
|
g = (-155.2549f - 0.4460f * g + 104.4922f * math::log(g))/255.f;
|
|
rgb.y = math::clamp(g, 0.f, 1.f);
|
|
|
|
}
|
|
else
|
|
{
|
|
float g = k - 50.f;
|
|
g = (325.4494f + 0.0794f * g - 28.0853f * math::log(g))/255.f;
|
|
rgb.y = math::clamp(g, 0.f, 1.f);
|
|
}
|
|
|
|
// blue
|
|
if (temperature >= 6600.f)
|
|
{
|
|
rgb.z = 1.f;
|
|
}
|
|
else if (temperature <= 2000.f)
|
|
{
|
|
rgb.z = 0.f;
|
|
}
|
|
else
|
|
{
|
|
float b = k - 10.f;
|
|
b = (-254.7694f + 0.8274f * blue + 115.6799f * math::log(b))/255.f;
|
|
rgb.z = math::clamp(b, 0.f, 1.f);
|
|
}
|
|
}
|
|
|
|
// apply gamma
|
|
if(color_gamma != 1.f)
|
|
rgb = math::pow(rgb, 1.f/color_gamma);
|
|
|
|
// apply multiplier
|
|
rgb *= rgb_multiplier;
|
|
|
|
// fix ranges and return
|
|
rgb = math::clamp(rgb, 0.f, 1.f);
|
|
return texture_return(color(rgb), alpha);
|
|
}
|
|
|
|
// VRayColor Map for Bump
|
|
export float3 VRayColor_bump
|
|
(
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return state::normal();
|
|
}
|
|
|
|
// VRayColor2Bump Map for Bump
|
|
export float3 VRayColor2Bump_bump
|
|
(
|
|
float3 map = state::normal()
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Bump map")
|
|
]],
|
|
uniform float height = 2.0f
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Height"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float bump_delta_scale = 1.0f
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Bump delta scale"),
|
|
anno::unused(),
|
|
anno::hidden(),
|
|
anno::hard_range(0.f, 1.f)
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return map;
|
|
}
|
|
|
|
// VRay Dirt Map
|
|
export texture_return VRayDirt
|
|
(
|
|
float radius = 10.f
|
|
[[
|
|
anno::in_group("VRayDirt Parameters"),
|
|
anno::display_name("Radius"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
color occluded_color = color(0.f)
|
|
[[
|
|
anno::in_group("VRayDirt Parameters"),
|
|
anno::display_name("Occluded color"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
color unoccluded_color = color(1.f)
|
|
[[
|
|
anno::in_group("VRayDirt Parameters"),
|
|
anno::display_name("Unoccluded color")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return texture_return(unoccluded_color, 1.f);
|
|
}
|
|
|
|
// VRay Edges Tex Map
|
|
export texture_return VRayEdgesTex
|
|
(
|
|
color edges_color = color(1.f)
|
|
[[
|
|
anno::in_group("VRayEdgesTex params"),
|
|
anno::display_name("Color")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return texture_return(edges_color, 1.f);
|
|
}
|
|
|
|
// VRay Edges Tex Map for bump
|
|
export float3 VRayEdgesTex_bump
|
|
(
|
|
color edges_color = color(1.f)
|
|
[[
|
|
anno::in_group("VRayEdgesTex params"),
|
|
anno::display_name("Color"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float radius = 0.1f
|
|
[[
|
|
anno::in_group("VRayEdgesTex params"),
|
|
anno::display_name("Radius"),
|
|
anno::hard_range(0.f, 100.f)
|
|
|
|
]],
|
|
uniform bool same_object_only = true
|
|
[[
|
|
anno::in_group("VRayEdgesTex params"),
|
|
anno::display_name("Consider same object only")
|
|
]],
|
|
uniform int corners_mode = 0
|
|
[[
|
|
anno::in_group("VRayEdgesTex params"),
|
|
anno::display_name("Corners"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float multiplier = 1.f
|
|
[[
|
|
anno::in_group("VRayEdgesTex params"),
|
|
anno::display_name("Multiplier"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return state::rounded_corner_normal(radius*state::meters_per_scene_unit(), !same_object_only);
|
|
}
|
|
|
|
// VRay Normap Map for bump
|
|
export float3 VRayNormalMap_bump
|
|
(
|
|
texture_return normal_map = texture_return()
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Normal map")
|
|
]],
|
|
float3 bump_map = state::normal()
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Bump map")
|
|
]],
|
|
uniform float normal_amount = 1.f
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Normal amount"),
|
|
anno::hard_range(-1000.f, 1000.f)
|
|
]],
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Bump amount"),
|
|
anno::hard_range(-1000.f, 1000.f)
|
|
]],
|
|
uniform bool flip_red = false
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Flip red")
|
|
]],
|
|
uniform bool flip_green = false
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Flip green")
|
|
]],
|
|
uniform bool swap_rg = false
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Swap red and green")
|
|
]],
|
|
uniform int map_channel = 1
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Map channel"),
|
|
anno::hidden(),
|
|
anno::unused()
|
|
]],
|
|
uniform float map_rotation = 0.f
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Map rotation"),
|
|
anno::hard_range(0.f, 360.f),
|
|
anno::hidden(),
|
|
anno::unused()
|
|
]],
|
|
uniform float normal_map_amount = 1.0f
|
|
[[
|
|
anno::in_group("VRayNormalMap Parameters"),
|
|
anno::display_name("Map amount"),
|
|
anno::hard_range(-10.f, 10.f)
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 tangent_space_normal = float3(normal_map.tint);
|
|
|
|
if(flip_red)
|
|
tangent_space_normal.x = 1.f - tangent_space_normal.x;
|
|
|
|
if(flip_green)
|
|
tangent_space_normal.y = 1.f - tangent_space_normal.y;
|
|
|
|
if(swap_rg)
|
|
{
|
|
float tmp = tangent_space_normal.x;
|
|
tangent_space_normal.x = tangent_space_normal.y;
|
|
tangent_space_normal.y = tmp;
|
|
}
|
|
|
|
float normal_factor = normal_amount*(normal_map_amount);
|
|
tangent_space_normal = (tangent_space_normal - float3(0.5f))*(2.f*normal_factor);
|
|
|
|
float3 mapped_normal = math::normalize(
|
|
state::texture_tangent_u(0) * tangent_space_normal.x +
|
|
state::texture_tangent_v(0) * tangent_space_normal.y +
|
|
state::normal() * (tangent_space_normal.z + (1.f - normal_factor)));
|
|
|
|
float3 bumped_normal = math::normalize(math::lerp(state::normal(), bump_map, bump_amount*normal_map_amount));
|
|
|
|
return math::normalize(mapped_normal + bumped_normal);
|
|
}
|