@tushar-br/editing-pack 1.0.195 → 1.0.196

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

@@ -1,371 +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.
-//
-
--- configuration
-{
-    "techniques": {
-        "default": {
-            "ptexTextureSampler" : {
-                "source": [
-                    "PtexTextureSampler"
-                ]
-            }
-        }
-    }
-}
-
--- glsl PtexTextureSampler
-
-// ----- following code comes from OpenSubdiv/examples/common
-
-struct PtexPacking {
-    int page;
-    int nMipmap;
-    int uOffset;
-    int vOffset;
-    int adjSizeDiffs[4];
-    int width;
-    int height;
-};
-
-int computeMipmapOffsetU(int w, int level)
-{
-    int width = 1 << w;
-    int m = (0x55555555 & (width | (width-1))) << (w&1);
-    int x = ~((1 << (w -((level-1)&~1))) - 1);
-    return (m & x) + ((level+1)&~1);
-}
-
-int computeMipmapOffsetV(int h, int level)
-{
-    int height = 1 << h;
-    int m = (0x55555555 & (height-1)) << ((h+1)&1);;
-    int x = ~((1 << (h - (level&~1))) - 1 );
-    return (m & x) + (level&~1);
-}
-
-void evalQuadraticBSpline(float u,
-    REF(thread,float) B0,  REF(thread,float) B1,  REF(thread,float) B2,
-    REF(thread,float) BU0, REF(thread,float) BU1, REF(thread,float) BU2)
-{
-    B0 = 0.5 * (u*u - 2.0*u + 1);
-    B1 = 0.5 + u - u*u;
-    B2 = 0.5 * u*u;
-
-    BU0 = u - 1.0;
-    BU1 = 1 - 2 * u;
-    BU2 = u;
-}
-
-PtexPacking getPtexPacking(usampler1DArray packings, int faceID, int level)
-{
-    const int layoutTexelsPerFace = 3;
-    const int stride = textureSize(packings, 0).x;
-    const int index = faceID * layoutTexelsPerFace;
-    const int layer = index / stride;
-
-    const ivec2 packingIndex = ivec2(index - (layer * stride), layer); 
-
-    const uvec2 page    = texelFetch(packings, packingIndex+ivec2(0,0), 0).xy;
-    const uvec2 offsets = texelFetch(packings, packingIndex+ivec2(1,0), 0).xy;
-    const uvec2 sizes   = texelFetch(packings, packingIndex+ivec2(2,0), 0).xy;
-
-    PtexPacking packing;
-    packing.page    = int(page.x);
-    packing.nMipmap = int(page.y);
-    packing.uOffset = int(offsets.x);
-    packing.vOffset = int(offsets.y);
-
-    const int adjSizeDiffs = int(sizes.x);
-    packing.adjSizeDiffs[0] = (adjSizeDiffs >> 12) & 0xf;
-    packing.adjSizeDiffs[1] = (adjSizeDiffs >>  8) & 0xf;
-    packing.adjSizeDiffs[2] = (adjSizeDiffs >>  4) & 0xf;
-    packing.adjSizeDiffs[3] = (adjSizeDiffs >>  0) & 0xf;
-
-    const int wh = int(sizes.y);
-    const int w = wh >> 8;
-    const int h = wh & 0xff;
-
-    // clamp max level
-    level = min(level, packing.nMipmap);
-
-    packing.width   = 1 << (w-level);
-    packing.height  = 1 << (h-level);
-
-    if (level > 0) {
-        packing.uOffset += computeMipmapOffsetU(w, level);
-        packing.vOffset += computeMipmapOffsetV(h, level);
-    }
-
-    return packing;
-}
-
-// ----------------------------------------------------------------------------
-// Non-Mipmap Lookups
-// ----------------------------------------------------------------------------
-
-vec4 PtexLookupNearest(vec4 patchCoord,
-                       sampler2DArray data,
-                       usampler1DArray packings)
-{
-    vec2 uv = clamp(patchCoord.xy, vec2(0), vec2(1));
-    int faceID = int(patchCoord.w);
-    PtexPacking ppack = getPtexPacking(packings, faceID, 0);
-    vec2 coords = vec2(uv.x * ppack.width + ppack.uOffset,
-                       uv.y * ppack.height + ppack.vOffset);
-    return texelFetch(data, ivec3(int(coords.x), int(coords.y), ppack.page), 0);
-}
-
-vec4 PtexLookupNearest(vec4 patchCoord,
-                       int level,
-                       sampler2DArray data,
-                       usampler1DArray packings)
-{
-    vec2 uv = clamp(patchCoord.xy, vec2(0), vec2(1));
-    int faceID = int(patchCoord.w);
-    PtexPacking ppack = getPtexPacking(packings, faceID, level);
-    vec2 coords = vec2(uv.x * ppack.width + ppack.uOffset,
-                       uv.y * ppack.height + ppack.vOffset);
-    return texelFetch(data, ivec3(int(coords.x), int(coords.y), ppack.page), 0);
-}
-
-vec4 PtexLookupFast(vec4 patchCoord,
-                    sampler2DArray data,
-                    usampler1DArray packings)
-{
-    vec2 uv = clamp(patchCoord.xy, vec2(0), vec2(1));
-    int faceID = int(patchCoord.w);
-    PtexPacking ppack = getPtexPacking(packings, faceID, 0);
-
-    ivec3 size = textureSize(data, 0);
-    vec2 coords = vec2((uv.x * ppack.width + ppack.uOffset)/size.x,
-                       (uv.y * ppack.height + ppack.vOffset)/size.y);
-    return texture(data, vec3(coords.x, coords.y, ppack.page));
-}
-
-vec4 PtexLookupFast(vec4 patchCoord,
-                    int level,
-                    sampler2DArray data,
-                    usampler1DArray packings)
-{
-    vec2 uv = clamp(patchCoord.xy, vec2(0), vec2(1));
-    int faceID = int(patchCoord.w);
-    PtexPacking ppack = getPtexPacking(packings, faceID, level);
-
-    ivec3 size = textureSize(data, 0);
-    vec2 coords = vec2((uv.x * ppack.width + ppack.uOffset)/size.x,
-                       (uv.y * ppack.height + ppack.vOffset)/size.y);
-    return texture(data, vec3(coords.x, coords.y, ppack.page));
-}
-
-vec4 PtexLookup(vec4 patchCoord,
-                int level,
-                sampler2DArray data,
-                usampler1DArray packings)
-{
-    vec2 uv = clamp(patchCoord.xy, vec2(0), vec2(1));
-    int faceID = int(patchCoord.w);
-    PtexPacking ppack = getPtexPacking(packings, faceID, level);
-
-    vec2 coords = vec2(uv.x * ppack.width + ppack.uOffset,
-                       uv.y * ppack.height + ppack.vOffset);
-
-    coords -= vec2(0.5, 0.5);
-
-    int c0X = int(floor(coords.x));
-    int c1X = int(ceil(coords.x));
-    int c0Y = int(floor(coords.y));
-    int c1Y = int(ceil(coords.y));
-
-    float t = coords.x - float(c0X);
-    float s = coords.y - float(c0Y);
-
-    vec4 d0 = texelFetch(data, ivec3(c0X, c0Y, ppack.page), 0);
-    vec4 d1 = texelFetch(data, ivec3(c0X, c1Y, ppack.page), 0);
-    vec4 d2 = texelFetch(data, ivec3(c1X, c0Y, ppack.page), 0);
-    vec4 d3 = texelFetch(data, ivec3(c1X, c1Y, ppack.page), 0);
-
-    vec4 result = (1-t) * ((1-s)*d0 + s*d1) + t * ((1-s)*d2 + s*d3);
-
-    return result;
-}
-
-vec4 PtexLookupQuadratic(REF(thread, vec4) du,
-                         REF(thread, vec4) dv,
-                         vec4 patchCoord,
-                         int level,
-                         sampler2DArray data,
-                         usampler1DArray packings)
-{
-    vec2 uv = clamp(patchCoord.xy, vec2(0), vec2(1));
-    int faceID = int(patchCoord.w);
-    PtexPacking ppack = getPtexPacking(packings, faceID, level);
-
-    vec2 coords = vec2(uv.x * ppack.width + ppack.uOffset,
-                       uv.y * ppack.height + ppack.vOffset);
-
-    coords -= vec2(0.5, 0.5);
-
-    int cX = int(round(coords.x));
-    int cY = int(round(coords.y));
-
-    float x = 0.5 - (float(cX) - coords.x);
-    float y = 0.5 - (float(cY) - coords.y);
-
-    vec4 d[9];
-    d[0] = texelFetch(data, ivec3(cX-1, cY-1, ppack.page), 0);
-    d[1] = texelFetch(data, ivec3(cX-1, cY-0, ppack.page), 0);
-    d[2] = texelFetch(data, ivec3(cX-1, cY+1, ppack.page), 0);
-    d[3] = texelFetch(data, ivec3(cX-0, cY-1, ppack.page), 0);
-    d[4] = texelFetch(data, ivec3(cX-0, cY-0, ppack.page), 0);
-    d[5] = texelFetch(data, ivec3(cX-0, cY+1, ppack.page), 0);
-    d[6] = texelFetch(data, ivec3(cX+1, cY-1, ppack.page), 0);
-    d[7] = texelFetch(data, ivec3(cX+1, cY-0, ppack.page), 0);
-    d[8] = texelFetch(data, ivec3(cX+1, cY+1, ppack.page), 0);
-
-    float B[3], D[3];
-    vec4 BUCP[3], DUCP[3];
-    BUCP[0] = vec4(0); BUCP[1] = vec4(0); BUCP[2] = vec4(0);
-    DUCP[0] = vec4(0); DUCP[1] = vec4(0); DUCP[2] = vec4(0);
-
-    evalQuadraticBSpline(y, B[0], B[1], B[2], D[0], D[1], D[2]);
-
-    for (int i = 0; i < 3; ++i) {
-        for (int j = 0; j < 3; j++) {
-            vec4 A = d[i*3+j];
-            BUCP[i] += A * B[j];
-            DUCP[i] += A * D[j];
-        }
-    }
-
-    evalQuadraticBSpline(x, B[0], B[1], B[2], D[0], D[1], D[2]);
-
-    vec4 result = vec4(0);
-    du = vec4(0);
-    dv = vec4(0);
-    for (int i = 0; i < 3; ++i) {
-        result += B[i] * BUCP[i];
-        du += D[i] * BUCP[i];
-        dv += B[i] * DUCP[i];
-    }
-
-    du *= ppack.width;
-    dv *= ppack.height;
-
-    return result;
-}
-
-// ----------------------------------------------------------------------------
-// MipMap Lookups
-// ----------------------------------------------------------------------------
-vec4 PtexMipmapLookupNearest(vec4 patchCoord,
-                             float level,
-                             sampler2DArray data,
-                             usampler1DArray packings)
-{
-#if defined(SEAMLESS_MIPMAP)
-    // diff level
-    int faceID = int(patchCoord.w);
-    vec2 uv = patchCoord.xy;
-    PtexPacking packing = getPtexPacking(packings, faceID);
-    level += mix(mix(packing.adjSizeDiffs[0], packing.adjSizeDiffs[1], uv.x),
-                 mix(packing.adjSizeDiffs[3], packing.adjSizeDiffs[2], uv.x),
-                 uv.y);
-#endif
-
-    int levelm = int(floor(level));
-    int levelp = int(ceil(level));
-    float t = level - float(levelm);
-
-    vec4 result = (1-t) * PtexLookupNearest(patchCoord, levelm, data, packings)
-        + t * PtexLookupNearest(patchCoord, levelp, data, packings);
-    return result;
-}
-
-
-vec4 PtexMipmapLookup(vec4 patchCoord,
-                      float level,
-                      sampler2DArray data,
-                      usampler1DArray packings)
-{
-#if defined(SEAMLESS_MIPMAP)
-    // diff level
-    int faceID = int(patchCoord.w);
-    vec2 uv = patchCoord.xy;
-    PtexPacking packing = getPtexPacking(packings, faceID);
-    level += mix(mix(packing.adjSizeDiffs[0], packing.adjSizeDiffs[1], uv.x),
-                 mix(packing.adjSizeDiffs[3], packing.adjSizeDiffs[2], uv.x),
-                 uv.y);
-#endif
-
-    int levelm = int(floor(level));
-    int levelp = int(ceil(level));
-    float t = level - float(levelm);
-
-    vec4 result = (1-t) * PtexLookup(patchCoord, levelm, data, packings)
-        + t * PtexLookup(patchCoord, levelp, data, packings);
-    return result;
-}
-
-vec4 PtexMipmapLookupQuadratic(REF(thread, vec4) du,
-                               REF(thread, vec4) dv,
-                               vec4 patchCoord,
-                               float level,
-                               sampler2DArray data,
-                               usampler1DArray packings)
-{
-#if defined(SEAMLESS_MIPMAP)
-    // diff level
-    int faceID = int(patchCoord.w);
-    vec2 uv = patchCoord.xy;
-    PtexPacking packing = getPtexPacking(packings, faceID);
-    level += mix(mix(packing.adjSizeDiffs[0], packing.adjSizeDiffs[1], uv.x),
-                 mix(packing.adjSizeDiffs[3], packing.adjSizeDiffs[2], uv.x),
-                 uv.y);
-#endif
-
-    int levelm = int(floor(level));
-    int levelp = int(ceil(level));
-    float t = level - float(levelm);
-
-    vec4 du0, du1, dv0, dv1;
-    vec4 r0 = PtexLookupQuadratic(du0, dv0, patchCoord, levelm, data, packings);
-    vec4 r1 = PtexLookupQuadratic(du1, dv1, patchCoord, levelp, data, packings);
-
-    vec4 result = mix(r0, r1, t);
-    du = mix(du0, du1, t);
-    dv = mix(dv0, dv1, t);
-
-    return result;
-}
-
-vec4 PtexMipmapLookupQuadratic(vec4 patchCoord,
-                               float level,
-                               sampler2DArray data,
-                               usampler1DArray packings)
-{
-    vec4 du, dv;
-    return PtexMipmapLookupQuadratic(du, dv, patchCoord, level, data, packings);
-}
-
-// end from OpenSubdiv/examples/common
-
-// ----------------------------------------------------------------------------
-
-vec4
-PtexTextureLookup(sampler2DArray data,
-                  usampler1DArray packings,
-                  vec4 patchCoord)
-{
-    return PtexLookup(patchCoord,
-                      /*level = */0,
-                      data,
-                      packings);
-}
-

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

