@tushar-br/editing-pack 1.0.195 → 1.0.196

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

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

@@ -1,201 +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/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

@@ -1,326 +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/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

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