Scratches - 图1

    1. // Micro Scratched Texture
    2. //
    3. // Author: John Su <cuckons@gmail.com>
    4. // Changes by Michael Abrahams <miabraha@gmail.com>
    5. // Last Modified 1/11/2021 for Redshift 3D + Metadata & Triplaner
    6. // An OSL shader that generates texture to make swirly micro scratch look by
    7. // controlling the anistropy and roughness.
    8. // The original idea is from Hang Li(悬挂鲤) and Ben Paschke. Here I implemented
    9. // it using OSL and exposured some arts friendly parameters.
    11. float AxisMask(point axis, float power)
    12. {
    13.     return pow(abs(dot(N, axis)), power);
    14. }
    16. float lineDistance(point p, float direction){
    17.     float theta = direction * M_2PI;
    18.     float s = 0, c = 1;
    19.     sincos(theta, s, c);
    20.     vector v = vector(c,s,0);
    21.     float distance = length(p - (v * dot(v, p)));
    22.     return distance;
    23. }
    25. void generateScratchPlane(point shading_p,
    26.                             int max_search_cell,
    27.                             point index,
    28.                             int seed,
    29.                             float delta,
    30.                             float hardScratches,
    31.                             float roughness_default,
    32.                             float roughness_min,
    33.                             float roughness_max,
    34.                             float anisotropic_min,
    35.                             float anisotropic_max,
    36.                             float scratchWidth,
    37.                              output float roughness, output float anisotropy, output float rotation, output float scratch)
    38. {
    39.     for (int x = -max_search_cell; x <= max_search_cell; ++x){
    40.         for (int y = -max_search_cell; y <= max_search_cell; ++y){
    42.             // Distance from line in neighbor cell
    43.             point line_cell_index = index + point(x, y, 0);
    44.             point scratch_origin_p = (line_cell_index + (hashnoise(line_cell_index + seed + .8) - 0.5)) * delta;
    45.             rotation = hashnoise(line_cell_index + seed + .88);
    46.             float dist = lineDistance(scratch_origin_p - shading_p, rotation);
    48.             // Randomize width
    49.             float width = scratchWidth * hashnoise(line_cell_index + seed + .888) / 2048;
    51.             // hard = 0-1 step function; soft = linear gradient
    52.             if (hardScratches) {
    53.                 scratch = 1 - step(width, dist);
    54.             }
    55.             else {
    56.                 scratch = 1 - min(dist / width, 1);
    57.             }
    59.             if (scratch)
    60.             {
    61.                 roughness = select(
    62.                         roughness_default,
    63.                         mix(roughness_min, roughness_max, hashnoise(line_cell_index + seed + .8888)),
    64.                         scratch > 0
    65.                 );
    66.                 anisotropy = select(
    67.                         0,
    68.                         mix(anisotropic_min, anisotropic_max, hashnoise(line_cell_index + seed + .88888)),
    69.                         scratch > 0
    70.                 );
    71.                 rotation *= scratch;
    72.                 return;
    73.             }
    74.         }
    75.     }
    76. }
    79. shader Scratches
    80. [[  string help = "Procedural Scratches",
    81.     string label = "Scratches" ]]
    82. (
    83.         float density=10
    84.             [[string label="Density",
    85.             string widget="number",
    86.             float min=1,
    87.             float max=50]],
    88.         float scale=5
    89.             [[string label="Scale",
    90.             string widget="number",
    91.             float min=.01,
    92.             float max=100]],
    93.         float scratchLength=10
    94.             [[string label="Scratch Length",
    95.             string widget="number",
    96.             float min=0,
    97.             float max=10]],
    98.         float scratchWidth=1
    99.             [[string label="Scratch Width",
    100.             string widget="number",
    101.             float min=0,
    102.             float max=10]],
    103.         int hardScratches=1
    104.             [[string label="Hard scratches",
    105.             string widget="checkBox"]],
    106.         float roughness_default = 0.0
    107.             [[string label="Default Roughness",
    108.             string widget="number",
    109.             float min=0,
    110.             float max=1]],
    111.         float roughness_min=0.1
    112.             [[string label="Minimum Roughness",
    113.             string widget="number",
    114.             float min=0,
    115.             float max=1]],
    116.         float roughness_max=0.2
    117.             [[string label="Maximum Roughness",
    118.             string widget="number",
    119.             float min=0,
    120.             float max=1]],
    121.         float anisotropic_min = 0.0
    122.             [[string label="Minimum Anisotropy",
    123.             string widget="number",
    124.             float min=0,
    125.             float max=1]],
    126.         float anisotropic_max = 0.2
    127.             [[string label="Maximum Anisotropy",
    128.             string widget="number",
    129.             float min=0,
    130.             float max=1]],
    131.         float blendPower = 1,
    132.     int seed=12345
    133.         [[string label="Random Seed",
    134.         string widget="number",
    135.         int min=0,
    136.         int max=99999]],
    137.     output float roughness = 0 + roughness_default,
    138.     output float anisotropy = 0,
    139.     output float rotation = 0,
    140.     output float scratch = 0
    141. ){
    143.     // Divides texture space into a grid
    144.     // Each cell contains a scratch that will be offset by a hash noise.
    145.     // "density" and "scale" both effectively scale the shader,
    146.     // but density preserves scratch length.
    147.     float delta = 1/max(density * density * scale, .1);
    148.     int max_search_cell = (int)ceil(scratchLength);
    150.     //XY
    151.     point xy = point(P[0], P[1], 0)*scale;
    152.     point xyIndex = point(round(scale * P[0]/delta), round(scale * P[1]/delta), 0.0);
    153.     float xyPlaneRoughness = 0;
    154.     float xyPlaneAnisotropy = 0;
    155.     float xyPlaneRotation = 0;
    156.     float xyPlaneScratch = 0;
    157.     generateScratchPlane(xy, max_search_cell, xyIndex, seed, delta, hardScratches, roughness_default, roughness_min, roughness_max, anisotropic_min, anisotropic_max, scratchWidth, xyPlaneRoughness, xyPlaneAnisotropy, xyPlaneRotation, xyPlaneScratch);
    160.     //XZ
    161.     point xz = point(P[0], P[2], 0)*scale;
    162.     point xzIndex = point(round(scale * P[0]/delta), round(scale * P[2]/delta), 0.0);
    163.     float xzPlaneRoughness = 0;
    164.     float xzPlaneAnisotropy = 0;
    165.     float xzPlaneRotation = 0;
    166.     float xzPlaneScratch = 0;
    167.     generateScratchPlane(xz, max_search_cell, xzIndex, seed + 1, delta, hardScratches, roughness_default, roughness_min, roughness_max, anisotropic_min, anisotropic_max, scratchWidth, xzPlaneRoughness, xzPlaneAnisotropy, xzPlaneRotation, xzPlaneScratch);
    170.     //YZ
    171.     point yz = point(P[1], P[2], 0)*scale;
    172.     point yzIndex = point(round(scale * P[1]/delta), round(scale * P[2]/delta), 0.0);
    173.     float yzPlaneRoughness = 0;
    174.     float yzPlaneAnisotropy = 0;
    175.     float yzPlaneRotation = 0;
    176.     float yzPlaneScratch = 0;
    177.     generateScratchPlane(yz, max_search_cell, yzIndex, seed + 2, delta, hardScratches, roughness_default, roughness_min, roughness_max, anisotropic_min, anisotropic_max, scratchWidth, yzPlaneRoughness, yzPlaneAnisotropy, yzPlaneRotation, yzPlaneScratch);
    180.     roughness = mix(xyPlaneRoughness, xzPlaneRoughness, AxisMask(point(0,1,0), blendPower));
    181.     anisotropy = mix(xyPlaneAnisotropy, xzPlaneAnisotropy, AxisMask(point(0,1,0), blendPower));
    182.     rotation = mix(xyPlaneRotation, xzPlaneRotation, AxisMask(point(0,1,0), blendPower));
    183.     scratch = mix(xyPlaneScratch, xzPlaneScratch, AxisMask(point(0,1,0), blendPower));
    185.     roughness = mix(roughness, yzPlaneRoughness, AxisMask(point(1,0,0), blendPower));
    186.     anisotropy = mix(anisotropy, yzPlaneAnisotropy, AxisMask(point(1,0,0), blendPower));
    187.     rotation = mix(rotation, yzPlaneRotation, AxisMask(point(1,0,0), blendPower));
    188.     scratch = mix(scratch, yzPlaneScratch, AxisMask(point(1,0,0), blendPower));
    189. }