@tushar-br/editing-pack 1.0.194 → 1.0.195

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

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

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

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