@tushar-br/editing-pack 1.0.194 → 1.0.195

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

@@ -0,0 +1,53 @@
+-- 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/renderPassShader.glslfx
+
+#import $TOOLS/hdSt/shaders/renderPass.glslfx
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "vertexShader" : {
+                "source": [ "RenderPass.Camera",
+                            "RenderPass.ApplyClipPlanes" ]
+            },
+            "postTessControlShader": {
+                "source": [ "RenderPass.Camera" ]
+            },
+            "postTessVertexShader": {
+                "source": [ "RenderPass.Camera",
+                            "RenderPass.ApplyClipPlanes" ]
+            },
+            "tessControlShader" : {
+                "source": [ "RenderPass.Camera" ]
+            },
+            "tessEvalShader" : {
+                "source": [ "RenderPass.Camera",
+                            "RenderPass.ApplyClipPlanes" ]
+            },
+            "geometryShader" : {
+                "source": [ "RenderPass.Camera",
+                            "RenderPass.ApplyClipPlanes" ]
+            },
+            "fragmentShader" : {
+                "source": [ "RenderPass.Camera",
+                            "RenderPass.CameraFS",
+                            "RenderPass.NoSelection",
+                            "RenderPass.ApplyColorOverrides",
+                            "RenderPass.RenderColor",
+                            "RenderPass.RenderIdNoOp",
+                            "RenderPass.RenderNeyeNoOp",
+                            "RenderPass.RenderOutput"]
+            }
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+-- 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/simpleLightingShader.glslfx
+
+#import $TOOLS/glf/shaders/pcfShader.glslfx
+#import $TOOLS/glf/shaders/simpleLighting.glslfx
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "fragmentShader" : {
+                "source": [
+                    "PCF.ShadowFilterFragmentOnly",
+                    "SimpleLighting.LightIntegrator",
+                    "SimpleLighting.SimpleLighting",
+                    "LightingOverride.SimpleLighting"
+                ]
+            }
+        }
+    }
+}
+
+-- glsl LightingOverride.SimpleLighting
+
+vec3 FallbackLighting(in vec3 Peye, in vec3 Neye, in vec3 color)
+{
+    return simpleLightingMaterial(
+        vec4(color,1), 
+        vec4(Peye,1), 
+        Neye, 
+        vec4(1)).rgb;
+}

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

@@ -0,0 +1,80 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2023 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+
+
+--- --------------------------------------------------------------------------
+-- glsl SurfaceHelpers.Lighting
+
+#define PI 3.1415
+vec2 ProjectToLatLong(vec3 sample3D)
+{
+    // project spherical coord onto latitude-longitude map with
+    // latitude: +y == pi/2 and longitude: +z == 0, +x == pi/2
+    float x = (atan(sample3D.z, sample3D.x) + 0.5 * PI) / (2.0 * PI);
+    float y = acos(sample3D.y) / PI;
+
+    return vec2(x,y);
+}
+
+
+--- --------------------------------------------------------------------------
+-- glsl SurfaceHelpers.TangentSpace
+
+// Calculation of TBN matrix and terminology based on "Surface 
+// Gradient-Based Bump Mapping Framework" (2020)
+mat3
+ComputeTBNMatrix(vec3 P, vec3 N, vec2 st)
+{
+    // Get screen space derivatives of position
+    vec3 dPdx = dFdx(P);
+    vec3 dPdy = dFdy(P);
+
+    // Ensure position derivatives are perpendicular to N
+    vec3 sigmaX = dPdx - dot(dPdx, N) * N;
+    vec3 sigmaY = dPdy - dot(dPdy, N) * N;
+
+    float flipSign = dot(dPdy, cross(N, dPdx)) < 0 ? -1 : 1;
+
+    // Get screen space derivatives of st
+    vec2 dSTdx = dFdx(st);
+    vec2 dSTdy = dFdy(st);
+
+    // Get determinant and determinant sign of st matrix
+    float det = dot(dSTdx, vec2(dSTdy.y, -dSTdy.x));
+    float signDet = det < 0 ? -1 : 1;
+
+    // Get first column of inv st matrix
+    // Don't divide by det, but scale by its sign
+    vec2 invC0 = signDet * vec2(dSTdy.y, -dSTdx.y);
+
+    vec3 T = sigmaX * invC0.x + sigmaY * invC0.y;
+
+    if (abs(det) > 0) {
+        T = normalize(T);
+    }
+
+    vec3 B = (signDet * flipSign) * cross(N, T);
+
+    return mat3(T, B, N);
+}
+
+vec3
+ComputeTangentVector(vec3 P, vec3 N, vec2 st)
+{
+    mat3 TBN = ComputeTBNMatrix(P, N, st);
+    return TBN[0];
+}
+
+vec3
+PerturbNormal(vec3 P, vec3 N, vec2 st, vec3 Nt)
+{
+    mat3 TBN = ComputeTBNMatrix(P, N, st);
+    return normalize(TBN * Nt);
+}

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

