@tushar-br/editing-pack 1.0.195 → 1.0.196

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

@@ -1,103 +0,0 @@
--- glslfx version 0.1
-
-//
-// Copyright 2025 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/pointDisk.glslfx
-
---- --------------------------------------------------------------------------
--- glsl PointDisk.Vertex.PointSizeBias
-
-float ApplyPointSizeBias(float pointSize)
-{
-    if (pointSize <= 0) {
-        return 0;
-    }
-
-#ifdef HD_HAS_multisampleCount
-    const uint multisampleCount = HdGet_multisampleCount();
-#else
-    const uint multisampleCount = 1;
-#endif
-    if (multisampleCount == 1) {
-        return pointSize;
-    }
-
-    // Slightly enlarge the points as the input size reaches 1.
-    // This improves MSAA and prevents tiny point from disappearing
-    // when MSAA is disabled. Similar behaviour is observed when
-    // using native round points on Nvidia GPUs.
-    if (pointSize < 16.0) {
-        pointSize += (16.0 - pointSize) * 0.0825;
-    }
-
-    // We must enlarge the point ever so slightly to make
-    // sure that the rounding sample mask doesn't conflict
-    // with the input edge sample mask. We want our input
-    // sample mask to always be all 1s. This is compensated
-    // in the fragment shader.
-    pointSize += 0.5;
-
-    return pointSize;
-}
-
---- --------------------------------------------------------------------------
--- glsl PointDisk.Vertex.None
-
-float ApplyPointSizeBias(float pointSize)
-{
-    // do nothing
-    return pointSize;
-}
-
---- --------------------------------------------------------------------------
--- glsl PointDisk.Fragment.SampleMask
-
-void ApplyDiskSampleMask()
-{
-#ifdef HD_HAS_multisampleCount
-    const uint multisampleCount = HdGet_multisampleCount();
-#else
-    const uint multisampleCount = 1;
-#endif
-    if (multisampleCount == 1) {
-        hd_SampleMask = int(hd_SampleMaskIn);
-        return;
-    }
-
-    // By using the sample mask directly, don't depend on the
-    // alpha-to-coverage or multisampling state.
-
-    // We can ignore dFdy(gl_PointCoord.y) because on a
-    // square it's the same as dFdx(gl_PointCoord.x).
-    const float pointSize = 1.0 / dFdx(gl_PointCoord.x);
-    const float pointSdf = length(gl_PointCoord - 0.5) - 0.5;
-    // +0.25 to compensate for enlargement in the vertex shader.
-    const float pointSdfPx = pointSdf * pointSize + 0.25;
-    if (pointSdfPx < -1) {
-        // Inside disk edge
-        hd_SampleMask = int(hd_SampleMaskIn);
-    } else if (pointSdfPx > 0) {
-        // Outside disk
-        hd_SampleMask = 0;
-    } else {
-        // On the disk edge
-        const float edgeSdf = clamp(-pointSdfPx, 0.0, 1.0);
-        const int sampleCount = int(round(multisampleCount * edgeSdf));
-        hd_SampleMask =  (1 << sampleCount) - 1;
-    }
-}
-
---- --------------------------------------------------------------------------
--- glsl PointDisk.Fragment.None
-
-void ApplyDiskSampleMask()
-{
-    // do nothing
-}
-

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

@@ -1,87 +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/pointId.glslfx
-
-#import $TOOLS/hdx/shaders/selection.glslfx
-
---- --------------------------------------------------------------------------
--- glsl PointId.Vertex.None
-
-int GetPointId()
-{
-    return -1;
-}
-
-float GetPointRasterSize(int pointId)
-{
-    return GetPointSize();
-}
-
-void ProcessPointId(int pointId)
-{
-    // do nothing
-}
-
---- --------------------------------------------------------------------------
--- layout PointId.Vertex.PointParam
-
-# Plumb the pointId, for use in the FS.
-# XXX: This works only because the TES and GS stages are disabled when
-# rendering as points. If they are enabled, we need to add the plumbing.
-[
-    ["out", "int", "vsPointId", "flat"]
-]
-
---- --------------------------------------------------------------------------
--- glsl PointId.Vertex.PointParam
-
-// Fwd declare accessor method defined via code gen
-FORWARD_DECL(int GetBaseVertexOffset());
-int GetPointId()
-{
-    return int(hd_VertexID) - GetBaseVertexOffset();
-}
-
-// Fwd declare selection decoder method defined in hdx/shaders/selection.glslfx
-FORWARD_DECL(bool IsPointSelected(int));
-float GetPointRasterSize(int pointId)
-{
-    return IsPointSelected(pointId)? 
-                        GetPointSelectedSize() : GetPointSize();
-}
-
-void ProcessPointId(int pointId)
-{
-    vsPointId = pointId;
-}
-
---- --------------------------------------------------------------------------
--- glsl PointId.Fragment.Fallback
-
-int GetPointId()
-{
-    return -1;
-}
-
---- --------------------------------------------------------------------------
--- layout PointId.Fragment.PointParam
-
-[
-    ["in", "int", "vsPointId", "flat"]
-]
-
---- --------------------------------------------------------------------------
--- glsl PointId.Fragment.PointParam
-
-int GetPointId()
-{
-    return vsPointId;
-}

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

