@tushar-br/editing-pack 1.0.195 → 1.0.196

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

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

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

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

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

@@ -1,80 +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/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;
-    }
-}