@@ -0,0 +1,458 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2017 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/terminals.glslfx
+
+--- --------------------------------------------------------------------------
+-- glsl Geometry.CustomDisplacement
+
+FORWARD_DECL(
+    vec4 displacementShader(int index, vec4 Peye, vec3 Neye, vec4 patchCoord));
+
+vec4 DisplacementTerminal(int index, vec4 Peye, vec3 Neye, vec4 patchCoord)
+{
+    return displacementShader(index, Peye, Neye, patchCoord);
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Geometry.NoCustomDisplacement
+
+vec4 DisplacementTerminal(int index, vec4 Peye, vec3 Neye, vec4 patchCoord)
+{
+    return Peye;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.CommonTerminals
+
+struct ReprStyle
+{
+    vec4  color;
+    bool  usePrimvarColor;
+    bool  usePrimvarAlpha;
+    bool  applyColorOverride;
+    bool  useSurfaceShaderColor;
+    bool  useSurfaceShaderAlpha;
+};
+
+struct ScalarOverride
+{
+    bool enabled;
+    vec3 color;
+};
+
+FORWARD_DECL(ReprStyle GetReprStyle());
+FORWARD_DECL(ScalarOverride GetScalarOverride());
+FORWARD_DECL(
+    vec4 surfaceShader(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord));
+FORWARD_DECL(vec4 postSurfaceShader(vec4 Peye, vec3 Neye, vec4 color));
+
+vec4 ShadingTerminal(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
+{
+    ReprStyle reprStyle = GetReprStyle();
+    
+    // Apply scalar override.
+    ScalarOverride scalarOverride = GetScalarOverride();
+    if (scalarOverride.enabled) {
+        vec4 result;
+        
+        result.rgb = scalarOverride.color;
+        result.a   = reprStyle.usePrimvarAlpha ? color.a: reprStyle.color.a;
+
+        vec4 colorOverride = ApplyColorOverrides(result);
+        result = reprStyle.applyColorOverride ? colorOverride : result;
+
+        return result;
+    }
+
+    // Draw mode can override face color
+    vec4 reprColor;
+    
+    reprColor.rgb = reprStyle.usePrimvarColor ? color.rgb : reprStyle.color.rgb;
+    reprColor.a   = reprStyle.usePrimvarAlpha ? color.a   : reprStyle.color.a; 
+
+    // Compute color overrides
+    vec4 colorOverride = ApplyColorOverrides(reprColor);
+    reprColor = reprStyle.applyColorOverride ? colorOverride : reprColor;
+    
+
+    // Surface shading can be expensive and also can contain undesirable
+    // side effects (like discards).  So only run it for reprs that require it.
+
+    if (reprStyle.useSurfaceShaderColor ||
+        reprStyle.useSurfaceShaderAlpha) {
+        vec4 shadingColor;
+
+        shadingColor = surfaceShader(Peye,
+                                     Neye,
+                                     reprColor,
+                                     patchCoord);
+
+#ifdef HD_HAS_postSurfaceShader
+        shadingColor = postSurfaceShader(Peye,
+                                         Neye,
+                                         shadingColor);
+#endif
+
+        // Modify the shaded color by camera exposure.
+        shadingColor.rgb *= GetLinearExposure();
+    
+        reprColor.rgb = reprStyle.useSurfaceShaderColor ? 
+                        shadingColor.rgb :
+                        reprColor.rgb;
+                        
+        reprColor.a   = reprStyle.useSurfaceShaderAlpha ? 
+                        shadingColor.a :
+                        reprColor.a;
+    }
+
+    vec4 baseColor = color;
+    baseColor = ApplyColorOverrides(baseColor);
+    
+    vec4 litColor = mix(baseColor,
+                        reprColor,
+                        GetLightingBlendAmount());
+
+    // Final overrides.
+
+    return ApplyColorOverridesPostLighting(litColor); 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.Surface
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsDefault(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = vec4(0.0, 0.0, 0.0, 1.0);
+    reprStyle.usePrimvarColor          = true;
+    reprStyle.usePrimvarAlpha          = true;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = true;
+    reprStyle.useSurfaceShaderAlpha    = true;
+    
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.SurfaceUnlit
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsConstant(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = vec4(0.0, 0.0, 0.0, 1.0);
+    reprStyle.usePrimvarColor          = true;
+    reprStyle.usePrimvarAlpha          = true;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = true;
+    reprStyle.useSurfaceShaderAlpha    = true;
+    
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.SurfaceSheer
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsConstant(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    // shade only every 2nd pixel in x and y
+    // creating a thin stippled mesh grid 
+    float factor = step(0.5, fract((gl_FragCoord.x + 1.0) * 0.5))
+                 * step(0.5, fract((gl_FragCoord.y + 0.0) * 0.5));
+    
+    // make the surface translucent so that the lines of
+    // the mesh edges are visible even from the back faces.
+    float alpha = 0.2 * (1.0 - factor);
+
+
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = vec4(0.0, 0.0, 0.0, alpha);
+    reprStyle.usePrimvarColor          = true;
+    reprStyle.usePrimvarAlpha          = false;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = true;
+    reprStyle.useSurfaceShaderAlpha    = false;
+    
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.SurfaceOutline
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsConstant(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = vec4(0.0, 0.0, 0.0, 1.0);
+    reprStyle.usePrimvarColor          = false;
+    reprStyle.usePrimvarAlpha          = false;
+    reprStyle.applyColorOverride       = false;
+    reprStyle.useSurfaceShaderColor    = false;
+    reprStyle.useSurfaceShaderAlpha    = false;
+    
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.ConstantColor
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsConstant(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = vec4(0.0, 0.0, 0.0, 1.0);
+    reprStyle.usePrimvarColor          = true;
+    reprStyle.usePrimvarAlpha          = true;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = false;
+    reprStyle.useSurfaceShaderAlpha    = false;
+
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.HullColor
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsConstant(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    vec4 hullColor = vec4(vec3(0.18), 1.0);
+
+#if defined(HD_HAS_selectedWeight)
+    float weight = clamp(HdGet_selectedWeight(), 0.0, 1.0);
+
+    if (weight <= 0.0) {
+        discard;
+    }
+
+    // The three control points of the quadratic curve for the selection color
+    // with the binomial coefficient premultiplied in.
+    // constant  :      1
+    // linear    :    1   1
+    // quadratic :  1   2   1
+    vec3 c0 = vec3(0.0, 0.0, 0.0); // 1.0 * Black
+    vec3 c1 = vec3(2.0, 0.0, 0.0); // 2.0 * Red
+    vec3 c2 = vec3(1.0, 1.0, 0.0); // 1.0 * Yellow
+    
+    // de Casteljau quadratic curve interpolation
+    // A recursive application of lerp ('mix' in glsl) reducing the order each
+    // step of the recursion. 
+    //  at weight = 0.0  we get c0
+    //  at weight = 0.5  we get c0 * .25 + c1 * 0.5 + c2 *.25
+    //  at weight = 1.0  we get c2
+    // Thus it is a smooth curve going from c0 to c2 bending towards c1
+    hullColor.rgb = mix(mix(c0, c1, weight),
+                        mix(c1, c2, weight), weight);
+
+#else
+#if defined(HD_HAS_hullColor)
+    hullColor.rgb = HdGet_hullColor();
+#endif
+#if defined(HD_HAS_hullOpacity)
+    hullColor.a = HdGet_hullOpacity();
+#endif
+#endif
+
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = hullColor;
+    reprStyle.usePrimvarColor          = false;
+    reprStyle.usePrimvarAlpha          = false;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = false;
+    reprStyle.useSurfaceShaderAlpha    = false;
+    
+    return reprStyle;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.PointColor
+
+#ifdef HD_HAS_integrateLights
+#ifndef HD_HAS_definedIntegrateLights
+#define HD_HAS_definedIntegrateLights
+
+LightingContribution
+integrateLights(vec4 Peye, vec3 Neye, LightingInterfaceProperties props)
+{
+    return integrateLightsConstant(Peye, Neye, props);
+}
+
+#endif // HD_HAS_definedIntegrateLights
+#endif
+
+ReprStyle GetReprStyle()
+{
+    vec4 pointColor = vec4(vec3(0.18), 1.0);
+#if defined(HD_HAS_pointColor)
+    pointColor = HdGet_pointColor();
+#endif
+
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = pointColor;
+    reprStyle.usePrimvarColor          = false;
+    reprStyle.usePrimvarAlpha          = false;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = false;
+    reprStyle.useSurfaceShaderAlpha    = false;
+    
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.PointShaded
+
+ReprStyle GetReprStyle()
+{
+    vec4 pointColor = vec4(vec3(0.18), 1.0);
+#if defined(HD_HAS_pointColor)
+    pointColor = HdGet_pointColor();
+#endif
+
+    ReprStyle reprStyle;
+    
+    reprStyle.color                    = pointColor;
+    reprStyle.usePrimvarColor          = false;
+    reprStyle.usePrimvarAlpha          = false;
+    reprStyle.applyColorOverride       = true;
+    reprStyle.useSurfaceShaderColor    = true;
+    reprStyle.useSurfaceShaderAlpha    = true;
+    
+    return reprStyle; 
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.ScalarOverride
+
+ScalarOverride GetScalarOverride()
+{
+    ScalarOverride result;
+
+#if defined(HD_HAS_scalarOverride)
+    result.enabled = true;
+
+    // Allow a scalar value to override the color from the surface
+    // for previewing heatmaps. This is useful for editing workflows.
+#if defined(HD_HAS_scalarOverrideColorRamp)
+    int rampCount = constantPrimvars[GetDrawingCoord().constantCoord].
+                scalarOverrideColorRamp.length();
+    float scalar = HdGet_scalarOverride() * float(rampCount - 1);
+    float baseIndex = floor(scalar);
+    float nextIndex = min(float(rampCount - 1), baseIndex + 1.0);
+    float interp = scalar - baseIndex;
+    result.color = mix(HdGet_scalarOverrideColorRamp(int(baseIndex)).rgb,
+                       HdGet_scalarOverrideColorRamp(int(nextIndex)).rgb,
+                       interp);
+#else
+    // If no ramp is given just gamma correct the scalar as greyscale.
+    result.color = vec3(pow(HdGet_scalarOverride(), 2.2));
+#endif // HD_HAS_scalarOverrideColorRamp
+
+#else // HD_HAS_scalarOverride
+    result.enabled = false;
+    result.color   = vec3(0.0, 0.0, 0.0); 
+#endif
+
+    return result;
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Fragment.NoScalarOverride
+
+ScalarOverride GetScalarOverride()
+{
+    ScalarOverride result;
+    
+    result.enabled = false;
+    result.color   = vec3(0.0, 0.0, 0.0); 
+
+    return result;    
+}

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

@@ -0,0 +1,80 @@
+-- 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/visibility.glslfx
+
+--- --------------------------------------------------------------------------
+-- glsl Visibility.Fragment.Fallback
+void DiscardBasedOnTopologicalVisibility()
+{
+    // Nothing to do, since there's no authored opinion.
+}
+
+--- --------------------------------------------------------------------------
+-- glsl Visibility.Fragment.Topology
+
+FORWARD_DECL(int GetElementID()); // code gen
+
+void GetBitmaskBufferIndices(
+    int id, REF(thread, int) arrayIndex, REF(thread, int) bitIndex)
+{
+    arrayIndex = id / 32;
+    bitIndex   = id % 32;
+}
+
+bool IsBitSet(uint bitmask, int bitIndex)
+{
+    return bool(bitmask & (1 << bitIndex));
+}
+
+bool IsElementVisible()
+{
+#if defined(HD_HAS_elementsVisibility)
+    // Element (face) visibility is encoded as an array of bitmasks (uint32)
+    // with 1 bit per authored face.
+    int elementId = GetElementID();
+    // When rendering a mesh as points, element id doesn't make sense. Code
+    // gen returns -1 as a fallback for this case.
+    if (elementId != -1) {
+        int arrayIndex, bitIndex;
+        GetBitmaskBufferIndices(elementId, arrayIndex, bitIndex);
+        uint ev = HdGet_elementsVisibility(arrayIndex);
+        return IsBitSet(ev, bitIndex);
+    }
+#endif
+    return true;
+}
+
+FORWARD_DECL(int GetPointId()); // pointId.glslfx
+
+bool IsPointVisible()
+{
+#if defined(HD_HAS_pointsVisibility)
+    // Point visibility is encoded as an array of bitmasks (uint32) with 1 bit
+    // per unrefined vertex.
+    int pointId = GetPointId();
+    // When *not* rendering a mesh as points, we return -1 for the point id.
+    // See PointId.Fragment.Fallback
+    if (pointId != -1) {
+        int arrayIndex, bitIndex;
+        GetBitmaskBufferIndices(pointId, arrayIndex, bitIndex);
+        uint pv = HdGet_pointsVisibility(arrayIndex);
+        return IsBitSet(pv, bitIndex);
+    }
+#endif
+    return true;
+}
+
+void DiscardBasedOnTopologicalVisibility()
+{
+    if (!IsElementVisible() || !IsPointVisible()) {
+        discard;
+    }
+}