@tushar-br/editing-pack 1.0.195 → 1.0.197

package/staging_area/Blender/blender.shared/usd/hdSt/resources/shaders/domeLight.glslfx

@@ -1,280 +0,0 @@
--- glslfx version 0.1
-
-//
-// Copyright 2019 Pixar
-//
-// Licensed under the terms set forth in the LICENSE.txt file available at
-// https://openusd.org/license.
-//
-
--- configuration
-{
-    "techniques": {
-        "default": {
-            "domeLightIrradiance": {
-                "source": [ "DomeLight.Common",
-                            "DomeLight.Irradiance" ]
-            },
-            "domeLightPrefilter": {
-                "source": [ "DomeLight.Common",
-                            "DomeLight.CommonSampling",
-                            "DomeLight.Prefilter" ]
-            },
-            "domeLightBRDF": {
-                "source": [ "DomeLight.Common",
-                            "DomeLight.CommonSampling",
-                            "DomeLight.BRDF" ]
-            }
-        }
-    }
-}
-
---- --------------------------------------------------------------------------
--- glsl DomeLight.Common
-
-const float PI = 3.1415926536;
-
-// compute texture coords based on the size of the output image/texture
-vec2 GetTexCoords(ivec2 outCoords)
-{
-    vec2 outDims = vec2(HgiGetSize_outTexture());
-    // apply a (0.5, 0.5) offset to use pixel centers and not pixel corners
-    vec2 texCoords = (vec2(outCoords) + vec2(0.5, 0.5)) / outDims;
-    return texCoords;
-}
-
-float SanitizeValue(float value)
-{
-    if (isnan(value) || isinf(value)) {
-        return 0;
-    }
-    return value;
-}
-
-vec3 SanitizeChannels(vec3 value)
-{
-    return vec3(SanitizeValue(value.r),
-                SanitizeValue(value.g),
-                SanitizeValue(value.b));
-}
-
-// sample lat/long env map input texture
-vec3 SampleEnvMapLod(vec3 sampleVec, float sampleLod) {
-    vec2 coord = vec2((atan(sampleVec.z, sampleVec.x) + PI) / (2.0 * PI),
-                      acos(sampleVec.y) / PI);
-    vec3 value = HgiTextureLod_inTexture(coord, sampleLod).rgb;
-
-    return SanitizeChannels(value);
-}
-
-// compute world position from texture coords
-vec3 GetWorldPos(vec2 textureCoord)
-{
-    // have theta range from [-PI, PI] so the origin is in the center
-    // of the image
-    float theta = (textureCoord.x * 2.0 * PI) - PI;
-    float phi = (textureCoord.y * PI);
-    float x = cos(theta) * sin(phi);
-    float y = cos(phi);
-    float z = sin(theta) * sin(phi);
-    return vec3(x, y, z);
-}
-
---- --------------------------------------------------------------------------
--- glsl DomeLight.CommonSampling
-
-float RadicalInverse(uint a)
-{
-    return float(bitfieldReverse(a)) * 2.3283064365386963e-10; // 0x1p-32
-}
-
-vec2 Hammersley2d(uint a, uint N)
-{
-    return vec2(float(a) / float(N), RadicalInverse(a));
-}
-
-vec3 ImportanceSample_GGX(vec2 Xi, float roughness, vec3 normal)
-{
-    // Maps a 2D point to a hemisphere with spread based on roughness
-    float alpha = roughness * roughness;
-    float phi = 2.0 * PI * Xi.x;
-    
-    // Clamp cosTheta to at most 1. Values larger than 1 (arising from floating 
-    // point imprecision perhaps) can cause NaNs in the sinTheta term.
-    float cosTheta = min(
-        1.0, sqrt((1.0 - Xi.y) / (1.0 + (alpha*alpha - 1.0) * Xi.y)));
-    
-    float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
-    vec3 H = vec3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta);
-
-    // Tangent space
-    vec3 up = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-    vec3 tangentX = normalize(cross(up, normal));
-    vec3 tangentY = normalize(cross(normal, tangentX));
-
-    // Convert to world Space
-    return normalize(tangentX * H.x + tangentY * H.y + normal * H.z);
-}
-
---- --------------------------------------------------------------------------
--- glsl DomeLight.Irradiance
-
-const float deltaPhi = (2.0f * float(PI)) / 180.0f;
-const float deltaTheta = (0.5f * float(PI)) / 64.0f;
-
-vec3 SampleEnvMap(vec3 sampleVec)
-{
-    // sample from a mipmap level of the environment map determined by the
-    // size of the environment map and the number of samples we are taking
-    ivec2 inDims = HgiGetSize_inTexture();
-    float mipLevel = ceil(log2(inDims.x * deltaPhi/(2.0 * PI)) * 2.0f);
-
-    return SampleEnvMapLod(sampleVec, mipLevel);
-}
-
-vec3 ComputeIrradiance(vec3 inPos)
-{
-    vec3 N = normalize(inPos);
-    vec3 up = vec3(0.0, 1.0, 0.0);
-    vec3 right = normalize(cross(up, N));
-    up = cross(N, right);
-
-    const float TWO_PI = PI * 2.0;
-    const float HALF_PI = PI * 0.5;
-
-    vec3 color = vec3(0.0);
-    uint sampleCount = 0u;
-    for (float phi = 0.0; phi < TWO_PI; phi += deltaPhi) {
-        for (float theta = 0.0; theta < HALF_PI; theta += deltaTheta) {
-            vec3 tempVec = cos(phi) * right + sin(phi) * up;
-            vec3 sampleVector = cos(theta) * N + sin(theta) * tempVec;
-            color += SampleEnvMap(sampleVector).rgb * cos(theta) * sin(theta);
-            sampleCount++;
-        }
-    }
-    return PI * color / float(sampleCount);
-}
-
-void main(void)
-{
-    ivec2 outCoords = ivec2(hd_GlobalInvocationID.xy);
-
-    vec2 texCoords = GetTexCoords(outCoords);
-    vec3 pos3D = GetWorldPos(texCoords);
-    vec4 outColor = vec4(ComputeIrradiance(pos3D), 1.0);
-
-    HgiSet_outTexture(outCoords, outColor);
-}
-
---- --------------------------------------------------------------------------
--- glsl DomeLight.Prefilter
-
-// Normal Distribution function
-float Distribution_GGX(float dotNH, float roughness)
-{
-    float alpha = roughness * roughness;
-    float alpha2 = alpha * alpha;
-    float denom = dotNH * dotNH * (alpha2 - 1.0) + 1.0;
-    return (alpha2)/(PI * denom*denom);
-}
-
-vec3 PrefilterEnvMap(vec3 R, float roughness)
-{
-    vec3 N = R;
-    vec3 V = R;
-    vec3 color = vec3(0.0);
-    float totalWeight = 0.0;
-    float envMapDim = float(HgiGetSize_inTexture().x);
-    const uint numSamples = 1024u;
-    for (uint i = 0u; i < numSamples; i++) {
-        vec2 Xi = Hammersley2d(i, numSamples);
-        vec3 H = ImportanceSample_GGX(Xi, roughness, N);
-        vec3 L = 2.0 * dot(V, H) * H - V;
-        float dotNL = clamp(dot(N, L), 0.0, 1.0);
-        if (dotNL > 0.0) {
-
-            float dotNH = clamp(dot(N, H), 0.0, 1.0);
-            float dotVH = clamp(dot(V, H), 0.0, 1.0);
-
-            // Probability Distribution Function
-            float pdf = Distribution_GGX(dotNH, roughness) * dotNH
-                                                / (4.0 * dotVH) + 0.0001;
-            // Solid angle of current sample
-            float omegaS = 1.0 / (float(numSamples) * pdf);
-            // Solid angle of 1 pixel across all cube faces
-            float omegaP = 4.0 * PI / (6.0 * envMapDim * envMapDim);
-            // Biased (+1.0) mip level for better result
-            float mipLevel = roughness == 0.0
-                           ? 0.0 : max(0.5 * log2(omegaS / omegaP) + 1.0, 0.0f);
-            color += SampleEnvMapLod(L, mipLevel).rgb * dotNL;
-            totalWeight += dotNL;
-
-        }
-    }
-    return (color / totalWeight);
-}
-
-void main(void)
-{
-    ivec2 outCoords = ivec2(hd_GlobalInvocationID.xy);
-
-    vec2 texCoords = GetTexCoords(outCoords);
-    vec3 pos3D = GetWorldPos(texCoords);
-    vec3 R = normalize(pos3D);
-    vec4 outColor = vec4(PrefilterEnvMap(R, inRoughness), 1.0);
-
-    HgiSet_outTexture(outCoords, outColor);
-}
-
---- --------------------------------------------------------------------------
--- glsl DomeLight.BRDF
-
-float Geometry_SchlicksmithGGX(float dotNL, float dotNV, float roughness)
-{
-    float k = (roughness * roughness) / 2.0;
-    float GL = dotNL / (dotNL * (1.0 - k) + k);
-    float GV = dotNV / (dotNV * (1.0 - k) + k);
-    return GL * GV;
-}
-
-vec2 ComputeBRDF(float NoV, float roughness)
-{
-    // make sure NoV doesn't go exactly to 0 to avoid NaN
-    NoV = max(NoV, 0.001);
-
-    // Normal always points along z-axis for the 2D lookup
-    const vec3 N = vec3(0.0, 0.0, 1.0);
-    vec3 V = vec3(sqrt(1.0 - NoV*NoV), 0.0, NoV);
-
-    vec2 LUT = vec2(0.0);
-    const uint NUM_SAMPLES = 1024u;
-    for (uint i = 0u; i < NUM_SAMPLES; i++) {
-        vec2 Xi = Hammersley2d(i, NUM_SAMPLES);
-        vec3 H = ImportanceSample_GGX(Xi, roughness, N);
-        vec3 L = 2.0 * dot(V, H) * H - V;
-
-        float dotNL = max(dot(N, L), 0.0);
-        float dotNV = max(dot(N, V), 0.0);
-        float dotVH = max(dot(V, H), 0.0);
-        float dotNH = max(dot(H, N), 0.0);
-
-        if (dotNL > 0.0) {
-            float G = Geometry_SchlicksmithGGX(dotNL, dotNV, roughness);
-            float G_Vis = (G * dotVH) / (dotNH * dotNV);
-            float Fc = pow(1.0 - dotVH, 5.0);
-            LUT += vec2((1.0 - Fc) * G_Vis, Fc * G_Vis);
-        }
-    }
-    return LUT / float(NUM_SAMPLES);
-}
-
-void main(void)
-{
-    ivec2 outCoords = ivec2(hd_GlobalInvocationID.xy);
-
-    vec2 texCoords = GetTexCoords(outCoords);
-    // texCoords.x represents N dot E and texCoords.y represents roughness
-    vec4 outColor = vec4(ComputeBRDF(texCoords.x, texCoords.y), 0.0, 1.0);
-
-    HgiSet_outTexture(outCoords, outColor);
-}

