2894 lines
80 KiB
Plaintext
2894 lines
80 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 color_layer_mode;
|
|
export using ::base import texture_return;
|
|
|
|
// Helper functions
|
|
// 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);
|
|
}
|
|
|
|
// Returns the normal n in internal space, given n is in tangent space.
|
|
float3 transform_tangent_to_internal(float3 n)
|
|
{
|
|
return state::texture_tangent_u(0) * n.x +
|
|
state::texture_tangent_v(0) * n.y +
|
|
state::normal() * n.z ;
|
|
}
|
|
|
|
// Returns a normal as a weighted combination of two normals.
|
|
export float3 combine_normals(
|
|
float w1 = 1.f, float3 n1 = state::normal(),
|
|
float w2 = 1.f, float3 n2 = state::normal())
|
|
{
|
|
// http://blog.selfshadow.com/publications/blending-in-detail/
|
|
float3 n1_t = transform_internal_to_tangent(n1);
|
|
float3 n2_t = transform_internal_to_tangent(n2);
|
|
|
|
n1_t = math::lerp(float3(0.f, 0.f, 1.f), n1_t, w1);
|
|
n2_t = math::lerp(float3(0.f, 0.f, 1.f), n2_t, w2);
|
|
|
|
n1_t = n1_t + float3(0.f, 0.f, 1.f);
|
|
n2_t = n2_t * float3(-1.f, -1.f, 1.f);
|
|
|
|
float3 n = n1_t*math::dot(n1_t, n2_t)/n1_t.z - n2_t;
|
|
|
|
// alternative way of combining the 2 normals
|
|
// float3 n = float3(n1_t.x + n2_t.x,n1_t.y + n2_t.y, n1_t.z*n2_t.z);
|
|
|
|
return math::normalize(transform_tangent_to_internal(n));
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
// 3dsmax Mono Output
|
|
export enum ad_3dsmax_mono_output
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
mono_output_rgb_intensity,
|
|
mono_output_alpha
|
|
};
|
|
|
|
// 3dsmax RGB Output
|
|
export enum ad_3dsmax_rgb_output
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
rgb_output_rgb,
|
|
rgb_output_alpha
|
|
};
|
|
|
|
// 3dsmax Alpha Source
|
|
export enum ad_3dsmax_alpha_source
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
alpha_source_alpha,
|
|
alpha_source_rgb_intensity,
|
|
alpha_source_none
|
|
};
|
|
|
|
// 3dsmax Bitmap map
|
|
export texture_return ad_3dsmax_bitmap
|
|
(
|
|
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()
|
|
]],
|
|
uniform texture_2d filename = texture_2d()
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bitmap")
|
|
]],
|
|
uniform float clipu = 0.f //u+w and v+h are always <=1.0
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("U Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float clipw = 1.0
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("W Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float clipv = 0.0
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("V Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float cliph = 1.0
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("H Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform ad_3dsmax_mono_output mono_output = mono_output_rgb_intensity
|
|
[[
|
|
anno::in_group("Mono Output"),
|
|
anno::display_name("Mono Output")
|
|
]],
|
|
uniform ad_3dsmax_rgb_output rgb_output = rgb_output_rgb
|
|
[[
|
|
anno::in_group("RGB Output"),
|
|
anno::display_name("RGB Output")
|
|
]],
|
|
uniform ad_3dsmax_alpha_source alpha_source = alpha_source_none
|
|
[[
|
|
anno::in_group("Alpha Source"),
|
|
anno::display_name("Alpha Source")
|
|
]],
|
|
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")
|
|
]]
|
|
{
|
|
texture_return result = base::file_texture
|
|
(
|
|
texture: filename,
|
|
mono_source: (alpha_source == alpha_source_alpha) ? base::mono_alpha : base::mono_average,
|
|
crop_u: float2(clipu, clipw+clipu),
|
|
crop_v: float2(1.-clipv-cliph, 1.-clipv),
|
|
uvw: base::transform_coordinate(
|
|
transform: max_rotation_translation_scale(
|
|
scaling: float3(U_Tiling,V_Tiling,1.0),
|
|
rotation: float3(U_angle,V_angle,W_angle)/180.*math::PI,
|
|
translation: float3(U_Offset,V_Offset,0.0),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
|
|
);
|
|
|
|
result.tint = invert ? result.tint * (-rgb_level * output_amount ) + (1.f - rgb_offset) : result.tint * (rgb_level * output_amount ) + rgb_offset;
|
|
|
|
float alpha = (alpha_source != alpha_source_none) ? result.mono : 1.f;
|
|
result.tint = result.tint*alpha;
|
|
|
|
// determinate mono output
|
|
if(mono_output == mono_output_alpha)
|
|
result.mono = alpha;
|
|
else
|
|
result.mono = math::average(result.tint);
|
|
|
|
// determinate rgb output
|
|
if(rgb_output == rgb_output_alpha)
|
|
result.tint = color(alpha);
|
|
|
|
return result;
|
|
}
|
|
// 3dsmax Bitmap Map for Bump
|
|
export float3 ad_3dsmax_bitmap_bump
|
|
(
|
|
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()
|
|
]],
|
|
uniform texture_2d filename = texture_2d()
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bitmap")
|
|
]],
|
|
uniform float clipu = 0.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("U Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float clipw = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("W Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float clipv = 0.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("V Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float cliph = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("H Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bump amount")
|
|
]],
|
|
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")
|
|
]]
|
|
{
|
|
return base::file_bump_texture
|
|
(
|
|
texture : filename,
|
|
crop_u : float2(clipu, clipw + clipu),
|
|
crop_v : float2(1.f - clipv - cliph, 1.f - clipv),
|
|
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,
|
|
factor : invert ? -10.f*factor*bump_amount : 10.f*factor*bump_amount
|
|
);
|
|
}
|
|
|
|
// 3dsmax Bitmap Normal Map
|
|
export float3 ad_3dsmax_bitmap_normalmap
|
|
(
|
|
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.f
|
|
[[
|
|
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()
|
|
]],
|
|
uniform texture_2d filename = texture_2d()
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Bitmap")
|
|
]],
|
|
uniform float clipu = 0.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("U Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float clipw = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("W Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float clipv = 0.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("V Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float cliph = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("H Clip"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Bitmap parameters"),
|
|
anno::display_name("Strength")
|
|
]],
|
|
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.0
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float mult_spin = 1.f
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Normal map mult")
|
|
]],
|
|
uniform bool swap_rg = false
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Swap red & green"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool flipred = false
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Flip red")
|
|
]],
|
|
uniform bool flipgreen = false
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Flip green")
|
|
]],
|
|
|
|
uniform int method = 0
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Method"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float3 bump_map = state::normal()
|
|
[[
|
|
anno::in_group("Parameters"),
|
|
anno::display_name("Bump map"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return base::tangent_space_normal_texture(
|
|
texture: filename,
|
|
crop_u: float2(clipu, clipw + clipu),
|
|
crop_v: float2(1.f - clipv - cliph, 1.f - clipv),
|
|
factor: factor*mult_spin*rgb_level*output_amount,
|
|
flip_tangent_u: invert ? !flipred : flipred,
|
|
flip_tangent_v: invert ? flipgreen : !flipgreen,
|
|
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
|
|
);
|
|
}
|
|
|
|
// 3dsmax Color Correction RGB Channels
|
|
export enum ad_3dsmax_channel
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
channel_red,
|
|
channel_green,
|
|
channel_blue,
|
|
channel_alpha,
|
|
channel_inverse_red,
|
|
channel_inverse_green,
|
|
channel_inverse_blue,
|
|
channel_inverse_alpha,
|
|
channel_mono,
|
|
channel_one,
|
|
channel_zero
|
|
};
|
|
|
|
// 3dsmax Color Correction Lightness Mode
|
|
export enum ad_3dsmax_lightness_mode
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
Standard,
|
|
Advanced
|
|
};
|
|
|
|
// 3dsmax Color Correction Map
|
|
export texture_return ad_3dsmax_color_correction
|
|
(
|
|
texture_return map = texture_return()
|
|
[[
|
|
anno::in_group("Basic parameters"),
|
|
anno::display_name("Color")
|
|
]],
|
|
uniform ad_3dsmax_channel rewireR = channel_red
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Red")
|
|
]],
|
|
uniform ad_3dsmax_channel rewireG = channel_green
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Green")
|
|
]],
|
|
uniform ad_3dsmax_channel rewireB = channel_blue
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Blue")
|
|
]],
|
|
uniform ad_3dsmax_channel rewireA = channel_alpha
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Alpha")
|
|
]],
|
|
uniform float hue_shift = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Hue shift"),
|
|
anno::hard_range(-180.f, 180.f)
|
|
]],
|
|
uniform float saturation = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Saturation"),
|
|
anno::hard_range(-100.f, 100.f)
|
|
]],
|
|
uniform float hue_tint = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Hue tint"),
|
|
anno::hard_range(0.f, 360.f)
|
|
]],
|
|
uniform float hue_tint_amnt = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Strength"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
uniform ad_3dsmax_lightness_mode lightness_mode = Standard
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("Lightness mode")
|
|
]],
|
|
uniform float brightness = 0.f
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("Brightness"),
|
|
anno::hard_range(-100.f, 100.f)
|
|
]],
|
|
uniform float contrast = 0.f
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("Contrast"),
|
|
anno::hard_range(-100.f, 100.f)
|
|
]],
|
|
uniform float rgb_gamma = 1.f
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("RGB gamma"),
|
|
anno::hard_range(0.01f, 10000.f)
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
// channel rewiring
|
|
float3 rgb = float3(map.tint);
|
|
texture_return result = (rewireB == channel_blue) && (rewireG == channel_green) && (rewireR == channel_red) && (rewireA == channel_alpha) ?
|
|
texture_return(color(rgb), map.mono) :
|
|
texture_return(color(
|
|
rewireR == channel_red ? rgb.x :
|
|
rewireR == channel_green ? rgb.y :
|
|
rewireR == channel_blue ? rgb.z :
|
|
rewireR == channel_alpha ? map.mono :
|
|
rewireR == channel_inverse_red ? 1.f - rgb.x :
|
|
rewireR == channel_inverse_green ? 1.f - rgb.y :
|
|
rewireR == channel_inverse_blue ? 1.f - rgb.z :
|
|
rewireR == channel_inverse_alpha ? 1.f - map.mono :
|
|
rewireR == channel_mono ? math::luminance(map.tint) :
|
|
rewireR == channel_one ? 1.f : 0.f,
|
|
rewireG == channel_red ? rgb.x :
|
|
rewireG == channel_green ? rgb.y :
|
|
rewireG == channel_blue ? rgb.z :
|
|
rewireG == channel_alpha ? map.mono :
|
|
rewireG == channel_inverse_red ? 1.f - rgb.x :
|
|
rewireG == channel_inverse_green ? 1.f - rgb.y :
|
|
rewireG == channel_inverse_blue ? 1.f - rgb.z :
|
|
rewireG == channel_inverse_alpha ? 1.f - map.mono :
|
|
rewireG == channel_mono ? math::luminance(map.tint) :
|
|
rewireG == channel_one ? 1.f : 0.f,
|
|
rewireB == channel_red ? rgb.x :
|
|
rewireB == channel_green ? rgb.y :
|
|
rewireB == channel_blue ? rgb.z :
|
|
rewireB == channel_alpha ? map.mono :
|
|
rewireB == channel_inverse_red ? 1.f - rgb.x :
|
|
rewireB == channel_inverse_green ? 1.f - rgb.y :
|
|
rewireB == channel_inverse_blue ? 1.f - rgb.z :
|
|
rewireB == channel_inverse_alpha ? 1.f - map.mono :
|
|
rewireB == channel_mono ? math::luminance(map.tint) :
|
|
rewireB == channel_one ? 1.f : 0.f
|
|
),
|
|
rewireA == channel_red ? rgb.x :
|
|
rewireA == channel_green ? rgb.y :
|
|
rewireA == channel_blue ? rgb.z :
|
|
rewireA == channel_alpha ? map.mono :
|
|
rewireA == channel_inverse_red ? 1.f - rgb.x :
|
|
rewireA == channel_inverse_green ? 1.f - rgb.y :
|
|
rewireA == channel_inverse_blue ? 1.f - rgb.z :
|
|
rewireA == channel_inverse_alpha ? 1.f - map.mono :
|
|
rewireA == channel_mono ? math::luminance(map.tint) :
|
|
rewireA == channel_one ? 1.f : 0.f);
|
|
|
|
rgb = float3(result.tint);
|
|
|
|
// chroma correction
|
|
if(hue_shift != 0.f || saturation != 0.f || hue_tint_amnt != 0.f)
|
|
{
|
|
// RGB to HSV
|
|
float min = math::min_value(rgb);
|
|
float max = math::max_value(rgb);
|
|
float h = 0.f, s = 0.f, v = max;
|
|
float delta = max - min;
|
|
|
|
if(min != max)
|
|
{
|
|
if(max == rgb.x)
|
|
h = math::fmod(((60.f*((rgb.y - rgb.z)/delta)) + 360.f), 360.f);
|
|
else if(max == rgb.y)
|
|
h = math::fmod(((60.f*((rgb.z - rgb.x)/delta)) + 120.f), 360.f);
|
|
else // max == rgb.z
|
|
h = math::fmod(((60.f*((rgb.x - rgb.y)/delta)) + 240.f), 360.f);
|
|
}
|
|
|
|
if(max > 0.f)
|
|
{
|
|
s = delta / max;
|
|
|
|
if(saturation >= 0.f)
|
|
s += saturation*saturation*0.0001f;
|
|
else
|
|
s -= saturation*saturation*0.0001f;
|
|
|
|
if(s < 0.f)
|
|
s = 0.f;
|
|
else if (s > 1.f)
|
|
s = 1.f;
|
|
}
|
|
|
|
// apply cromatic corrections
|
|
h += hue_shift;
|
|
h += (hue_tint - h)*(hue_tint_amnt*0.01f);
|
|
|
|
if(h < 0.f)
|
|
h += 360.f;
|
|
else if(h >= 360.f)
|
|
h -= 360.f;
|
|
|
|
|
|
// HSV to RGB
|
|
float sv = s*v;
|
|
h = math::fmod(h / 60.f, 6.f);
|
|
int idx = int(h);
|
|
float x = sv * (1.f - math::abs(math::fmod(h, 2.f) - 1.f));
|
|
float m = v - sv;
|
|
|
|
float r=0.f, g=0.f, b=0.f;
|
|
|
|
switch(idx)
|
|
{
|
|
case 0:
|
|
r = sv, g = x;
|
|
break;
|
|
case 1:
|
|
r = x, g = sv;
|
|
break;
|
|
case 2:
|
|
g = sv, b = x;
|
|
break;
|
|
case 3:
|
|
g = x, b = sv;
|
|
break;
|
|
case 4:
|
|
r = x, b = sv;
|
|
break;
|
|
case 5:
|
|
r = sv, b = x;
|
|
break;
|
|
}
|
|
|
|
rgb = float3(r+m, g+m, b+m);
|
|
}
|
|
|
|
// lightness correction
|
|
if(lightness_mode == Advanced) // advanced exposure
|
|
{
|
|
if(rgb_gamma != 1.f)
|
|
rgb = math::pow(rgb, 1.f/rgb_gamma);
|
|
}
|
|
else // basic exposure
|
|
{
|
|
if(contrast != 0.f)
|
|
{
|
|
float c = contrast*2.55f;
|
|
float f = (259.f * (c + 255.f))/(255.f * (259.f - c));
|
|
float3 grey(0.5f);
|
|
rgb = math::clamp((rgb - grey)*f + grey, 0.f, 1.f);
|
|
}
|
|
|
|
if(brightness != 0.f)
|
|
{
|
|
rgb = math::clamp(rgb + float3(brightness*0.01), 0.f, 1.f);
|
|
}
|
|
}
|
|
|
|
result.tint = color(rgb);
|
|
return result;
|
|
}
|
|
|
|
// 3dsmax Color Correction Map for Bump
|
|
export float3 ad_3dsmax_color_correction_bump(
|
|
float3 map = state::normal()
|
|
[[
|
|
anno::in_group("Basic parameters"),
|
|
anno::display_name("Bump map")
|
|
]],
|
|
uniform ad_3dsmax_channel rewireR = channel_red
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Red"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_channel rewireG = channel_green
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Green"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_channel rewireB = channel_blue
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Blue"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_channel rewireA = channel_alpha
|
|
[[
|
|
anno::in_group("Channels"),
|
|
anno::display_name("Alpha"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float hue_shift = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Hue shift"),
|
|
anno::hard_range(-180.f, 180.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float saturation = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Saturation"),
|
|
anno::hard_range(-100.f, 100.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float hue_tint = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Hue tint"),
|
|
anno::hard_range(0.f, 360.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float hue_tint_amnt = 0.f
|
|
[[
|
|
anno::in_group("Color"),
|
|
anno::display_name("Strength"),
|
|
anno::hard_range(0.f, 100.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_lightness_mode lightness_mode = Standard
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("Lightness mode"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float brightness = 0.f
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("Brightness"),
|
|
anno::hard_range(-100.f, 100.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
|
|
]],
|
|
uniform float contrast = 0.f
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("Contrast"),
|
|
anno::hard_range(-100.f, 100.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_gamma = 1.f
|
|
[[
|
|
anno::in_group("Lightness"),
|
|
anno::display_name("RGB gamma"),
|
|
anno::hard_range(0.01f, 10000.f),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Bump"),
|
|
anno::display_name("Bump amount"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return math::normalize(math::lerp(state::normal(), map, bump_amount));
|
|
// return combine_normals(bump_amount, map, 1.f - bump_amount, state::normal());
|
|
|
|
// EXPERIMENTAL CODE
|
|
// if(bump_amount <= 0.f)
|
|
// return state::normal();
|
|
|
|
// // normal xyz to spherical
|
|
// float disc = math::sqrt(map.x*map.x + map.y*map.y);
|
|
// float theta = math::atan(disc/map.z);
|
|
// float phi = math::atan2(map.y, map.x);
|
|
|
|
// float t = math::clamp(1.f - theta/math::HALF_PI, 0.f, 1.f); // [0, PI/2] --> [1, 0] mapping
|
|
|
|
|
|
// // lightness corrections
|
|
// if(lightness_mode = Advanced)
|
|
// {
|
|
// if(rgb_gamma != 1.f)
|
|
// t = math::pow(t, 1.f/rgb_gamma);
|
|
// }
|
|
// else // basic exposure
|
|
// {
|
|
// if(contrast != 0.f)
|
|
// {
|
|
// float c = contrast*2.55f;
|
|
// float f = (259.f * (c + 255.f))/(255.f * (259.f - c));
|
|
// t = math::clamp((t - 0.5f)*f + 0.5f, 0.f, 1.f);
|
|
// }
|
|
|
|
// if(brightness != 0.f)
|
|
// {
|
|
// t = math::clamp(t + (brightness*0.01), 0.f, 1.f);
|
|
// }
|
|
// }
|
|
|
|
// theta = (1.f - t)*math::HALF_PI; // [1, 0] --> [0, PI/2] mapping
|
|
|
|
// // normal spherical to xyz
|
|
// float3 bump_normal(math::sin(theta)*math::cos(phi), math::sin(theta)*math::sin(phi), math::cos(theta));
|
|
|
|
// if(bump_amount >= 1.f)
|
|
// return bump_normal;
|
|
// else
|
|
// return combine_normals(bump_amount, bump_normal, 1.f - bump_amount, state::normal());
|
|
}
|
|
|
|
// 3dsmax Composite Layer Mask Mode
|
|
uniform color_layer_mode ad_3dsmax_mapmode(uniform int m)
|
|
{
|
|
return
|
|
m == 0 ? base::color_layer_blend:
|
|
m == 1 ? base::color_layer_average:
|
|
m == 2 ? base::color_layer_add:
|
|
m == 3 ? base::color_layer_add: //but factor is negative to get subtract!!
|
|
m == 4 ? base::color_layer_darken:
|
|
m == 5 ? base::color_layer_multiply:
|
|
m == 6 ? base::color_layer_colorburn:
|
|
m == 7 ? base::color_layer_linearburn:
|
|
m == 8 ? base::color_layer_lighten:
|
|
m == 9 ? base::color_layer_screen:
|
|
m == 10 ? base::color_layer_colordodge:
|
|
m == 11 ? base::color_layer_lineardodge:
|
|
m == 12 ? base::color_layer_spotlight:
|
|
m == 13 ? base::color_layer_spotlightblend:
|
|
m == 14 ? base::color_layer_overlay:
|
|
m == 15 ? base::color_layer_softlight:
|
|
m == 16 ? base::color_layer_hardlight:
|
|
m == 17 ? base::color_layer_pinlight:
|
|
m == 18 ? base::color_layer_hardmix:
|
|
m == 19 ? base::color_layer_difference:
|
|
m == 20 ? base::color_layer_exclusion:
|
|
m == 21 ? base::color_layer_hue:
|
|
m == 22 ? base::color_layer_saturation:
|
|
m == 23 ? base::color_layer_color:
|
|
m == 24 ? base::color_layer_brightness:
|
|
base::color_layer_blend;
|
|
}
|
|
|
|
// 3dsmax Composite Map
|
|
export texture_return ad_3dsmax_composite
|
|
(
|
|
// layer 1
|
|
uniform int blendMode1 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Blend Mode (unused)"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
texture_return map1 = texture_return()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Map")
|
|
]],
|
|
texture_return mask1 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Mask")
|
|
]],
|
|
uniform float opacity1 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
// layer2
|
|
uniform int blendMode2 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Blend Mode")
|
|
]],
|
|
texture_return map2 = texture_return()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Map")
|
|
]],
|
|
texture_return mask2 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Mask")
|
|
]],
|
|
uniform float opacity2 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
// layer3
|
|
uniform int blendMode3 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Blend Mode")
|
|
]],
|
|
texture_return map3 = texture_return()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Map")
|
|
]],
|
|
texture_return mask3 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Mask")
|
|
]],
|
|
uniform float opacity3 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
// Layer4
|
|
uniform int blendMode4 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Blend Mode")
|
|
]],
|
|
texture_return map4 = texture_return()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Map")
|
|
]],
|
|
texture_return mask4 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Mask")
|
|
]],
|
|
uniform float opacity4 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
opacity1 *= map1.mono*mask1.mono*0.01f;
|
|
texture_return t1 = opacity1 > 0.f ?
|
|
base::blend_color_layers
|
|
(
|
|
layers: base::color_layer[]
|
|
(
|
|
base::color_layer
|
|
(
|
|
layer_color: map1.tint,
|
|
weight: opacity1,
|
|
mode: base::color_layer_blend
|
|
)
|
|
),
|
|
base: color(0.f)
|
|
)
|
|
: texture_return(color(0.f), 0.f);
|
|
|
|
opacity2 *= map2.mono*mask2.mono*0.01f;
|
|
texture_return t2 = opacity2 > 0.f ?
|
|
base::blend_color_layers
|
|
(
|
|
layers: base::color_layer[]
|
|
(
|
|
base::color_layer
|
|
(
|
|
layer_color: map2.tint,
|
|
weight: blendMode2 == 3 ? -opacity2 : opacity2,
|
|
mode: ad_3dsmax_mapmode(blendMode2)
|
|
)
|
|
),
|
|
base: t1.tint
|
|
)
|
|
: t1;
|
|
|
|
opacity3 *= map3.mono*mask3.mono*0.01f;
|
|
texture_return t3 = opacity3 > 0.f ?
|
|
base::blend_color_layers
|
|
(
|
|
layers: base::color_layer[]
|
|
(
|
|
base::color_layer
|
|
(
|
|
layer_color: map3.tint,
|
|
weight: blendMode3 == 3 ? -opacity3 : opacity3,
|
|
mode: ad_3dsmax_mapmode(blendMode3)
|
|
)
|
|
),
|
|
base: t2.tint
|
|
)
|
|
: t2;
|
|
|
|
opacity4 *= map4.mono*mask4.mono*0.01f;
|
|
texture_return t4 = opacity4 > 0.f ?
|
|
base::blend_color_layers
|
|
(
|
|
layers: base::color_layer[]
|
|
(
|
|
base::color_layer
|
|
(
|
|
layer_color: map4.tint,
|
|
weight: blendMode4 == 3 ? -opacity4 : opacity4,
|
|
mode: ad_3dsmax_mapmode(blendMode4)
|
|
)
|
|
),
|
|
base: t3.tint
|
|
):
|
|
t3;
|
|
|
|
return t4;
|
|
}
|
|
|
|
// 3dsmax Composite Map for Bump
|
|
export float3 ad_3dsmax_composite_bump
|
|
(
|
|
// Layer1
|
|
uniform int blendMode1 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Blend Mode"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float3 map1 = state::normal()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Bump Map")
|
|
]],
|
|
texture_return mask1 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Mask")
|
|
]],
|
|
uniform float opacity1 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("1: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
// Layer2
|
|
uniform int blendMode2 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Blend Mode"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float3 map2 = state::normal()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Bump Map")
|
|
]],
|
|
texture_return mask2 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Mask")
|
|
]],
|
|
uniform float opacity2 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("2: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
// Layer3
|
|
uniform int blendMode3 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Blend Mode"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float3 map3 = state::normal()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Bump Map")
|
|
]],
|
|
texture_return mask3 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Mask")
|
|
]],
|
|
uniform float opacity3 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("3: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
// Layer4
|
|
uniform int blendMode4 = 0
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Blend Mode"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float3 map4 = state::normal()
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Bump Map")
|
|
]],
|
|
texture_return mask4 = texture_return(color(1.f), 1.f)
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Mask")
|
|
]],
|
|
uniform float opacity4 = 0.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("4: Opacity"),
|
|
anno::hard_range(0.f, 100.f)
|
|
]],
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Composite Layers"),
|
|
anno::display_name("Bump amount")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 n1 = opacity1 > 0.f ?
|
|
combine_normals(1.f - (opacity1/100.f*mask1.mono), state::normal(), opacity1/100.f*factor*mask1.mono, map1)
|
|
: state::normal();
|
|
|
|
float3 n2 = opacity2 > 0.f ?
|
|
combine_normals(1.f - (opacity2/100.f*mask2.mono), n1, opacity2/100.f*factor*mask2.mono, map2)
|
|
: n1;
|
|
|
|
float3 n3 = opacity3 > 0.f ?
|
|
combine_normals(1.f - (opacity3/100.f*mask3.mono), n2, opacity3/100.f*factor*mask3.mono, map3)
|
|
: n2;
|
|
|
|
float3 n4 = opacity4 > 0.f ?
|
|
combine_normals(1.f - (opacity4/100.f*mask4.mono), n3, opacity4/100.f*factor*mask4.mono, map4)
|
|
: n3;
|
|
|
|
return n4;
|
|
}
|
|
|
|
// 3dsmax Dent Map
|
|
export texture_return ad_3dsmax_dent
|
|
(
|
|
// Dent Params
|
|
color color1 = color(0.f)
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Color #1")
|
|
]],
|
|
color color2 = color(1.f)
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Color #2")
|
|
]],
|
|
uniform float size = 200.f
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Size")
|
|
]],
|
|
uniform float strength = 20.f
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Strength")
|
|
]],
|
|
uniform int iterations = 2
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Iterations")
|
|
]],
|
|
|
|
// Coords
|
|
uniform float blur = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur"),
|
|
anno::unused()
|
|
]],
|
|
uniform float3 offset = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Offset")
|
|
]],
|
|
uniform float3 tiling = float3(1.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Tiling")
|
|
]],
|
|
uniform float3 angle = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Angle")
|
|
]],
|
|
uniform float blur_Offset = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
// coordType: Object XYZ = 0, World XYZ = 1, Explicit Map Channel = 2, Vertex Color Channel = 3
|
|
uniform int coordType = 0
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Source")
|
|
]],
|
|
uniform int mapChannel = 1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map Channel")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return base::perlin_noise_texture
|
|
(
|
|
color1: color1,
|
|
color2: color2,
|
|
size: size / 30.0, // Experimental factor to improve the match
|
|
noise_levels: iterations,
|
|
absolute_noise: true, // Dent is absolute noise
|
|
noise_threshold_high: (strength != 0 ? 1/(strength) : 1), // Match seems rather close
|
|
apply_dent: true,
|
|
uvw: base::transform_coordinate
|
|
(
|
|
transform: base::rotation_translation_scale
|
|
(
|
|
scaling: tiling,
|
|
translation: offset,
|
|
rotation: float3(angle.x,angle.y,angle.z)/180.*math::PI
|
|
),
|
|
coordinate:
|
|
(
|
|
coordType == 0 ? // Object XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_object):
|
|
(
|
|
coordType == 1 ? // World XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_world):
|
|
(
|
|
// coordType == 2 ? // Explicit Map Channel
|
|
// base::coordinate_source(texture_space: mapChannel-1):
|
|
base::coordinate_source(texture_space: mapChannel-1) // No support for Vertex Color Channel, fallback to UVs
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
// 3dsmax Dent Map for Bump
|
|
export float3 ad_3dsmax_dent_bump
|
|
(
|
|
// Dent Params
|
|
color color1 = color(0.f)
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Color #1")
|
|
]],
|
|
color color2 = color(1.f)
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Color #2")
|
|
]],
|
|
uniform float size = 200.f
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Size")
|
|
]],
|
|
uniform float strength = 20.f
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Strength")
|
|
]],
|
|
uniform int iterations = 2
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Iterations")
|
|
]],
|
|
|
|
// Bump
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Bump amount")
|
|
]],
|
|
|
|
// Coords
|
|
uniform float blur = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float3 offset = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Offset")
|
|
]],
|
|
uniform float3 tiling = float3(1.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Tiling")
|
|
]],
|
|
uniform float3 angle = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Angle")
|
|
]],
|
|
uniform float blur_Offset = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
// coordType: Object XYZ = 0, World XYZ = 1, Explicit Map Channel = 2, Vertex Color Channel = 3
|
|
uniform int coordType = 0
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Source")
|
|
]],
|
|
uniform int mapChannel = 1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map Channel")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 perlin_normal = base::perlin_noise_bump_texture
|
|
(
|
|
factor: factor * (strength / 100.f), // Experimental
|
|
size: size / 30.f, // Experimental factor to improve the match
|
|
noise_levels: iterations,
|
|
absolute_noise: true, // Dent is absolute noise
|
|
apply_dent: true,
|
|
uvw: base::transform_coordinate
|
|
(
|
|
transform: base::rotation_translation_scale
|
|
(
|
|
scaling: tiling,
|
|
translation: offset,
|
|
rotation: float3(angle.x,angle.y,angle.z)/180.f*math::PI
|
|
),
|
|
coordinate:
|
|
(
|
|
coordType == 0 ? // Object XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_object):
|
|
(
|
|
coordType == 1 ? // World XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_world):
|
|
(
|
|
// coordType == 2 ? // Explicit Map Channel
|
|
// base::coordinate_source(texture_space: mapChannel-1):
|
|
base::coordinate_source(texture_space: mapChannel-1) // No support for Vertex Color Channel, fallback to UVs
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
float f = math::average(color1 - color2) * factor;
|
|
return combine_normals( f, perlin_normal, 1.f - f, state::normal() );
|
|
}
|
|
|
|
// 3dsmax Gradient Ramp Map
|
|
export enum ad_3dsmax_gradient_interpolation
|
|
{
|
|
custom = 0,
|
|
easy_in,
|
|
easy_in_out,
|
|
easy_out,
|
|
linear,
|
|
solid
|
|
};
|
|
|
|
|
|
export texture_return ad_3dsmax_gradient_ramp
|
|
(
|
|
// Gradient Params
|
|
uniform float[<nb_keys>] gradient_keys = float[](0.f, 50.f, 100.f)
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Gradient Keys")
|
|
]],
|
|
uniform float3[<nb_colors>] gradient_colors = float3[](float3(0.f, 0.f, 0.f), float3(0.5f, 0.5f, 0.5f), float3(1.f, 1.f, 1.f))
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Gradient Colors")
|
|
]],
|
|
uniform int gradient_type = 4
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Gradient Type"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_gradient_interpolation gradient_interpolation = linear
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Interpolation")
|
|
]],
|
|
|
|
// Noise Params
|
|
uniform float amount = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Amount"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
// type: regular = 0, fractal = 1, turbulence = 2
|
|
// 0- Regular (Generates plain noise. Basically the same as fractal noise with levels at 1.)
|
|
// 1- Fractal (Generates noise using a fractal algorithm. levels sets the number of iterations for the fractal noise.)
|
|
// 2- Turbulence (Generates fractal noise with an absolute value function applied to it to make fault lines.)
|
|
uniform int type = 0
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Type")
|
|
]],
|
|
uniform float size = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Size")
|
|
]],
|
|
uniform float phase = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Phase")
|
|
]],
|
|
uniform float levels = 4.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Levels")
|
|
]],
|
|
uniform float threshold_low = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Threshold Low")
|
|
]],
|
|
uniform float threshold_high = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Threshold High")
|
|
]],
|
|
uniform float threshold_smooth = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Threshold Smooth"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
|
|
// Coords
|
|
uniform int map_channel = 1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map Channel")
|
|
]],
|
|
uniform float3 offset = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Offset")
|
|
]],
|
|
uniform float3 tiling = float3(1.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Tiling")
|
|
]],
|
|
uniform float3 angle = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Angle")
|
|
]],
|
|
uniform bool u_tile = true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Tile"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool v_tile = true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Tile"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool u_mirror = false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Mirror")
|
|
]],
|
|
uniform bool v_mirror = false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Mirror")
|
|
]],
|
|
uniform float blur_Offset = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform int UVW_Type = 0
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("UVW_Type"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
|
|
// Output
|
|
uniform bool alpha_from_RGB = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Alpha from RGB Intensity"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
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"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Output Amount"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Level"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
texture_return noise;
|
|
|
|
if(amount > 0.f)
|
|
{
|
|
noise = base::perlin_noise_texture
|
|
(
|
|
size: size/30.f,
|
|
noise_phase: phase,
|
|
noise_levels: (type == 0 ? 1 : int(levels)), // Levels only used for fractal and turbulence noise types
|
|
absolute_noise: type == 2, // If set to true, the appearance of the pattern will be more "billowing" and "turbulent"
|
|
noise_threshold_high: threshold_high,
|
|
noise_threshold_low: threshold_low,
|
|
uvw: base::transform_coordinate
|
|
(
|
|
transform: max_rotation_translation_scale
|
|
(
|
|
scaling: tiling,
|
|
rotation: angle/180.f*math::PI ,
|
|
translation: offset,
|
|
u_mirror: u_mirror,
|
|
v_mirror: v_mirror
|
|
),
|
|
coordinate: base::coordinate_source(texture_space: map_channel-1)
|
|
)
|
|
);
|
|
}
|
|
|
|
float3 position = state::texture_coordinate(0);
|
|
|
|
float t = position.x + noise.mono*amount;
|
|
|
|
t = t - int(t);
|
|
if( t < 0.f)
|
|
t += 1.f;
|
|
else if( t > 1.f)
|
|
t -= 1.f;
|
|
|
|
t *= 100.f;
|
|
|
|
int idx=0;
|
|
for(int i=0; i<nb_keys-1; i++)
|
|
{
|
|
if(gradient_keys[i+1] >= t)
|
|
{
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
color c;
|
|
switch(gradient_interpolation)
|
|
{
|
|
case easy_in:
|
|
t = (t - gradient_keys[idx])/(gradient_keys[idx+1] - gradient_keys[idx]);
|
|
c = color(math::lerp( gradient_colors[idx], gradient_colors[idx+1], t*t));
|
|
break;
|
|
case easy_in_out:
|
|
t = (t - gradient_keys[idx])/(gradient_keys[idx+1] - gradient_keys[idx]);
|
|
c = color(math::lerp( gradient_colors[idx], gradient_colors[idx+1], t*t*(3.f - 2.f*t)));
|
|
break;
|
|
case easy_out:
|
|
t = (t - gradient_keys[idx])/(gradient_keys[idx+1] - gradient_keys[idx]);
|
|
c = color(math::lerp( gradient_colors[idx], gradient_colors[idx+1], math::sqrt(t)));
|
|
break;
|
|
default:
|
|
case linear:
|
|
t = (t - gradient_keys[idx])/(gradient_keys[idx+1] - gradient_keys[idx]);
|
|
c = color(math::lerp( gradient_colors[idx], gradient_colors[idx+1], t));
|
|
break;
|
|
case solid:
|
|
c = color(gradient_colors[idx]);
|
|
break;
|
|
}
|
|
|
|
return texture_return(c, math::average(c));
|
|
}
|
|
|
|
// 3dsmax Gradient Ramp Map for Bump
|
|
export float3 ad_3dsmax_gradient_ramp_bump
|
|
(
|
|
// Gradient Params
|
|
uniform float[<nb_keys>] gradient_keys = float[](0.f, 50.f, 100.f)
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Gradient Keys"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
|
|
]],
|
|
uniform float3[<nb_colors>] gradient_colors = float3[](float3(0.f, 0.f, 0.f), float3(0.5f, 0.5f, 0.5f), float3(1.f, 1.f, 1.f))
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Gradient Colors"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform int gradient_type = 5
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Gradient Type"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_gradient_interpolation gradient_interpolation = linear
|
|
[[
|
|
anno::in_group("Gradient Parameters"),
|
|
anno::display_name("Interpolation"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
|
|
// Noise Params
|
|
uniform float amount = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Amount"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
// type: regular = 0, fractal = 1, turbulence = 2
|
|
// 0- Regular (Generates plain noise. Basically the same as fractal noise with levels at 1.)
|
|
// 1- Fractal (Generates noise using a fractal algorithm. levels sets the number of iterations for the fractal noise.)
|
|
// 2- Turbulence (Generates fractal noise with an absolute value function applied to it to make fault lines.)
|
|
uniform int type = 0
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Type")
|
|
]],
|
|
uniform float size = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Size")
|
|
]],
|
|
uniform float phase = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Phase")
|
|
]],
|
|
uniform float levels = 4.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Levels")
|
|
]],
|
|
uniform float threshold_low = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Threshold Low")
|
|
]],
|
|
uniform float threshold_high = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Threshold High")
|
|
]],
|
|
uniform float threshold_smooth = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Threshold Smooth"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
|
|
// Bump
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Bump Parameters"),
|
|
anno::display_name("Bump factor")
|
|
]],
|
|
|
|
// Coords
|
|
uniform int map_channel = 1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map Channel")
|
|
]],
|
|
uniform float3 offset = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Offset")
|
|
]],
|
|
uniform float3 tiling = float3(1.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Tiling")
|
|
]],
|
|
uniform float3 angle = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Angle")
|
|
]],
|
|
uniform bool u_tile = true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Tile"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool v_tile = true
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Tile"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform bool u_mirror = false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("U Mirror")
|
|
]],
|
|
uniform bool v_mirror = false
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("V Mirror")
|
|
]],
|
|
uniform float blur_Offset = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform int UVW_Type = 0
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("UVW_Type"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
|
|
// Output
|
|
uniform bool alpha_from_RGB = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Alpha from RGB Intensity"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
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"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Output Amount"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Level"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 perlin_normal = base::perlin_noise_bump_texture
|
|
(
|
|
factor: factor,
|
|
size: size/30.f,
|
|
noise_phase: phase,
|
|
noise_levels: (type == 0 ? 1 : int(levels)), // Levels only used for fractal and turbulence noise types
|
|
absolute_noise: type == 2, // If set to true, the appearance of the pattern will be more "billowing" and "turbulent"
|
|
noise_threshold_high: threshold_high,
|
|
noise_threshold_low: threshold_low,
|
|
uvw: base::transform_coordinate
|
|
(
|
|
transform: max_rotation_translation_scale
|
|
(
|
|
scaling: tiling,
|
|
rotation: angle/180.f*math::PI ,
|
|
translation: offset,
|
|
u_mirror: u_mirror,
|
|
v_mirror: v_mirror
|
|
),
|
|
coordinate: base::coordinate_source(texture_space: map_channel-1)
|
|
)
|
|
);
|
|
// return combine_normals( factor, perlin_normal, 1.f-factor, state::normal() );
|
|
|
|
return math::normalize(math::lerp(state::normal(), perlin_normal, factor*amount));
|
|
|
|
}
|
|
|
|
|
|
// 3dsmax Falloff Map Type
|
|
export enum ad_3dsmax_falloff_Type
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
Towards_Away,
|
|
Perpendicular_Parallel,
|
|
Fresnel,
|
|
Shadow_Light,
|
|
Distance_Blend
|
|
};
|
|
|
|
// 3dsmax Falloff Map directions
|
|
export enum ad_3dsmax_falloff_direction
|
|
[[
|
|
anno::hidden()
|
|
]]
|
|
{
|
|
View,
|
|
Camera_X,
|
|
Camera_Y,
|
|
Object,
|
|
Local_X,
|
|
Local_Y,
|
|
Local_Z,
|
|
World_X,
|
|
World_Y,
|
|
World_Z
|
|
};
|
|
|
|
// 3dsmax Falloff Map
|
|
export texture_return ad_3dsmax_falloff
|
|
(
|
|
texture_return color1 = texture_return()
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Color #1")
|
|
]],
|
|
texture_return color2 = texture_return()
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Color #1"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_falloff_Type falloff_type = Perpendicular_Parallel
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Falloff type"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform ad_3dsmax_falloff_direction falloff_direction = View
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Falloff direction"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
float4x4 node = float4x4()
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Node"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float nearDistance = 0.f
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Near distance"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float farDistance = 1000000.f
|
|
[[
|
|
anno::in_group("Falloff"),
|
|
anno::display_name("Far distance"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return color1;
|
|
}
|
|
|
|
// 3dsmax Mix Map
|
|
export texture_return ad_3dsmax_mix
|
|
(
|
|
texture_return color1 = texture_return()
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Color #1")
|
|
]],
|
|
texture_return color2 = texture_return()
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Color #2")
|
|
]],
|
|
float mixAmount = 0.f
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Mix amount"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform bool useCurve = false
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Use curve")
|
|
]],
|
|
uniform float lower = 0.3f
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Lower"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float upper = .7f
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Upper"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float t = useCurve ? math::smoothstep(lower, upper, mixAmount) : math::smoothstep(0.0, 1.0, mixAmount);
|
|
|
|
return texture_return(
|
|
math::lerp(color1.tint,color2.tint, t),
|
|
math::lerp(color1.mono,color2.mono, t));
|
|
}
|
|
|
|
// 3dsmax Mix Map for Bump
|
|
export float3 ad_3dsmax_mix_bump
|
|
(
|
|
float3 color1 = state::normal()
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Bump Map #1")
|
|
]],
|
|
float3 color2 = state::normal()
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Bump Map #2")
|
|
]],
|
|
float mixAmount = 0.f
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Mix amount"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform bool useCurve = false
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Use Curve")
|
|
]],
|
|
uniform float lower = 0.3f
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Lower"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
uniform float upper = .7f
|
|
[[
|
|
anno::in_group("Mix parameters"),
|
|
anno::display_name("Upper"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]],
|
|
|
|
// Bump
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Dent Parameters"),
|
|
anno::display_name("Bump amount")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float t = useCurve ? math::smoothstep(lower, upper, mixAmount) : math::smoothstep(0.0, 1.0, mixAmount);
|
|
float3 mix_normal = math::normalize(math::lerp(color1, color2, t));
|
|
|
|
return math::normalize(math::lerp(state::normal(), mix_normal, bump_amount));
|
|
}
|
|
|
|
// 3dsmax Noise Map
|
|
export texture_return ad_3dsmax_noise
|
|
(
|
|
// Noise Params
|
|
color color1 = color(0.f)
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Color #1")
|
|
]],
|
|
color color2 = color(1.f)
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Color #2")
|
|
]],
|
|
uniform float size = 25.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Size")
|
|
]],
|
|
uniform float phase = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Phase")
|
|
]],
|
|
uniform float levels = 3.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Levels")
|
|
]],
|
|
uniform float thresholdLow = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Threshold Low")
|
|
]],
|
|
uniform float thresholdHigh = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Threshold High")
|
|
]],
|
|
// type: regular = 0, fractal = 1, turbulence = 2
|
|
// 0- Regular (Generates plain noise. Basically the same as fractal noise with levels at 1.)
|
|
// 1- Fractal (Generates noise using a fractal algorithm. levels sets the number of iterations for the fractal noise.)
|
|
// 2- Turbulence (Generates fractal noise with an absolute value function applied to it to make fault lines.)
|
|
uniform int type = 1
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Type")
|
|
]],
|
|
|
|
// Coords
|
|
uniform float blur = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float3 offset = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Offset")
|
|
]],
|
|
uniform float3 tiling = float3(1.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Tiling")
|
|
]],
|
|
uniform float3 angle = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Angle")
|
|
]],
|
|
uniform float blur_Offset = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
// coordType: Object XYZ = 0, World XYZ = 1, Explicit Map Channel = 2, Vertex Color Channel = 3
|
|
uniform int coordType = 0
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Source")
|
|
]],
|
|
uniform int mapChannel = 1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map Channel")
|
|
]],
|
|
|
|
// Output
|
|
uniform bool alphaFromRGB = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Alpha from RGB Intensity"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
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"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Output Amount"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Level"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
return base::perlin_noise_texture
|
|
(
|
|
color1: color1,
|
|
color2: color2,
|
|
size: size/30.f,
|
|
noise_phase: phase,
|
|
noise_levels: (type == 0 ? 1 : int(levels)), // Levels only used for fractal and turbulence noise types
|
|
absolute_noise: type == 2, // If set to true, the appearance of the pattern will be more "billowing" and "turbulent"
|
|
noise_threshold_high: thresholdHigh,
|
|
noise_threshold_low: thresholdLow,
|
|
uvw: base::transform_coordinate
|
|
(
|
|
transform: base::rotation_translation_scale
|
|
(
|
|
scaling: tiling,
|
|
translation: offset,
|
|
rotation: float3(angle.x,angle.y,angle.z)/180.*math::PI
|
|
),
|
|
coordinate:
|
|
(
|
|
coordType == 0 ? // Object XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_object):
|
|
(
|
|
coordType == 1 ? // World XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_world):
|
|
(
|
|
// coordType == 2 ? // Explicit Map Channel
|
|
// base::coordinate_source(texture_space: mapChannel-1):
|
|
base::coordinate_source(texture_space: mapChannel-1) // No support for Vertex Color Channel, fallback to UVs
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
// 3dsmax Noise Map for Bump
|
|
export float3 ad_3dsmax_noise_bump
|
|
(
|
|
// Noise Params
|
|
color color1 = color(0.f)
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Color #1")
|
|
]],
|
|
color color2 = color(1.f)
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Color #2")
|
|
]],
|
|
uniform float size = 25.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Size")
|
|
]],
|
|
uniform float phase = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Phase")
|
|
]],
|
|
uniform float levels = 3.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Levels")
|
|
]],
|
|
uniform float thresholdLow = 0.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Threshold Low")
|
|
]],
|
|
uniform float thresholdHigh = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Threshold High")
|
|
]],
|
|
// type: regular = 0, fractal = 1, turbulence = 2
|
|
// 0- Regular (Generates plain noise. Basically the same as fractal noise with levels at 1.)
|
|
// 1- Fractal (Generates noise using a fractal algorithm. levels sets the number of iterations for the fractal noise.)
|
|
// 2- Turbulence (Generates fractal noise with an absolute value function applied to it to make fault lines.)
|
|
uniform int type = 1
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Noise Type")
|
|
]],
|
|
|
|
// Bump
|
|
uniform float factor = 1.f
|
|
[[
|
|
anno::in_group("Noise Parameters"),
|
|
anno::display_name("Bump amount")
|
|
]],
|
|
|
|
// Coords
|
|
uniform float blur = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float3 offset = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Offset")
|
|
]],
|
|
uniform float3 tiling = float3(1.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Tiling")
|
|
]],
|
|
uniform float3 angle = float3(0.f)
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Angle")
|
|
]],
|
|
uniform float blur_Offset = 1.f
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Blur Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
// coordType: Object XYZ = 0, World XYZ = 1, Explicit Map Channel = 2, Vertex Color Channel = 3
|
|
uniform int coordType = 0
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Source")
|
|
]],
|
|
uniform int mapChannel = 1
|
|
[[
|
|
anno::in_group("Coordinates"),
|
|
anno::display_name("Map Channel")
|
|
]],
|
|
|
|
// Output
|
|
uniform bool alphaFromRGB = false
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Alpha from RGB Intensity"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float bump_amount = 1.0
|
|
[[
|
|
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"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float output_amount = 1.0
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("Output Amount"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_level = 1.0
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Level"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]],
|
|
uniform float rgb_offset = 0.0
|
|
[[
|
|
anno::in_group("Output"),
|
|
anno::display_name("RGB Offset"),
|
|
anno::unused(),
|
|
anno::hidden()
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 perlin_normal = base::perlin_noise_bump_texture
|
|
(
|
|
factor: factor,
|
|
size: size/30.f,
|
|
noise_phase: phase,
|
|
noise_levels: (type == 0 ? 1 : int(levels)), // Levels only used for fractal and turbulence noise types
|
|
absolute_noise: type == 2, // If set to true, the appearance of the pattern will be more "billowing" and "turbulent"
|
|
noise_threshold_high: thresholdHigh,
|
|
noise_threshold_low: thresholdLow,
|
|
uvw: base::transform_coordinate
|
|
(
|
|
transform: base::rotation_translation_scale
|
|
(
|
|
scaling: tiling,
|
|
translation: offset,
|
|
rotation: float3(angle.x,angle.y,angle.z)/180.*math::PI
|
|
),
|
|
coordinate:
|
|
(
|
|
coordType == 0 ? // Object XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_object):
|
|
(
|
|
coordType == 1 ? // World XYZ
|
|
base::coordinate_source(coordinate_system: base::texture_coordinate_world):
|
|
(
|
|
// coordType == 2 ? // Explicit Map Channel
|
|
// base::coordinate_source(texture_space: mapChannel-1):
|
|
base::coordinate_source(texture_space: mapChannel-1) // No support for Vertex Color Channel, fallback to UVs
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
float f = math::average(color1 - color2) * factor;
|
|
return combine_normals( f, perlin_normal, 1-f, state::normal() );
|
|
}
|
|
|
|
// 3dsmax Output Map
|
|
export texture_return ad_3dsmax_output
|
|
(
|
|
texture_return MAP1 = texture_return()
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Map")
|
|
]],
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Bump amount"),
|
|
anno::unused()
|
|
]],
|
|
uniform bool clamp = false
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Clamp")
|
|
]],
|
|
uniform bool invert = false
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Invert")
|
|
]],
|
|
uniform bool alphaFromRGB = false
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Alpha from RGB intensity")
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Output amount"),
|
|
anno::unused()
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("RGB level")
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("RGB offset")
|
|
]]
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
color rgb(MAP1.tint*rgb_level + rgb_offset);
|
|
|
|
if(clamp || invert)
|
|
rgb = math::clamp(rgb, 0.f, 1.f);
|
|
|
|
if(invert)
|
|
rgb = color(1.f) - rgb;
|
|
|
|
return texture_return(rgb, alphaFromRGB ? math::luminance(rgb) : MAP1.mono);
|
|
|
|
}
|
|
|
|
// 3dsmax Output Map for Bump
|
|
export float3 ad_3dsmax_output_bump
|
|
(
|
|
float3 MAP1 = state::normal()
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Map")
|
|
]],
|
|
uniform float bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Bump amount")
|
|
]],
|
|
uniform bool clamp = false
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Clamp"),
|
|
anno::unused()
|
|
]],
|
|
uniform bool invert = false
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Invert")
|
|
]],
|
|
uniform bool alphaFromRGB = false
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Alpha from RGB intensity"),
|
|
anno::unused()
|
|
]],
|
|
uniform float output_amount = 1.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("Output amount"),
|
|
anno::unused()
|
|
]],
|
|
uniform float rgb_level = 1.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("RGB level"),
|
|
anno::unused()
|
|
]],
|
|
uniform float rgb_offset = 0.f
|
|
[[
|
|
anno::in_group("Output Parameters"),
|
|
anno::display_name("RGB offset"),
|
|
anno::unused()
|
|
]],
|
|
uniform float base_bump_amount = 1.f
|
|
[[
|
|
anno::in_group("Bump"),
|
|
anno::display_name("Base bump amount"),
|
|
anno::hard_range(0.f, 1.f)
|
|
]]
|
|
|
|
)
|
|
[[
|
|
anno::author("NVIDIA Corporation")
|
|
]]
|
|
{
|
|
float3 normal = MAP1;
|
|
if(invert)
|
|
{
|
|
normal = transform_internal_to_tangent(normal);
|
|
normal = float3(-normal.x, -normal.y, normal.z);
|
|
normal = transform_tangent_to_internal(normal);
|
|
}
|
|
|
|
return math::normalize(math::lerp(state::normal(), normal, bump_amount*base_bump_amount));
|
|
}
|