@tushar-br/editing-pack 1.0.194 → 1.0.195

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

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

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