@tushar-br/editing-pack 1.0.194 → 1.0.195

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

@@ -0,0 +1,40 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2020 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/meshFaceCull.glslfx
+
+
+--- --------------------------------------------------------------------------
+-- glsl MeshFaceCull.Fragment.None
+
+void DiscardBasedOnShading(bool frontFacing, bool isFlipped)
+{
+    // Nothing to do since h/w face culling is used.
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshFaceCull.Fragment.FrontFacing
+
+void DiscardBasedOnShading(bool frontFacing, bool isFlipped)
+{
+    if (frontFacing != isFlipped) {
+        discard;
+    }
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshFaceCull.Fragment.BackFacing
+
+void DiscardBasedOnShading(bool frontFacing, bool isFlipped)
+{
+    if ((!frontFacing) != isFlipped) {
+        discard;
+    }
+}

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

@@ -0,0 +1,201 @@
+-- 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/meshNormal.glslfx
+
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Scene
+
+vec3 GetNormal(vec3 Neye, int index)
+{
+    vec3 normal = vec3(0);
+#if defined(HD_HAS_normals)
+    normal = vec3(HdGet_normals(index).xyz);
+#endif
+
+    MAT4 transformInv = ApplyInstanceTransformInverse(HdGet_transformInverse());
+    normal = vec4(transpose(transformInv * GetWorldToViewInverseMatrix()) *
+                  vec4(normal,0)).xyz;
+
+    if (length(normal) > 0.0)
+        normal = normalize(normal);
+    return normal;
+}
+
+vec3 GetNormal(vec3 Neye, int index, vec2 localST)
+{
+    return GetNormal(Neye, index);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Scene.Patches
+
+vec3 GetNormal(vec3 Neye, int index, vec2 localST)
+{
+    vec3 normal = vec3(0);
+#if defined(HD_HAS_normals)
+    normal = vec3(HdGet_normals(index, localST).xyz);
+#endif
+
+    MAT4 transformInv = ApplyInstanceTransformInverse(HdGet_transformInverse());
+    normal = vec4(transpose(transformInv * GetWorldToViewInverseMatrix()) *
+                  vec4(normal,0)).xyz;
+
+    if (length(normal) > 0.0)
+        normal = normalize(normal);
+    return normal;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Smooth
+
+vec3 GetNormal(vec3 Neye, int index)
+{
+    vec3 normal = vec3(0);
+#if defined(HD_HAS_smoothNormals)
+    normal = vec3(HdGet_smoothNormals(index).xyz);
+#elif defined(HD_HAS_packedSmoothNormals)
+    normal = vec3(HdGet_packedSmoothNormals(index).xyz);
+#endif
+
+    MAT4 transformInv = ApplyInstanceTransformInverse(HdGet_transformInverse());
+    normal = vec4(transpose(transformInv * GetWorldToViewInverseMatrix()) *
+                  vec4(normal,0)).xyz;
+
+    if (length(normal) > 0.0)
+        normal = normalize(normal);
+    return normal;
+}
+
+vec3 GetNormal(vec3 Neye, int index, vec2 localST)
+{
+    return GetNormal(Neye, index);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Flat
+
+vec3 GetNormal(vec3 Neye, int index)
+{
+    vec3 normal = vec3(0);
+#if defined(HD_HAS_flatNormals)
+    normal = vec3(HdGet_flatNormals(index).xyz);
+#elif defined(HD_HAS_packedFlatNormals)
+    normal = vec3(HdGet_packedFlatNormals(index).xyz);
+#endif
+
+    MAT4 transformInv = ApplyInstanceTransformInverse(HdGet_transformInverse());
+    normal = vec4(transpose(transformInv * GetWorldToViewInverseMatrix()) *
+                  vec4(normal,0)).xyz;
+
+    if (length(normal) > 0.0)
+        normal = normalize(normal);
+    return normal;
+}
+
+vec3 GetNormal(vec3 Neye, int index, vec2 localST)
+{
+    return GetNormal(Neye, index);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Fragment.ScreenSpace
+
+FORWARD_DECL(vec3 ComputeScreenSpaceNeye());
+
+vec3 GetNormal(vec3 Neye, int index)
+{
+    return ComputeScreenSpaceNeye();
+}
+
+vec3 GetNormal(vec3 Neye, int index, vec2 localST)
+{
+    return GetNormal(Neye, index);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Pass
+
+vec3 GetNormal(vec3 Neye, int index)
+{
+    return Neye;
+}
+
+vec3 GetNormal(vec3 Neye, int index, vec2 localST)
+{
+    return GetNormal(Neye, index);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Geometry.Flat
+
+vec3 GetTriGeometryNormal(vec3 Neye, vec4 Peye0, vec4 Peye1, vec4 Peye2,
+                          bool isFlipped)
+{
+    // ignore vertex normal and compute flat facing normal
+    vec3 n = normalize(cross(Peye1.xyz - Peye0.xyz, Peye2.xyz - Peye0.xyz));
+    return isFlipped ? -n : n;
+}
+
+vec3 GetQuadGeometryNormal(vec3 Neye,
+                           vec4 Peye0, vec4 Peye1, vec4 Peye2, vec4 Peye3,
+                           bool isFlipped)
+{
+    //  0---3
+    //  |.  |
+    //  | . |
+    //  |  .|
+    //  1---2
+    // ignore vertex normal and compute flat facing normal
+    // average diagonal cross products to deal with co-linear edges
+    vec3 A0 = Peye2.xyz - Peye3.xyz;
+    vec3 B0 = Peye0.xyz - Peye3.xyz;
+    vec3 A1 = Peye0.xyz - Peye1.xyz;
+    vec3 B1 = Peye2.xyz - Peye1.xyz;
+    vec3 n = normalize(cross(B0, A0) + cross(B1, A1));
+    return isFlipped ? -n : n;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Geometry.NoFlat
+
+vec3 GetTriGeometryNormal(vec3 Neye, vec4 Peye0, vec4 Peye1, vec4 Peye2,
+                          bool isFlipped)
+{
+    return Neye;
+}
+
+vec3 GetQuadGeometryNormal(vec3 Neye,
+                           vec4 Peye0, vec4 Peye1, vec4 Peye2, vec4 Peye3,
+                           bool isFlipped)
+{
+    return Neye;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Fragment.SingleSided
+
+vec3 GetShadingNormal(vec3 N, bool isFlipped)
+{
+    // the fragment shader takes already-flipped-normals.
+    // no need to flip here.
+    return N;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshNormal.Fragment.DoubleSided
+
+vec3 GetShadingNormal(vec3 N, bool isFlipped)
+{
+    // note that negative scaling isn't taken into account in gl_FrontFacing
+    // so we have to consider isFlipped here too.
+    return (isFlipped != gl_FrontFacing) ? N : -N;
+}

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

@@ -0,0 +1,326 @@
+-- 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/meshWire.glslfx
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeMaskTriangle
+
+vec3 GetPrimitiveEdgeMask()
+{
+    // A value of one in this mask hides the corresponding edge.
+    // (See hd/meshUtil.cpp)
+    return vec3(0, GetEdgeFlag() & 1, GetEdgeFlag() & 2);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeMaskQuad
+
+vec3 GetPrimitiveEdgeMask()
+{
+    // A value of one in this mask hides the corresponding edge.
+    // (See hd/meshUtil.cpp)
+    return vec3(GetEdgeFlag() != 0, 1, 0);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeMaskTriQuad
+
+vec3 GetPrimitiveEdgeMask()
+{
+    // A value of one in this mask hides the corresponding edge.
+    // (See hd/meshUtil.cpp)
+    if (GetTriQuadID() == 0) {
+        return vec3(GetEdgeFlag() != 0, 1, 0);
+    } else {
+        return vec3(0, 1, GetEdgeFlag() != 0);
+    }
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeMaskRefinedQuad
+
+vec3 GetPrimitiveEdgeMask()
+{
+    // Hide the common edge between the pair of rasterized triangles.
+    return vec3(0,1,0);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeMaskNone
+
+vec3 GetPrimitiveEdgeMask()
+{
+    return vec3(0);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeCommon
+
+// Returns the distance of the current fragment (in viewport pixel units) from
+// the nearest edge.
+float GetMinEdgeDistance()
+{
+    // Hide triangle edges by adding edge mask.
+    vec3 param = GetEdgeCoord() + GetPrimitiveEdgeMask();
+    vec3 edgeDistance = max(vec3(0.0), param / fwidth(param));
+    return min(edgeDistance.x,
+               min(edgeDistance.y,
+                   edgeDistance.z));
+}
+
+// Use edge distance to compute a smooth opacity falloff for good looking edges.
+float GetEdgeFalloff(float d) {
+    return exp2(-4 * d * d);
+}
+
+float GetEdgeOpacity() {
+    return GetEdgeFalloff(GetMinEdgeDistance());
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeTriQuadPTVS
+
+// Returns the distance of the current fragment (in viewport pixel units) from
+// the nearest edge.
+float GetMinEdgeDistance()
+{
+    vec2 leftBottom = GetEdgeCoord().xy;
+    vec2 rightTop = vec2(1.0) - leftBottom;
+
+    vec4 param = vec4(leftBottom.y, rightTop.x, rightTop.y, leftBottom.x);
+    vec4 edgeDistance = max(vec4(0.0), param / fwidth(param));
+
+    // Hide internal edges introduced by quadrangulation
+    if (GetEdgeFlag() != 0) edgeDistance.yz += vec2(2.0);
+
+    return min(min(edgeDistance.x, edgeDistance.y),
+               min(edgeDistance.z, edgeDistance.w));
+}
+
+// Use edge distance to compute a smooth opacity falloff for good looking edges.
+float GetEdgeFalloff(float d) {
+    return exp2(-4 * d * d);
+}
+
+float GetEdgeOpacity() {
+    return GetEdgeFalloff(GetMinEdgeDistance());
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeParam
+
+vec3 GetEdgeParamTriangle()
+{
+    // Expand barycentric coordinates
+    vec2 param = GetPatchCoord(0).xy;
+    vec3 barycentric = vec3(param.x, param.y, 1 - param.x - param.y);
+
+    // Match triangle edge order
+    return barycentric.yzx;
+}
+
+vec3 GetEdgeDistanceTriangle()
+{
+    vec3 param = GetEdgeParamTriangle();
+    return max(vec3(0.0), param / fwidth(param));
+}
+
+vec4 GetEdgeParamQuad()
+{
+    // Expand coordinates to opposite corners of quad
+    vec2 leftBottom = GetPatchCoord(0).xy;
+    vec2 rightTop = vec2(1.0) - leftBottom;
+
+    // Match quad edge order
+    return vec4(leftBottom.y, rightTop.x, rightTop.y, leftBottom.x);
+}
+
+vec4 GetEdgeDistanceQuad()
+{
+    vec4 param = GetEdgeParamQuad();
+    return max(vec4(0.0), param / fwidth(param));
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshPatchWire.Fragment.PatchEdgeTriangle
+
+// Override for subdivided faces to make the boundary of the face stand out.
+float GetEdgeOpacityForPatch()
+{
+    // Distance in pixels from triangle patch edges.
+    vec3 patchEdgeDistance = GetEdgeDistanceTriangle();
+
+    const float patchEdgeMinDistance =
+        min(patchEdgeDistance.x, min(patchEdgeDistance.y, patchEdgeDistance.z));
+
+    // Reduce the opacity of edges not on patch boundaries
+    if (patchEdgeMinDistance > 1.0) {
+        return 0.3 * GetEdgeOpacity();
+    }
+
+    // Use distance to patch edge rather than distance to primitive edge
+    return GetEdgeFalloff(patchEdgeMinDistance);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshPatchWire.Fragment.PatchEdgeQuad
+
+// Override for subdivided faces to make the boundary of the face stand out.
+float GetEdgeOpacityForPatch()
+{
+    // Distance in pixels from quad patch edges.
+    vec4 patchEdgeDistance = GetEdgeDistanceQuad();
+
+    // Hide sub-patch internal edges introduced by quadrangulation
+    if (GetEdgeFlag() != 0) patchEdgeDistance.yz += vec2(2.0);
+
+    const float patchEdgeMinDistance =
+        min(min(patchEdgeDistance.x, patchEdgeDistance.y),
+            min(patchEdgeDistance.z, patchEdgeDistance.w));
+
+    // Reduce the opacity of edges not on patch boundaries
+    if (patchEdgeMinDistance > 1.0) {
+        return 0.3 * GetEdgeOpacity();
+    }
+
+    // Use distance to patch edge rather than distance to primitive edge
+    return GetEdgeFalloff(patchEdgeMinDistance);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.FinalEdgeOpacityNoForce
+
+vec4 ApplyFinalEdgeOpacity(vec4 Cfill, float p)
+{
+    return Cfill;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.FinalEdgeOpacityForce
+
+vec4 ApplyFinalEdgeOpacity(vec4 Cfill, float p)
+{
+    Cfill.a = mix(Cfill.a, 1, p);
+    return Cfill;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.NoEdge
+
+vec4 ApplyEdgeColor(vec4 Cfill, vec4 patchCoord)
+{
+    return Cfill;
+}
+
+// Return a large value, signifying that the fragment isn't near an edge.
+float GetMinEdgeDistance()
+{
+    return 1000.0;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeOnSurface
+
+vec4 ApplyEdgeColor(vec4 Cfill, vec4 patchCoord)
+{
+    float p = GetEdgeOpacity();
+    
+    vec4 wireColor = GetWireframeColor();
+    
+    // If wireColor is unset (zero), the fill color is just dimmed a bit.
+    if (all(equal(wireColor, vec4(0)))) wireColor.a = 0.5;
+
+    vec4 Cedge = vec4(mix(Cfill.rgb, wireColor.rgb, wireColor.a), 1);
+    Cfill.rgb = mix(Cfill.rgb, Cedge.rgb, p);
+
+    return ApplyFinalEdgeOpacity(Cfill, p);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeOnlyBlendColor
+
+vec4 ApplyEdgeColor(vec4 Cfill, vec4 patchCoord)
+{
+    float p = GetEdgeOpacity();
+    if (p < 0.5) discard;
+
+    vec4 wireColor = GetWireframeColor();
+
+    // If wireColor is unset (zero), ignore it altogether
+    
+    Cfill.rgb = mix(Cfill.rgb, wireColor.rgb, wireColor.a);
+
+    return ApplyFinalEdgeOpacity(Cfill, p);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeOnlyNoBlend
+
+vec4 ApplyEdgeColor(vec4 Cfill, vec4 patchCoord)
+{
+    float p = GetEdgeOpacity();
+    if (p < 0.5) discard;
+
+    return ApplyFinalEdgeOpacity(Cfill, p);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeCoord.Barycentric
+
+vec3 GetEdgeCoord()
+{
+    return GetBarycentricCoord();
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeCoord.Tess
+
+vec2 GetEdgeCoord()
+{
+    return GetTessCoord();
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshWire.Fragment.EdgeCoord.TessTriangle
+
+vec3 GetEdgeCoord()
+{
+    return GetTessCoordTriangle();
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshPatchWire.Fragment.EdgeOnSurface
+
+vec4 ApplyEdgeColor(vec4 Cfill, vec4 patchCoord)
+{
+    float p = GetEdgeOpacityForPatch();
+    
+    vec4 wireColor = GetWireframeColor();
+
+    // If wireColor is unset (zero), the fill color is just dimmed a bit.
+    if (all(equal(wireColor, vec4(0)))) wireColor.a = 0.5;
+
+    vec4 Cedge = vec4(mix(Cfill.rgb, wireColor.rgb, wireColor.a), 1);
+    Cfill.rgb = mix(Cfill.rgb, Cedge.rgb, p);
+
+    return ApplyFinalEdgeOpacity(Cfill, p);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl MeshPatchWire.Fragment.EdgeOnly
+
+vec4 ApplyEdgeColor(vec4 Cfill, vec4 patchCoord)
+{
+    float p = GetEdgeOpacity();
+    if (p < 0.5) discard;
+
+    return ApplyFinalEdgeOpacity(Cfill, p);
+}

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

@@ -0,0 +1,66 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2021 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/overlayShader.glslfx
+
+---
+--- The fallback overlay shader is used as a replacement shader if the
+--- original material shader failed to compile. It needs to
+--- define both the surfaceShader() and displacementShader() terminals.
+---
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "displacementShader": {
+                "source": [ "Overlay.Displacement" ]
+            },
+            "surfaceShader": {
+                "source": [ "Overlay.Surface" ]
+            }
+        }
+    }
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Overlay.Surface
+
+vec4 surfaceShader(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
+{
+    float d = 1.0;
+    vec4 bg = vec4(0,0,0,1);
+
+#ifdef HD_HAS_depthReadback
+    d = texelFetch(HdGetSampler_depthReadback(), ivec2(gl_FragCoord.xy),
+        0).x;
+#endif
+
+#ifdef HD_HAS_colorReadback
+    bg = texelFetch(HdGetSampler_colorReadback(), ivec2(gl_FragCoord.xy),
+        0);
+#endif
+
+    vec4 colorOut = color;
+    if (d <= gl_FragCoord.z) {
+        const float showThroughAlpha = 0.3;
+        float adjAlpha = showThroughAlpha * color.a;
+        colorOut.rgb = color.rgb*adjAlpha + bg.rgb*bg.a*(1-adjAlpha);
+        colorOut.a = adjAlpha + bg.a*(1.0-adjAlpha);
+    }
+
+    return colorOut;
+}
+--- --------------------------------------------------------------------------
+-- glsl Overlay.Displacement
+
+vec4 displacementShader(int index, vec4 Peye, vec3 Neye, vec4 patchCoord)
+{
+    return Peye;
+}