@tushar-br/editing-pack 1.0.195 → 1.0.197

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

@@ -1,97 +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.
-//
-
---- This is what an import might look like.
---- #import $TOOLS/hdSt/shaders/fallbackVolume.glslfx
-
--- configuration
-{
-    "techniques": {
-        "default": {
-            "volumeShader": {
-                "source": [ "FallbackVolume.VolumeShader" ]
-            }
-        }
-    }
-}
-
---- --------------------------------------------------------------------------
--- glsl FallbackVolume.VolumeShader
-
-// Functions that the volume shader of a volume material would provide.
-//
-// The functions give extinction, scattering, emission at a point as well as
-// a phase function such as Henyey-Greenstein (see, e.g., [1]).
-//
-// Only single scattering is taken into account and the result of the
-// scattering function (together with the phase function) is used to compute
-// the in-scattering component of the volume rendering equation for a light
-// source (point lights only).
-// The extinction function is supposed to return the sum of the
-// absorption and out-scattering cross section.
-// Note that the interpretation of emission here follows [1] (rather than [2]),
-// so the emission is added by the ray-marcher without being multiplied by
-// extinction.
-// Note that one cannot use the fallback volume shader for assets containing
-// "glow" rather "emission" where the convention is
-// emission = glow * extinction.
-//
-// [1] Matt Pharr, Wenzel Jakob, Greg Humphreys, "Physically Based Rendering",
-// Third Edition).
-// [2] Julian Fong, Magnus Wrenninge, Christopher Kulla, Ralf Habel,
-// "Production Volume Rendering", SIGGRAPH 2017 Course.
-
-// The functions given here use a density and emission field with a fixed
-// albedo.
-//
-//
-
-// Extinction function, returns sum of absorption and out-scattering cross
-// ratio.
-//
-float
-extinctionFunction(vec3 p)
-{
-    return HdGet_density(p);
-}
-
-// Scattering function, returns in-scattering cross-section (will be combined
-// with phase function).
-//
-// Here: constant on ellipsoid and zero outside.
-float
-scatteringFunction(vec3 p)
-{
-    const float albedo = 0.18;
-
-    return extinctionFunction(p) * albedo;
-}
-
-// Emission function, returns emission cross-section.
-//
-// Here: zero since volume is not emitting light.
-vec3
-emissionFunction(vec3 p)
-{
-    return HdGet_emission(p);
-}
-
-// Phase function in volume rendering equation.
-//
-// Here: isotropic.
-float
-phaseFunction(vec3 direction1, vec3 direction2)
-{
-    const float pi = 3.14159265358979;
-    const float sphereArea = 4.0 * pi;
-    const float inverseSphereArea = 1.0 / sphereArea;
-
-    return inverseSphereArea;
-}
-

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

