@tushar-br/editing-pack 1.0.194 → 1.0.195

package/staging_area/Blender/blender.shared/usd/hdx/resources/shaders/boundingBox.glslfx

@@ -0,0 +1,52 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2022 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "BoundingBoxVertex": {
+                "source": [ "BoundingBox.Vertex" ]
+            },
+            "BoundingBoxFragment": {
+                "source": [ "BoundingBox.Fragment" ]
+            }
+        }
+    }
+}
+
+-- glsl BoundingBox.Vertex
+
+void main(void)
+{
+    const vec4 clipPos =  worldViewProj[hd_InstanceID] * vec4(position,1.0);
+    gl_Position = clipPos;
+
+    // Write out a flat (non-interpolated) screen space position for the
+    // provoking vertex for a line so we can measure how far a fragment
+    // is from that vertex in screen space.
+    dashStart = (clipPos.xy/clipPos.w+vec2(1.0))*(viewport.zw/2.0)+viewport.xy;
+}
+
+-- glsl BoundingBox.Fragment
+
+void main(void)
+{
+    // Skip any pattern styling if the uniform/constant dashSize is invalid.
+    if (dashSize != 0.0) {
+        // Otherwise create a dashed pattern with equal solid and blank pixel
+        // sections for the line.
+        const float pixelDist = distance(dashStart, gl_FragCoord.xy);
+        if (mod(pixelDist, 2.0*dashSize) > dashSize) {
+            discard;
+        }
+    }
+
+    hd_FragColor = color;
+}

package/staging_area/Blender/blender.shared/usd/hdx/resources/shaders/colorChannel.glslfx

@@ -0,0 +1,53 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2019 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "ColorChannelFragment": {
+                "source": [ "ColorChannel.Fragment" ]
+            }
+        }
+    }
+}
+
+-- glsl ColorChannel.Fragment
+
+
+// Display channel values. These should match the the indices of the entries in
+// HdxDisplayChannelTokens
+#define CHANNEL_COLOR     0
+#define CHANNEL_RED       1
+#define CHANNEL_GREEN     2
+#define CHANNEL_BLUE      3
+#define CHANNEL_ALPHA     4
+#define CHANNEL_LUMINANCE 5
+
+void main(void)
+{
+    vec2 fragCoord = uvOut * screenSize;
+    vec4 color = HgiTexelFetch_colorIn(ivec2(fragCoord));
+
+    // Display Channel
+    if (channel == CHANNEL_RED) {
+        color.g = color.b = color.r;
+    } else if (channel == CHANNEL_GREEN) {
+        color.r = color.b = color.g;
+    } else if (channel == CHANNEL_BLUE) {
+        color.r = color.g = color.b;
+    } else if (channel == CHANNEL_ALPHA) {
+        color.r = color.g = color.b = color.a;
+    } else if (channel == CHANNEL_LUMINANCE) {
+        const vec3 W = vec3(0.30, 0.59, 0.11);
+        color.r = color.g = color.b = dot(color.rgb, W);
+    } // Do nothing if channel == CHANNEL_COLOR
+
+    hd_FragColor = color;
+}

package/staging_area/Blender/blender.shared/usd/hdx/resources/shaders/colorCorrection.glslfx

@@ -0,0 +1,57 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "ColorCorrectionVertex": {
+                "source": [ "ColorCorrection.Vertex" ]
+            },
+            "ColorCorrectionFragment": {
+                "source": [ "ColorCorrection.Fragment" ]
+            }
+        }
+    }
+}
+
+-- glsl ColorCorrection.Vertex
+
+void main(void)
+{
+    gl_Position = position;
+    uvOut = uvIn;
+}
+
+-- glsl ColorCorrection.Fragment
+
+// Similar to D3DX_DXGIFormatConvert.inl, but branchless
+// https://www.shadertoy.com/view/wds3zM
+vec3 FloatToSRGB(vec3 val)
+{
+    val = mix((val * 12.92),
+              (1.055 * pow(val, vec3(1.0/2.4)) - 0.055),
+              step(0.0031308, val));
+    return val;
+}
+
+void main(void)
+{
+    vec2 fragCoord = uvOut * screenSize;
+    vec4 inCol = HgiTexelFetch_colorIn(ivec2(fragCoord));
+
+    #if defined(GLSLFX_USE_OCIO)
+        inCol = OCIO_DISPLAY_FUNC(inCol);
+    #else
+        // Only color, not alpha is gamma corrected!
+        inCol.rgb = FloatToSRGB(inCol.rgb);
+    #endif
+
+    hd_FragColor = inCol;
+}