package/staging_area/Blender/blender.shared/usd/hdSt/resources/shaders/edgeId.glslfx

@@ -1,237 +0,0 @@
--- glslfx version 0.1
-
-//
-// Copyright 2018 Pixar
-//
-// Licensed under the terms set forth in the LICENSE.txt file available at
-// https://openusd.org/license.
-//
-
---- This is what an import might look like.
---- #import $TOOLS/hdSt/shaders/edgeId.glslfx
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.None
-
-int GetPrimitiveEdgeId()
-{
-    return -1;
-}
-
-float GetSelectedEdgeOpacity()
-{
-    return 0;
-}
-
-bool SelectWireframeFaceEdges()
-{
-    return false;
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.Common
-
-// Determines whether a fragment is on or close to an unhidden triangle edge.
-const float edgePickRadius = 2; // in viewport pixels
-const float edgePickParametricRadius = 0.02; // in parametric space
-
-// For smooth looking edges, use an exponential falloff for the opacity.
-// Note: We use a slower falloff fn than in meshWire.glslfx to make the
-// selected edges stand out.
-float SelectedEdgeFalloff(float d) {
-    return exp2(-1 * d * d);
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.TriangleSurface
-
-FORWARD_DECL(vec3 GetEdgeDistanceTriangle());
-
-vec3 ComputeBaseFaceEdgeDistanceTriangle()
-{
-    return GetEdgeDistanceTriangle();
-}
-
-bool SelectWireframeFaceEdges()
-{
-    return false;
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.TriangleLines
-
-vec3 ComputeBaseFaceEdgeDistanceTriangle()
-{
-    // Use parametric distance since we can't use surface derivatives for lines
-    vec3 param = GetEdgeParamTriangle();
-    bvec3 nearEdge = lessThan(param, vec3(edgePickParametricRadius));
-    return vec3(edgePickRadius) * vec3(not(nearEdge));
-}
-
-bool SelectWireframeFaceEdges()
-{
-    // Make sure that edges of selected faces are highlighted correctly for
-    // wireframe lines, i.e. if an edge of an adjacent non-selected face
-    // draws over an edge of a selected face that the edge is drawn using
-    // the correct selection color.
-    return true;
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.TriangleParam
-
-float GetSelectedEdgeOpacity()
-{
-    float closestEdgeDistance = 0.0;
-
-    // The sequence of comparisons should match GetPrimitiveEdgeId()
-    vec3 dist = ComputeBaseFaceEdgeDistanceTriangle();
-    if (dist.x < edgePickRadius) {
-        closestEdgeDistance = dist.x;
-    } else if (dist.y < edgePickRadius) {
-        closestEdgeDistance = dist.y;
-    } else if (dist.z < edgePickRadius) {
-        closestEdgeDistance = dist.z;
-    } else {
-        return 0;
-    }
-
-    return SelectedEdgeFalloff(closestEdgeDistance);
-}
-
-// called from hdx/renderPass.glslfx and selection.glslfx
-int GetPrimitiveEdgeId()
-{
-    //              2 (0,1,0)
-    //              ^
-    //         e2 /   \ e1
-    //           /     \'
-    // (0,0,1)  0 ----- 1 (1,0,0)
-    //              e0
-
-    int edgeId = -1;
-
-    vec3 dist = ComputeBaseFaceEdgeDistanceTriangle();
-    if (dist.x < edgePickRadius) {
-        edgeId = 0;
-    } else if (dist.y < edgePickRadius) {
-        edgeId = 1;
-    } else if (dist.z < edgePickRadius) {
-        edgeId = 2;
-    } else {
-        return -1; // Not on a mesh edge
-    }
-
-    const int edgeFlag = GetEdgeFlag();
-    const int meshEdgeIndex = HdGetScalar_edgeIndices();
-
-    // Translate face-edge to authored mesh-edge
-    if (edgeFlag == 0) {
-        edgeId = meshEdgeIndex + edgeId; // regular triangle face.
-    } else if ((bool(edgeFlag & 1) && edgeId == 2) ||
-               (bool(edgeFlag & 2) && edgeId == 0)) {
-        edgeId = -1; // Not an authored mesh edge
-    } else {
-        edgeId = meshEdgeIndex + edgeId - 1;
-    }
-    return edgeId;
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.QuadSurface
-
-vec4 ComputeBaseFaceEdgeDistanceQuad()
-{
-    return GetEdgeDistanceQuad();
-}
-
-bool SelectWireframeFaceEdges()
-{
-    return false;
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.QuadLines
-
-vec4 ComputeBaseFaceEdgeDistanceQuad()
-{
-    // Use parametric distance since we can't use surface derivatives for lines
-    vec4 param = GetEdgeParamQuad();
-    bvec4 nearEdge = lessThan(param, vec4(edgePickParametricRadius));
-    return vec4(edgePickRadius) * vec4(not(nearEdge));
-}
-
-bool SelectWireframeFaceEdges()
-{
-    // Make sure that edges of selected faces are highlighted correctly for
-    // wireframe lines, i.e. if an edge of an adjacent non-selected face
-    // draws over an edge of a selected face that the edge is drawn using
-    // the correct selection color.
-    return true;
-}
-
---- --------------------------------------------------------------------------
--- glsl EdgeId.Fragment.QuadParam
-
-float GetSelectedEdgeOpacity()
-{
-    float closestEdgeDistance = 0.0;
-
-    // The sequence of comparisons should match GetPrimitiveEdgeId()
-    vec4 dist = ComputeBaseFaceEdgeDistanceQuad();
-    if (dist.x < edgePickRadius) {
-        closestEdgeDistance = dist.x;
-    } else if (dist.y < edgePickRadius) {
-        closestEdgeDistance = dist.y;
-    } else if (dist.z < edgePickRadius) {
-        closestEdgeDistance = dist.z;
-    } else if (dist.w < edgePickRadius) {
-        closestEdgeDistance = dist.w;
-    } else {
-        return 0;
-    }
-
-    return SelectedEdgeFalloff(closestEdgeDistance);
-}
-
-// called from hdx/renderPass.glslfx and selection.glslfx
-int GetPrimitiveEdgeId()
-{
-    //               e2
-    //     (0,1) 3 ------ 2 (1,1)
-    //           |        |
-    //       e3  |        |  e1
-    //           |        |
-    //     (0,0) 0 ------ 1 (1,0)
-    //               e0
-
-    int edgeId = -1;
-
-    vec4 dist = ComputeBaseFaceEdgeDistanceQuad();
-    if (dist.x < edgePickRadius) {
-        edgeId = 0;
-    } else if (dist.y < edgePickRadius) {
-        edgeId = 1;
-    } else if (dist.z < edgePickRadius) {
-        edgeId = 2;
-    } else if (dist.w < edgePickRadius) {
-        edgeId = 3;
-    } else {
-        return -1; // Not on a mesh edge
-    }
-
-    const int edgeFlag = GetEdgeFlag();
-    const ivec2 meshEdgeIndices = HdGet_edgeIndices();
-
-    // Translate face-edge to authored mesh-edge
-    if (edgeFlag == 0) {
-        edgeId = meshEdgeIndices[0] + edgeId; // regular quad face
-    } else if (edgeId == 0) {
-        edgeId = meshEdgeIndices[0];
-    } else if (edgeId == 3) {
-        edgeId = meshEdgeIndices[1];
-    } else {
-        edgeId = -1; // Not an authored mesh edge
-    }
-    return edgeId;
-}

package/staging_area/Blender/blender.shared/usd/hdSt/resources/shaders/fallbackLighting.glslfx

@@ -1,59 +0,0 @@
--- glslfx version 0.1
-
-//
-// Copyright 2016 Pixar
-//
-// Licensed under the terms set forth in the LICENSE.txt file available at
-// https://openusd.org/license.
-//
-
---- This is what an import might look like.
---- #import $TOOLS/hdSt/shaders/fallbackLighting.glslfx
-
---- --------------------------------------------------------------------------
--- glsl Fallback.LightIntegrator
-#ifndef HD_HAS_integrateLights
-#define HD_HAS_integrateLights
-#endif
-
-struct LightingContribution {
-    vec3 diffuse;
-};
-
-struct LightingInterfaceProperties {
-    float unused;
-};
-
-LightingContribution
-integrateLightsDefault(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
-{
-    vec3 n = normalize(Neye);
-
-    LightingContribution result;
-    result.diffuse = vec3(dot(n, vec3(0,0,1)));
-
-    return result;
-}
-
-LightingContribution
-integrateLightsConstant(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
-{
-    LightingContribution result;
-    //pefectly diffuse white hemisphere contribution
-    result.diffuse = vec3(1);
-
-    return result;
-}
-
--- glsl Fallback.Lighting
-
-FORWARD_DECL(
-    LightingContribution integrateLights(vec4 Peye, vec3 Neye,
-        LightingInterfaceProperties props));
-
-vec3 FallbackLighting(in vec3 Peye, in vec3 Neye, in vec3 color)
-{
-    LightingInterfaceProperties props;
-    LightingContribution light = integrateLights(vec4(Peye, 1), Neye, props);
-    return color * light.diffuse;
-}

package/staging_area/Blender/blender.shared/usd/hdSt/resources/shaders/fallbackLightingShader.glslfx

@@ -1,27 +0,0 @@
--- glslfx version 0.1
-
-//
-// Copyright 2016 Pixar
-//
-// Licensed under the terms set forth in the LICENSE.txt file available at
-// https://openusd.org/license.
-//
-
---- This is what an import might look like.
---- #import $TOOLS/hdSt/shaders/fallbackLightingShader.glslfx
-
-#import $TOOLS/hdSt/shaders/fallbackLighting.glslfx
-
--- configuration
-{
-    "techniques": {
-        "default": {
-            "fragmentShader" : {
-                "source": [ 
-                   "Fallback.LightIntegrator",
-                   "Fallback.Lighting"
-                ]
-            }
-        }
-    }
-}

package/staging_area/Blender/blender.shared/usd/hdSt/resources/shaders/fallbackMaterialNetwork.glslfx

@@ -1,47 +0,0 @@
--- glslfx version 0.1
-
-//
-// Copyright 2016 Pixar
-//
-// Licensed under the terms set forth in the LICENSE.txt file available at
-// https://openusd.org/license.
-//
-
---- This is what an import might look like.
---- #import $TOOLS/hdSt/shaders/fallbackMaterialNetwork.glslfx
-
----
---- The fallback shader is used as a replacement shader if no material binding
---- was provided. It needs to define both the surfaceShader() and
---- displacementShader() terminals.
----
--- configuration
-{
-    "techniques": {
-        "default": {
-            "displacementShader": {
-                "source": [ "Fallback.Displacement" ]
-            },
-            "surfaceShader": {
-                "source": [ "Fallback.Surface" ]
-            }
-        }
-    }
-}
-
---- --------------------------------------------------------------------------
--- glsl Fallback.Surface
-
-vec4 surfaceShader(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
-{
-    // lighting
-    color.rgb = FallbackLighting(Peye.xyz, Neye, color.rgb);
-    return color;
-}
---- --------------------------------------------------------------------------
--- glsl Fallback.Displacement
-
-vec4 displacementShader(int index, vec4 Peye, vec3 Neye, vec4 patchCoord)
-{
-    return Peye;
-}