@@ -1,448 +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/compute.glslfx
-
-#import $TOOLS/hdSt/shaders/instancing.glslfx
-
---- --------------------------------------------------------------------------
--- layout ViewFrustumCull.Counting
-
-[
-    ["buffer readWrite", "ResultData", "drawIndirectResult",
-        ["atomic_int", "numVisibleInstances"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.Counting
-
-void
-FrustumCullCountVisibleInstances(int resultInstanceCount)
-{
-    ATOMIC_ADD(numVisibleInstances[0], resultInstanceCount);
-}
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.NoCounting
-
-void
-FrustumCullCountVisibleInstances(int resultInstanceCount)
-{
-    // do nothing
-}
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.NoTinyCull
-
-bool
-FrustumCullIsTinyPrim(vec4 bboxMin, vec4 bboxMax, vec2 drawRangeNDC)
-{
-    // do nothing
-    return false;
-}
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.TinyCull
-
-bool
-FrustumCullIsTinyPrim(vec4 bboxMin, vec4 bboxMax, vec2 drawRangeNDC)
-{
-    // Check the length of the min/max diagonal, could do something better here.
-    vec2 ndcMin = (bboxMin.xy/max(.000001,bboxMin.w));
-    vec2 ndcMax = (bboxMax.xy/max(.000001,bboxMax.w));
-    float diag = distance(ndcMin, ndcMax);
-
-    // Cull prims outside the min(x)/max(y) range.
-    // When max is negative, do not cull based on max size
-
-    #define isLargeEnough (diag > drawRangeNDC.x)
-    #define isSmallEnough (drawRangeNDC.y < 0 || diag < drawRangeNDC.y)
-
-    return !isLargeEnough || !isSmallEnough;
-
-    #undef isLargeEnough
-    #undef isSmallEnough
-}
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.IsVisible
-
-bool
-FrustumCullIsVisible(MAT4 toClip, vec4 localMin, vec4 localMax, vec2 drawRangeNDC)
-{
-    // Disable culling when:
-    // (a) BBox is empty. An empty bbox defaults to [FLT_MAX, -FLT_MAX]), so
-    //     min > max.
-    // (b) Bounds are infinite.
-    if (any(greaterThan(localMin, localMax)) || 
-        any(isinf(localMin)) || any(isinf(localMax))) {
-        return true;
-    }
-    
-    // Transform the corners of the bounding box to clipping space.
-    vec4 p[8];
-    p[0] = vec4(toClip * vec4(localMin.x, localMin.y, localMin.z, 1));
-    p[2] = vec4(toClip * vec4(localMin.x, localMax.y, localMin.z, 1));
-    p[5] = vec4(toClip * vec4(localMax.x, localMin.y, localMax.z, 1));
-    p[7] = vec4(toClip * vec4(localMax.x, localMax.y, localMax.z, 1));
-
-    // This prim is visible if it wasn't culled and at least one tiny prim test
-    // failed. Test two axes here because size is measured in screen space.
-    // We front-load this test because it saves quite a bit of compute: in one
-    // test the framerate went from 7.7 to 9.0 FPS.
-    if (FrustumCullIsTinyPrim(p[0], p[7], drawRangeNDC) &&
-        FrustumCullIsTinyPrim(p[2], p[5], drawRangeNDC))
-    {
-        return false;
-    }
-
-    // Finish computing points and perform frustum culling.
-    p[1] = vec4(toClip * vec4(localMin.x, localMin.y, localMax.z, 1));
-    p[3] = vec4(toClip * vec4(localMin.x, localMax.y, localMax.z, 1));
-    p[4] = vec4(toClip * vec4(localMax.x, localMin.y, localMin.z, 1));
-    p[6] = vec4(toClip * vec4(localMax.x, localMax.y, localMin.z, 1));
-
-    // Test the corners of the bounding box against the clipping volume.
-    // clipFlags is effectively a 6-bit field, holding one bit of information
-    // per frustum plane. Each component of the vector holds 2 bits.
-    // If the bounding box overlaps the clip volume, then clipFlags will be
-    // (0b11, 0b11, 0b11).
-    ivec3 clipFlags = ivec3(0);
-    for (int i=0; i<8; ++i) {
-        vec4 clipPos = p[i];
-        bvec3 clip0 = lessThan(clipPos.xyz, vec3(clipPos.w));
-        bvec3 clip1 = greaterThan(clipPos.xyz, -vec3(clipPos.w));
-        clipFlags |= ivec3(clip0) /* bit 0 */ + 2*ivec3(clip1) /*bit 1*/;
-    }
-
-    return all(equal(clipFlags, ivec3(3)));
-}
-
---- --------------------------------------------------------------------------
--- layout ViewFrustumCull.Vertex
-
-[
-    ["in", "int", "instanceCountInput"],
-    ["in", "int", "drawCommandIndex"],
-    ["uniform block", "Uniforms", "ulocCullParams",
-        ["mat4", "cullMatrix"],
-        ["vec2", "drawRangeNDC"],
-        ["uint", "drawCommandNumUints"]
-    ],
-    ["buffer readWrite", "DispatchBuffer", "dispatchBuffer",
-        ["uint", "drawCommands", "[]"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.Vertex
-
-MAT4 GetCullMatrix()
-{
-    return MAT4(cullMatrix);
-}
-
-void main()
-{
-    // instanceCountOffset is a relative offset in drawcommand struct.
-    // it's a second entry in both DrawArraysCommand and DrawElementsCommand.
-    const uint instanceCountOffset = 1;
-
-    MAT4 transform = HdGet_transform();
-    MAT4 toClip = GetCullMatrix() * transform;
-
-    vec4 localMin = HdGet_bboxLocalMin();
-    vec4 localMax = HdGet_bboxLocalMax();
-
-    bool isVisible = FrustumCullIsVisible(
-        toClip, localMin, localMax, drawRangeNDC);
-
-    // Compute the index to the 'instanceCount' struct member in drawCommands.
-    uint index = uint(drawCommandIndex) * 
-        drawCommandNumUints + instanceCountOffset;
-
-    // Set the resulting instance count to 0 if the primitive is culled
-    // otherwise pass through the original incoming instance count.
-    uint resultInstanceCount = instanceCountInput * uint(isVisible);
-    drawCommands[index] = resultInstanceCount;
-
-    FrustumCullCountVisibleInstances(int(resultInstanceCount));
-}
-
---- --------------------------------------------------------------------------
--- layout ViewFrustumCull.VertexInstancing
-
-[
-    ["in", "int", "drawCommandIndex"],
-    ["uniform block", "Uniforms", "ulocCullParams",
-        ["mat4", "cullMatrix"],
-        ["vec2", "drawRangeNDC"],
-        ["uint", "drawCommandNumUints"],
-        ["uint",  "drawBatchId"],
-        ["int",  "resetPass"]
-    ],
-    ["buffer readWrite", "DispatchBuffer", "dispatchBuffer",
-        ["atomic_uint", "drawCommands", "[]"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.VertexInstancing
-
-/*
-   per-instance culling
-
-   We use instance index indirection buffer to switch prototypes efficiently.
-   Per-instance culling exploits this indirection to trim culled instances
-   from draw call.
-
-   Example: Prototype mesh M is instanced for 5 instances.
-
-   Instancer has instance primvars (translate, rotate, ...)
-   and index indirection for M.
-
-   InstancePrimvar  (T:translate)
-   +-------+-----------------------------+-----------+
-   :       |T0 T1 T2 T3 T4 T5 T6 T7 T8 T9|           :
-   +-------+-----------------------------+-----------+
-                           ^
-   InstanceIndices(for M)  |
-   +-----------+---------------+-----------+
-   :           | 0  2  5  8  9 |           :
-   +-----------+---------------+-----------+
-                     ^
-                     |
-           M: gl_InstanceID (0-5)
-
-   We can draw all instances of M, by just drawing with numInstance = 6.
-
-   For per-instance culling, we test each bbox against the frustum.
-   Then, we store only passed instance indices into culledInstanceIndices buffer,
-   as well as counting them.
-
-   InstanceIndices(for M)
-   +-----------+---------------+-----------+
-   :           | 0  2  5  8  9 |           :  instanceCount = 5
-   +-----------+---------------+-----------+
-                      V
-               <Frustum culling>  (say only 2 and 8 are visible in frustum)
-                      V
-   +-----------+---------------+-----------+
-   :           | 2  8  x  x  x |           :  instanceCount = 2
-   +-----------+---------------+-----------+
-                            x:undefined value
-*/
-
-MAT4 GetCullMatrix()
-{
-    return MAT4(cullMatrix);
-}
-
-void main()
-{
-    // instanceCountOffset is a relative offset in drawcommand struct.
-    // it's a second entry in both DrawArraysCommand and DrawElementsCommand.
-    const uint instanceCountOffset = 1;
-
-    const uint instanceCountBufferOffset =
-        drawCommandIndex * drawCommandNumUints + instanceCountOffset;
-
-    // reset pass
-    if (resetPass == 1) {
-        // note: we expect all instance invocations of this draw command
-        // are clearing same field to zero, and and so might not guard this
-        // access as atomic.
-        ATOMIC_STORE(drawCommands[instanceCountBufferOffset], 0);
-
-        // Sets first value of culledInstancesIndices to 0.
-        ATOMIC_STORE(culledInstanceIndices[GetBaseInstanceIndexCoord()], 0);
-
-        return;
-    }
-
-    // culling pass
-    // precondition: drawCommand.instanceCount has to be reset in the separate
-    // invocation unit.
-
-    vec4 localMin = HdGet_bboxLocalMin();
-    vec4 localMax = HdGet_bboxLocalMax();
-
-    MAT4 toClip = GetCullMatrix() * ApplyInstanceTransform(HdGet_transform());
-
-    bool isVisible = FrustumCullIsVisible(
-        toClip, localMin, localMax, drawRangeNDC);
-
-    if (isVisible) {
-        // increment the instance count and store instanceIndex to 
-        // culledInstanceIndices.
-
-        uint id = ATOMIC_ADD(drawCommands[instanceCountBufferOffset], 1);
-
-        // There is a potential correctness issue that happens when an instanced
-        // prim has geom subsets, resulting in multiple draw items with the same
-        // instanceIndices and culledInstanceIndices buffers (as we do not 
-        // duplicate these buffers for geom subset draw items). These geom 
-        // subset draw items will each try to read and write from the same 
-        // instanceIndices and culledInstanceIndices buffers from different
-        // threads of this shader. Given the potential difference in execution 
-        // order of the different threads, which each corresponding to a 
-        // different instance id, this can result in incorrect
-        // culledInstanceIndices.
-        // 
-        // To guard against this, we only allow one of these geom subset draw 
-        // items to write to the culledInstanceIndices buffer, by adding an 
-        // extra value at the start of culledInstanceIndices where we store
-        // the xor of the drawCommandIndex and drawBatchId for the first thread 
-        // to complete the atomic op below. Only this thread will be allowed to
-        // edit the culledInstanceIndices buffer.
-        int hash = drawCommandIndex ^ int(drawBatchId);
-
-        // XXX: There is a linking error in OpenGL when using atomicCompSwap 
-        // on bindless buffer culledInstanceIndices using the else case method.
-        // Thus we add this alternative.
-#ifdef HD_BINDLESS_BUFFERS_ENABLED
-        ATOMIC_COMP_SWAP(
-            culledInstanceIndices + GetBaseInstanceIndexCoord(), 0, hash);
-#else
-        ATOMIC_COMP_SWAP(
-            culledInstanceIndices[GetBaseInstanceIndexCoord()], 0, hash);
-#endif
-        
-        if (culledInstanceIndices[GetBaseInstanceIndexCoord()] != hash) {
-            return;
-        }
-
-        SetCulledInstanceIndex(id);
-        FrustumCullCountVisibleInstances(1);
-    }
-}
-
-
---- --------------------------------------------------------------------------
--- layout ViewFrustumCull.Compute
-
-[
-    ["uniform block", "Uniforms", "ulocCullParams",
-        ["mat4", "cullMatrix"],
-        ["vec2", "drawRangeNDC"],
-        ["uint", "drawCommandNumUints"]
-    ],
-    ["buffer readOnly", "DrawCullInput", "drawCullInput",
-        ["uint", "drawCullInput", "[]"]
-    ],
-    ["buffer readWrite", "DispatchBuffer", "dispatchBuffer",
-        ["uint", "drawCommands", "[]"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.Compute
-
-MAT4 GetCullMatrix()
-{
-    return MAT4(cullMatrix);
-}
-
-void compute(int drawCommandIndex)
-{
-    SetDrawIndex(drawCommandIndex, 0);
-
-    // instanceCountOffset is a relative offset in drawcommand struct.
-    // it's a second entry in both DrawArraysCommand and DrawElementsCommand.
-    const uint instanceCountOffset = 1;
-
-    MAT4 transform = HdGet_transform();
-    MAT4 toClip = GetCullMatrix() * transform;
-
-    vec4 localMin = HdGet_bboxLocalMin();
-    vec4 localMax = HdGet_bboxLocalMax();
-
-    bool isVisible = FrustumCullIsVisible(
-        toClip, localMin, localMax, drawRangeNDC);
-
-    // Compute the index to the 'instanceCount' struct member in drawCommands.
-    uint instanceIndex = uint(drawCommandIndex) *
-        drawCommandNumUints + instanceCountOffset;
-
-    // Set the resulting instance count to 0 if the primitive is culled
-    // otherwise pass through the original incoming instance count.
-    uint resultInstanceCount = drawCullInput[instanceIndex] * uint(isVisible);
-    drawCommands[instanceIndex] = resultInstanceCount;
-
-    FrustumCullCountVisibleInstances(int(resultInstanceCount));
-}
-
---- --------------------------------------------------------------------------
--- layout ViewFrustumCull.ComputeInstancing
-
-[
-    ["uniform block", "Uniforms", "ulocCullParams",
-        ["mat4", "cullMatrix"],
-        ["vec2", "drawRangeNDC"],
-        ["uint", "drawCommandNumUints"]
-    ],
-    ["buffer readOnly", "DrawCullInput", "drawCullInput",
-        ["uint", "drawCullInput", "[]"]
-    ],
-    ["buffer readWrite", "DispatchBuffer", "dispatchBuffer",
-        ["uint", "drawCommands", "[]"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl ViewFrustumCull.ComputeInstancing
-
-MAT4 GetCullMatrix()
-{
-    return MAT4(cullMatrix);
-}
-
-void compute(int drawCommandIndex)
-{
-    SetDrawIndex(drawCommandIndex, 0);
-
-    // instanceCountOffset is a relative offset in drawcommand struct.
-    // it's a second entry in both DrawArraysCommand and DrawElementsCommand.
-    const uint instanceCountOffset = 1;
-
-    const uint instanceCountBufferOffset =
-        drawCommandIndex * drawCommandNumUints + instanceCountOffset;
-
-    const uint instanceCount = drawCullInput[instanceCountBufferOffset];
-
-    vec4 localMin = HdGet_bboxLocalMin();
-    vec4 localMax = HdGet_bboxLocalMax();
-    MAT4 transform = HdGet_transform();
-
-    // Reset the instance count.
-    drawCommands[instanceCountBufferOffset] = 0;
-
-    for (int i = 0; i < instanceCount; ++i)
-    {
-        SetDrawIndex(drawCommandIndex, i);
-
-        MAT4 toClip = GetCullMatrix() * ApplyInstanceTransform(transform);
-
-        bool isVisible = FrustumCullIsVisible(
-            toClip, localMin, localMax, drawRangeNDC);
-
-        if (isVisible) {
-            // Increment the instance count and store instanceIndex to
-            // culledInstanceIndices.
-            uint id = drawCommands[instanceCountBufferOffset];
-
-            drawCommands[instanceCountBufferOffset] += 1;
-
-            SetCulledInstanceIndex(id);
-            FrustumCullCountVisibleInstances(1);
-        }
-    }
-}

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

@@ -1,103 +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.
-//
-
---- This is what an import might look like.
---- #import $TOOLS/hdSt/shaders/imageShader.glslfx
-
--- configuration
-{
-    "techniques": {
-        "default": {
-            "vertexShader" : {
-                "source": [ "ImageShader.Vertex" ]
-            },
-            "fragmentShader" : {
-                "source": [ "ImageShader.Fragment" ]
-            }
-        }
-    }
-}
-
---- --------------------------------------------------------------------------
--- layout ImageShader.Vertex
-
-[
-    ["out block", "VertexData", "outData",
-        ["vec2", "uv"]
-    ]
-]
-
---- --------------------------------------------------------------------------
--- glsl ImageShader.Vertex
-
-void main(void)
-{
-    // Position the vertices to create a large-than-screen triangle.
-    // Adjust the UVs of the triangle to have 0-1 fit the screen exactly.
-    // 'st' is the geometric UV where the [bottom,left] returns [0, 0].
-    // Unlike gl_fragCoord where the [bottom,left] defaults to [0.5, 0.5].
-    //
-    //    hd_VertexID=0 -> (-1,-1)
-    //    hd_VertexID=1 -> ( 3,-1)
-    //    hd_VertexID=2 -> (-1, 3)
-    //
-    //    glDrawArrays( GL_TRIANGLES, 0, 3 );
-    //
-    //    ID=2
-    //    x,y=-1,3
-    //    u,v=0,2
-    //    |\
-    //    |  \
-    //    |    \
-    //    |      \
-    //    |--------\
-    //    |        | \
-    //    | screen |   \
-    //    |        |     \
-    //     ----------------
-    //    ID=0             ID=1
-    //    x,y=-1,-1        x,y=3,-1
-    //    u,v=0,0          u,v=2,0
-    //
-    //
-    float x = -1.0 + float(((hd_VertexID%3) & 1) << 2);
-    float y = -1.0 + float(((hd_VertexID%3) & 2) << 1);
-    outData.uv.x = (x+1.0) * 0.5;
-    outData.uv.y = (y+1.0) * 0.5;
-
-    gl_Position = vec4(x, y, 0, 1);
-}
-
---- --------------------------------------------------------------------------
--- layout ImageShader.Fragment
-
-[
-    ["in block", "VertexData", "inData",
-        ["vec2", "uv"]
-    ],
-    ["out", "vec4", "colorOut"]
-]
-
---- --------------------------------------------------------------------------
--- glsl ImageShader.Fragment
-
-#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
-#endif
-
-void main(void)
-{
-    colorOut = imageShader(inData.uv);
-}