@tushar-br/editing-pack 1.0.194 → 1.0.195

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

@@ -0,0 +1,280 @@
+-- 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

@@ -0,0 +1,237 @@
+-- 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

@@ -0,0 +1,59 @@
+-- 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

@@ -0,0 +1,27 @@
+-- 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

@@ -0,0 +1,47 @@
+-- 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;
+}