@tushar-br/editing-pack 1.0.195 → 1.0.196

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

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

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

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

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

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

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