@@ -1,319 +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/renderPass.glslfx
-
--- glsl RenderPass.Camera
-
-// ---------------------------------------------------------------------------
-// global defines
-// ---------------------------------------------------------------------------
-// codeGen can override this range (currently not).
-// quadro 4000's max is 189.
-#ifndef HD_GL_POINT_SIZE_MAX
-#define HD_GL_POINT_SIZE_MAX  100.0
-#endif
-#ifndef HD_GL_POINT_SIZE_MIN
-#define HD_GL_POINT_SIZE_MIN  .45
-#endif
-
-// ---------------------------------------------------------------------------
-// render pass states
-// ---------------------------------------------------------------------------
-
-MAT4  GetWorldToViewMatrix() {
-#if defined(HD_HAS_worldToViewMatrix)
-    return MAT4(HdGet_worldToViewMatrix());
-#else
-    return MAT4(1);
-#endif
-}
-MAT4  GetWorldToViewInverseMatrix() {
-#if defined(HD_HAS_worldToViewInverseMatrix)
-    return MAT4(HdGet_worldToViewInverseMatrix());
-#else
-    return MAT4(1);
-#endif
-}
-MAT4  GetProjectionMatrix() {
-#if defined(HD_HAS_projectionMatrix)
-    return MAT4(HdGet_projectionMatrix());
-#else
-    return MAT4(1);
-#endif
-}
-vec3 GetPositionInWorldSpace(vec3 windowRelativeCoord)
-{
-#if defined(HD_HAS_imageToWorldMatrix)
-    vec4 pImage = vec4(windowRelativeCoord, 1.0);
-    vec4 pWorld = vec4(HdGet_imageToWorldMatrix() * pImage);
-    return (pWorld / pWorld.w).xyz;
-#else
-    return windowRelativeCoord;
-#endif
-}
-float GetLightingBlendAmount() {
-#if defined(HD_HAS_lightingBlendAmount)
-    return HdGet_lightingBlendAmount();
-#else
-    return 1;
-#endif
-}
-float GetLinearExposure() {
-#if defined(HD_HAS_linearExposure)
-    return HdGet_linearExposure();
-#else
-    return 1;
-#endif
-}
-vec4  GetViewport() {
-#if defined(HD_HAS_viewport)
-    return HdGet_viewport();
-#else
-    return vec4(0,0,1,1);
-#endif
-}
-float GetTessLevel() {
-#if defined(HD_HAS_tessLevel)
-    return HdGet_tessLevel();
-#else
-    return 1;
-#endif
-}
-float GetPointSize() {
-#if defined(HD_HAS_pointSize)
-    return HdGet_pointSize();
-#else
-    return 3.0;
-#endif
-}
-float GetPointSelectedSize() {
-#if defined(HD_HAS_pointSelectedSize)
-    return HdGet_pointSelectedSize();
-#else
-    return 5.0;
-#endif
-}
-vec4  GetWireframeColor() {
-// Individual prims can specify an alternative wireframe color
-// to one specified in the render pass.  This is used in cases were
-// there is not enough contrast with the normal one. 
-#if defined(HD_HAS_overrideWireframeColor)
-    return HdGet_overrideWireframeColor();
-#elif defined(HD_HAS_wireframeColor)
-    return HdGet_wireframeColor();
-#else
-    return vec4(0,0,0,0);
-#endif
-}
-vec4  GetMaskColor() {
-#if defined(HD_HAS_maskColor)
-    return HdGet_maskColor();
-#else
-    return vec4(0.5,0,0,1);
-#endif
-}
-vec4  GetIndicatorColor() {
-#if defined(HD_HAS_indicatorColor)
-    return HdGet_indicatorColor();
-#else
-    return vec4(0,0.5,0,1);
-#endif
-}
-
-bool ShouldDiscardByAlpha(vec4 color)
-{
-#if defined(HD_HAS_alphaThreshold)
-    float alphaThreshold = HdGet_alphaThreshold();
-#else
-    float alphaThreshold = 0;
-#endif
-    return (color.a < alphaThreshold);
-}
-
-vec2 ApplyAxisAlignedAffineTransform(vec4 t, vec2 pt)
-{
-    return t.xy * pt + t.zw;
-}
-
--- glsl RenderPass.CameraFS
-
-vec2 HorizontallyNormalizedFilmbackCoordinates()
-{
-    const vec4 transform =
-#ifdef HD_HAS_imageToHorizontallyNormalizedFilmback
-        HdGet_imageToHorizontallyNormalizedFilmback();
-#else
-        vec4(vec2(1.0), vec2(0.0));
-#endif
-    return ApplyAxisAlignedAffineTransform(transform, gl_FragCoord.xy);
-}
-
--- glsl RenderPass.ApplyClipPlanes
-
-void ApplyClipPlanes(vec4 Peye)
-{
-#if defined(HD_HAS_numClipPlanes)
-#if defined(HD_HAS_clipPlanes)
-    for (int i=0; i<HD_NUM_clipPlanes; ++i) {
-        // For Hgi backends like Metal, we declare a shader stage output of 
-        // gl_ClipDistance[HD_NUM_clipPlanes], since we need to know the array 
-        // size at compile time. To avoid having any uninitialized values in 
-        // that array, we initialize them all to zero first.
-        gl_ClipDistance[i] = 0;
-        if (i < HdGet_numClipPlanes()) {
-            gl_ClipDistance[i] = dot(HdGet_clipPlanes(i), Peye);
-        }
-    }
-#endif
-#endif
-}
-
--- glsl RenderPass.NoColorOverrides
-
-vec4 ApplyColorOverrides(vec4 color)
-{
-    return color;
-}
-
-vec3 ApplyMaskColor(vec3 color, float weight, vec4 maskColor)
-{
-    return color;
-}
-
-vec4 ApplyColorOverridesPostLighting(vec4 color)
-{
-    return color;
-}
-
--- glsl RenderPass.NoSelection
-
-vec4 ApplySelectionColor(vec4 color)
-{
-    return color;
-}
-
--- glsl RenderPass.ApplyColorOverrides
-
-// Forward declare selection functionality.
-// XXX: Currently, the non-empty implementation of this is in hdx.
-FORWARD_DECL(vec4 ApplySelectionColor(vec4 color));
-
-// XXX: Make sure to update hdx/shaders/renderPass.glslfx when editing these
-// color override methods, since they're currently duplicated. This is because
-// we don't have a mixin token for color overrides in a render pass yet.
-vec4 ApplyColorOverrides(vec4 color)
-{
-#if defined(HD_HAS_overrideColor)
-    // Mix in override color
-    vec4 overrideColor = HdGet_overrideColor();
-    color.rgb = mix(color.rgb, overrideColor.rgb, overrideColor.a);
-#endif
-    return ApplySelectionColor(color);
-}
-
-vec3 ApplyMaskColor(vec3 color, float weight, vec4 maskColor)
-{
-    float strength = maskColor.a * clamp(weight, 0.0, 1.0);
-    return mix(color, maskColor.rgb, strength);
-}
-
-vec4 ApplyColorOverridesPostLighting(vec4 color)
-{
-    #if defined(HD_HAS_maskWeight)
-        float maskWeight = HdGet_maskWeight();
-        vec4 maskColor = GetMaskColor();
-        color.rgb = ApplyMaskColor(color.rgb, maskWeight, maskColor);
-    #endif
-    #if defined(HD_HAS_indicatorWeight)
-        float indicatorWeight = HdGet_indicatorWeight();
-        vec4 indicatorColor = GetIndicatorColor();
-        color.rgb = ApplyMaskColor(color.rgb, indicatorWeight, indicatorColor);
-    #endif
-    return color;
-}
-
--- glsl RenderPass.RenderOutput
-
-void RenderOutput(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
-{
-    // Write to any desired AOVs here. The render pass shader configuation 
-    // decides if any of these are no-ops.
-    RenderColor(color);
-    RenderId();
-    RenderNeye(Neye);
-}
-
--- layout RenderPass.RenderColor
-
-[
-    ["out", "vec4", "colorOut"]
-]
-
--- glsl RenderPass.RenderColor
-
-void RenderColor(vec4 color)
-{
-    colorOut = color;
-}
-
--- glsl RenderPass.RenderColorNoOp
-
-void RenderColor(vec4 color)
-{
-    // do nothing
-}
-
--- layout RenderPass.RenderId
-
-[
-    ["out", "int", "primIdOut"],
-    ["out", "int", "instanceIdOut"]
-]
-
--- glsl RenderPass.RenderId
-
-void RenderId()
-{
-    primIdOut = HdGet_primID();
-
-    // instanceIndex is a tuple of integers (num nested levels).
-    // for picking, we store global instanceId (instanceIndex[0]) in the
-    // selection framebuffer and then reconstruct the tuple in postprocess.
-    instanceIdOut = GetDrawingCoord().instanceIndex[0];
-}
-
--- glsl RenderPass.RenderIdNoOp
-
-void RenderId()
-{
-    // do nothing
-}
-
--- layout RenderPass.RenderNeye
-
-[
-    ["out", "vec4", "NeyeOut"]
-]
-
--- glsl RenderPass.RenderNeye
-
-void RenderNeye(vec3 Neye)
-{
-    NeyeOut = vec4(Neye, 1.0);
-}
-
--- glsl RenderPass.RenderNeyeNoOp
-
-void RenderNeye(vec3 Neye)
-{
-    // do nothing
-}
-