package/staging_area/Blender/blender.shared/usd/hdx/resources/shaders/fullscreen.glslfx

@@ -0,0 +1,48 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "FullscreenVertex": {
+                "source": [ "Fullscreen.Vertex" ]
+            },
+            "CompositeFragmentNoDepth": {
+                "source": [ "Composite.FragmentNoDepth" ]
+            },
+            "CompositeFragmentWithDepth": {
+                "source": [ "Composite.FragmentWithDepth" ]
+            }
+        }
+    }
+}
+
+-- glsl Fullscreen.Vertex
+
+void main(void)
+{
+    gl_Position = position;
+    uvOut = uvIn;
+}
+
+-- glsl Composite.FragmentNoDepth
+
+void main(void)
+{
+    hd_FragColor = vec4(HgiGet_colorIn(uvOut));
+}
+
+-- glsl Composite.FragmentWithDepth
+
+void main(void)
+{
+    hd_FragColor = vec4(HgiGet_colorIn(uvOut));
+    gl_FragDepth = HgiGet_depth(uvOut).x;
+}

package/staging_area/Blender/blender.shared/usd/hdx/resources/shaders/oitResolveImageShader.glslfx

@@ -0,0 +1,93 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "fragmentShader": {
+                "source": [ "OitResolve.Image" ]
+            }
+        }
+    }
+}
+
+--- --------------------------------------------------------------------------
+-- layout OitResolve.Image
+
+[
+    ["buffer readWrite", "CounterBuffer", "hdxOitCounterBuffer",
+        ["atomic_int", "hdxOitCounterBuffer"]
+    ]
+]
+
+-- glsl OitResolve.Image
+
+vec4 imageShader(vec2 uv)
+{
+#if defined(HD_HAS_hdxOitDataBuffer)
+    const int screenWidth = int(HdGet_oitScreenSize().x);
+    const int screenHeight = int(HdGet_oitScreenSize().y);
+
+    // Must match the per-pixel sample count used when creating the OIT buffers.
+    // (See HdxOitResolveTask::_PrepareOitBuffers)
+    const int maxSamples = 8;
+
+    const int dataBufferSize = screenWidth * screenHeight * maxSamples;
+
+    // +1 because index 0 of counter buffer is reserved as atomic counter in
+    // WriteOitLayersToBuffer
+    int screenIndex = int(gl_FragCoord.x) + int(gl_FragCoord.y) * screenWidth;
+    screenIndex += 1;
+
+    int nodeIndex = ATOMIC_LOAD(hdxOitCounterBuffer[screenIndex]);
+    int numDepths = 0;
+
+    // XXX renderPass.WriteOitLayersToBuffer does not clamp the number of
+    //     depth samples we store for a pixel. Here we process no more than
+    //     'maxSamples' for a pixel. (If there are greater than 'maxSamples'
+    //     samples stored for this pixel some will currently not contribute)
+    vec4 sortedColor[maxSamples];
+    float sortedDepth[maxSamples];
+
+    while (nodeIndex != -1 && 
+           numDepths < maxSamples && 
+           nodeIndex < dataBufferSize) 
+    {
+        float currentDepth = hdxOitDepthBuffer[nodeIndex]; 
+        int insertIndex = numDepths; 
+        // Recall that depths are in eye space, so inequality is flipped.
+        while (insertIndex > 0 && sortedDepth[insertIndex - 1] < currentDepth) {
+            sortedDepth[insertIndex] = sortedDepth[insertIndex - 1];
+            sortedColor[insertIndex] = sortedColor[insertIndex - 1]; 
+            insertIndex -= 1; 
+        }
+        sortedColor[insertIndex] = hdxOitDataBuffer[nodeIndex];
+        sortedDepth[insertIndex] = hdxOitDepthBuffer[nodeIndex];
+        numDepths += 1; 
+        nodeIndex = hdxOitIndexBuffer[nodeIndex]; 
+    } 
+
+    // Assume color in sortedColor is pre-multiplied by alpha
+    int depth = 0;
+    vec4 colorAccum = vec4(0);
+    while (depth < numDepths) {
+        colorAccum += sortedColor[depth] * (1 - colorAccum.a);
+
+        if (colorAccum.a >= 1.0) break;
+
+        depth += 1; 
+    }
+
+    colorAccum = clamp(colorAccum, vec4(0), vec4(1));
+    return colorAccum;
+#else
+    return vec4(0);
+#endif
+}

package/staging_area/Blender/blender.shared/usd/hdx/resources/shaders/outline.glslfx