@@ -1,155 +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/points.glslfx
-
-#import $TOOLS/hdSt/shaders/instancing.glslfx
-#import $TOOLS/hdSt/shaders/terminals.glslfx
-#import $TOOLS/hdSt/shaders/pointId.glslfx
-#import $TOOLS/hdSt/shaders/pointDisk.glslfx
-
---- --------------------------------------------------------------------------
--- layout Point.Vertex
-
-[
-    ["out block", "VertexData", "outData",
-        ["vec4", "Peye"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl Point.Vertex
-
-// Fwd declare methods defined in pointId.glslfx, that are used below.
-FORWARD_DECL(int GetPointId());
-FORWARD_DECL(void ProcessPointId(int));
-
-// The approach used below transforms a unit diagonal vector by the provided
-// matrix and returns its length.
-// This works when the provided transform is computed from a chain of
-// transformations wherein the scale operation doesn't follow a rotation.
-// This is typically true with scene-graph hierachies wherein the parent nodes 
-// are rigid-body transformations.
-//
-// When that isn't the case, this approach would result in scaling that is
-// coordinate-system dependent.
-// The accurate way to calculate the scale would be to compute the determinant.
-// 
-float ExtractAverageScaleFromMatrix(
-    MAT4 transform)
-{
-    const vec4 eyeScale = vec4(transform * normalize(vec4(1,1,1,0)));
-    return length(eyeScale.xyz);
-}
-
-
-// Compute the point size in pixels based on the authored width.
-float ComputeRasterPointSize(
-    MAT4 modelToWorldTransform, float eyeZ)
-{
-    // Check for primvar 'widths'. This is in model space.
-#if defined(HD_HAS_widths)
-    float modelWidth = HdGet_widths();
-#else
-    float modelWidth = 1.0;
-#endif
-
-    // Compute scaling from the modelToWorld and worldToView transforms.
-    const float modelToEyeScale =
-        ExtractAverageScaleFromMatrix(
-            GetWorldToViewMatrix() * modelToWorldTransform);
-
-    // Compute the scaling factor in X when transforming from eye space to NDC
-    // space. We want to know how much the x-value of the result of the
-    // perspective division varies as the x-value of the position (x,y,z,1) in
-    // eye space varies.
-    //
-    // With 'p' being the projection matrix and using row-major order, the
-    // x-value in NDC space is:
-    //
-    // (x * p[0][0] + y * p[1][0] + z * p[2][0] + 1 * p[3][0]) /
-    // (x * p[0][3] + y * p[1][3] + z * p[2][3] + 1 * p[3][3])
-    //
-    // The derivative with respect to x under the assumption that p[0][3] and 
-    // p[1][3] is zero (which is the case for perspective and orthographic
-    // projection) then simply is p[0][0] / (z * p[2][3] + p[3][3]).
-    //
-    const MAT4 projMat = GetProjectionMatrix();
-    const float eyeToClipXScale = float(projMat[0][0]);
-    const float clipW = float(eyeZ * projMat[2][3] + projMat[3][3]);
-    const float eyeToNDCScale = eyeToClipXScale / clipW;
-
-    // Our final scaling factor is from the viewport transform, transforming
-    // from [-1,1] NDC space to image (pixel) space.
-    const float viewportSizeX = GetViewport().z;
-    const float NDCToImageScale = viewportSizeX * 0.5;
-
-    return modelWidth * modelToEyeScale * eyeToNDCScale * NDCToImageScale;
-}
-
-void main(void)
-{
-    MAT4 transform  = ApplyInstanceTransform(HdGet_transform());
-    vec4 point     = vec4(HdGet_points().xyz, 1);
-
-    outData.Peye = vec4(GetWorldToViewMatrix() * transform * point);
-
-    ProcessPrimvarsIn();
-
-    gl_Position = vec4(GetProjectionMatrix() * outData.Peye);
-    ApplyClipPlanes(outData.Peye);
-
-    float screenSpaceWidth = ComputeRasterPointSize(transform, outData.Peye.z);
-    screenSpaceWidth = ApplyPointSizeBias(screenSpaceWidth);
-    gl_PointSize = clamp(screenSpaceWidth,
-                         HD_GL_POINT_SIZE_MIN, HD_GL_POINT_SIZE_MAX);
-
-    ProcessPointId(GetPointId());
-}
-
---- --------------------------------------------------------------------------
--- layout Point.Fragment
-
-[
-    ["in block", "VertexData", "inData",
-        ["vec4", "Peye"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl Point.Fragment
-
-void main(void)
-{
-    ApplyDiskSampleMask();
-
-    vec3 Peye = inData.Peye.xyz / inData.Peye.w;
-    // camera facing.
-    vec3 Neye = vec3(0, 0, 1);
-
-    vec4 color = vec4(0.5, 0.5, 0.5, 1);
-#ifdef HD_HAS_displayColor
-    color.rgb = HdGet_displayColor().rgb;
-#endif
-#ifdef HD_HAS_displayOpacity
-    color.a = HdGet_displayOpacity();
-#endif
-
-    vec4 patchCoord = vec4(0);
-    color = ShadingTerminal(vec4(Peye, 1), Neye, color, patchCoord);
-
-#ifdef HD_MATERIAL_TAG_MASKED   
-    if (ShouldDiscardByAlpha(color)) {
-        discard;
-    }
-#endif
-
-    RenderOutput(vec4(Peye, 1), Neye, color, patchCoord);
-}