@@ -0,0 +1,138 @@
+-- glslfx version 0.1
+
+//
+// Copyright 2020 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+
+-- configuration
+{
+    "techniques": {
+        "default": {
+            "OutlineFragment": {
+                "source": [ "Outline.Fragment" ]
+            }
+        }
+    }
+}
+
+-- glsl Outline.Fragment
+
+#define EPSILON 0.0001
+#define LARGE 100000
+
+// The color texture with the highlighted areas.
+
+// Given a delta x and y in relation to the current texel coordinates, check if
+// the colorIn texture has a non-black texel and its distance^2 to the current
+// texel is smaller than the one passed as dist2. The color of that texel will
+// be returned in the color output var.
+void testTexel(int x, int y, REF(thread,float) dist2, REF(thread,vec4) color)
+{
+    vec2 texCoords = uvOut + vec2(x, y) * texelSize;
+    vec4 c = HgiGet_colorIn(texCoords);
+
+    if ( c.r > EPSILON || c.g > EPSILON || c.b > EPSILON) {
+        float d = float(x * x + y * y );
+        if (d < dist2) {
+            dist2 = d;
+            color = c;
+        }
+    }
+}
+
+// Used by testOctants() to scan each horizontal line in the circle.
+// Returns the distance^2 and color of the non-black texel that is closest to
+// the current texel.
+void testHLine(int x0, int x1, int y, REF(thread,float) dist2, REF(thread,vec4) color) {
+    for (int x = x0; x < x1; x++) {
+        testTexel(x, y, dist2, color);
+    }
+}
+
+// Part of the Bresenham algorithm: mirror the circle octant edge coords to
+// obtain a half circle and then mirror them horizontally to obtain the
+// horizontal lines that define the circle and its interior.
+// Returns the distance^2 and color of the non-black texel that is closest to
+// the current texel.
+void testOctants(int x, int y, REF(thread,float) dist2, REF(thread,vec4) color) {
+    testHLine(-x, x,  y, dist2, color);
+    testHLine(-x, x, -y, dist2, color);
+    testHLine(-y, y,  x, dist2, color);
+    testHLine(-y, y, -x, dist2, color);
+}
+
+// Find the color and distance^2 to the closest texel in colorIn that is not
+// black and that is within a circle defined by the specified radius, centered
+// in the current texel. (Note: distance^2 is used to avoid sqrt).
+// This uses the Bresenham circle algorithm to discover the texels inside that
+// circle, to avoid having to read the colorIn texels outside of it.
+void testCircle(int r, REF(thread,float) dist2, REF(thread,vec4) color) {
+    if (r < 0) { r = 0; }
+
+    int d = 3 - (2 * r);
+    int x = 0;
+    int y = r;
+
+    testOctants(x, y, dist2, color);
+
+    while (x < y) {
+        x++;
+
+        if (d > 0) {
+            y--;
+            d = d + 4 * (x - y) + 10;
+        } else {
+            d = d + 4 * x + 6;           
+        }
+
+        testOctants(x, y, dist2, color);
+    }
+}
+
+// If radius is 0 then render colorIn as is. If radius > 0 then render only the
+// outline of the non-black areas in colorIn. The radius will define the
+// thickness of the outline. The color of each texel in the outline will be
+// defined by the closest color in colorIn, fading out when the distance to that
+// colorIn texel equals the radius. This will allow colorIn to potentially hold
+// several colors that will be respected by the outline.
+
+void main()
+{
+    hd_FragColor = vec4(0, 0, 0, 1);
+    // Check if the current texel is not black - meaning that we are inside an
+    // area of colorId that has been highlighted.
+    vec4 color = HgiGet_colorIn(uvOut);
+    bool isInside = color.r > EPSILON || color.g > EPSILON || color.b > EPSILON;
+
+    if (enableOutline==0) { 
+        if (isInside) {
+            // Inside the highlighted areas in colorIn : render colorIn.
+            hd_FragColor = color;
+        }
+    } else {
+        
+        if (!isInside) {
+            // Outside the highlighted area: render the outline
+            float r2 = float(radius * radius);
+            float dist2 = LARGE;
+
+            // Check if there are any highlighted texels around the current one
+            // inside the specified radius.
+            testCircle(radius, dist2, color);
+
+            // Check if the distance^2 to the closest highlighted texel is within
+            // radius^2.
+            if (dist2 <= r2) {
+                // Attenuate the texel color using the distance^2 to it.
+                float factor = (r2 - dist2 ) / r2;
+                factor *= factor;
+                
+                hd_FragColor = color * factor;
+                hd_FragColor.a = 1;
+            }
+        }
+    }
+}