@reearth/core 0.0.1

package/src/engines/Cesium/PostProcesses/hbao/createCrossBilateralFilterStage.ts

@@ -0,0 +1,94 @@
+import { PostProcessStage, PostProcessStageComposite, PostProcessStageSampleMode } from "cesium";
+import { defaults } from "lodash-es";
+
+import { createUniforms } from "../../helpers/createUniforms";
+
+import { type AmbientOcclusionOutputType } from "./AmbientOcclusionOutputType";
+import crossBilateralFilter from "./shaders/crossBilateralFilter.glsl?raw";
+import depth from "./shaders/depth.glsl?raw";
+import globeDepth from "./shaders/globeDepth.glsl?raw";
+import packing from "./shaders/packing.glsl?raw";
+import reconstructPosition from "./shaders/reconstructPosition.glsl?raw";
+
+interface PrivatePostProcessStage extends PostProcessStage {
+  _depthTexture: unknown;
+}
+
+export interface CrossBilateralFilterStageUniforms {
+  textureScale: number;
+  frustumLength: number;
+  normalExponent: number;
+  depthExponent: number;
+}
+
+const defaultUniforms: CrossBilateralFilterStageUniforms = {
+  textureScale: 1,
+  frustumLength: 1e5,
+  normalExponent: 5,
+  depthExponent: 1,
+};
+
+export interface CrossBilateralFilterStageOptions {
+  prefix?: string;
+  outputType?: AmbientOcclusionOutputType | null;
+  useGlobeDepth?: boolean;
+  getGlobeDepthTexture?: () => unknown | undefined;
+  uniforms?: Partial<CrossBilateralFilterStageUniforms>;
+}
+
+export function createBilateralFilterStage({
+  prefix = "reearth",
+  outputType = null,
+  useGlobeDepth = false,
+  getGlobeDepthTexture,
+  uniforms: uniformsOption,
+}: CrossBilateralFilterStageOptions): PostProcessStageComposite {
+  const uniforms = defaults({}, uniformsOption, defaultUniforms);
+
+  const blurX = new PostProcessStage({
+    name: `${prefix}_ambient_occlusion_cross_bilateral_filter_x`,
+    fragmentShader: `
+      #define DIRECTION (0)
+      ${outputType != null ? `#define OUTPUT_TYPE (${outputType})` : ""}
+      ${useGlobeDepth ? globeDepth : depth}
+      ${packing}
+      ${reconstructPosition}
+      ${crossBilateralFilter}
+    `,
+    uniforms: {
+      ...uniforms,
+      globeDepthTexture: () =>
+        getGlobeDepthTexture?.() ?? (blurX as PrivatePostProcessStage)._depthTexture,
+    },
+    sampleMode: PostProcessStageSampleMode.LINEAR,
+  });
+
+  const blurY = new PostProcessStage({
+    name: `${prefix}_ambient_occlusion_cross_bilateral_filter_y`,
+    fragmentShader: `
+      #define DIRECTION (1)
+      ${outputType != null ? `#define OUTPUT_TYPE (${outputType})` : ""}
+      ${useGlobeDepth ? globeDepth : depth}
+      ${packing}
+      ${reconstructPosition}
+      ${crossBilateralFilter}
+    `,
+    uniforms: {
+      ...uniforms,
+      globeDepthTexture: () =>
+        getGlobeDepthTexture?.() ?? (blurY as PrivatePostProcessStage)._depthTexture,
+    },
+    sampleMode: PostProcessStageSampleMode.LINEAR,
+  });
+
+  return new PostProcessStageComposite({
+    name: `${prefix}_ambient_occlusion_cross_bilateral_filter`,
+    stages: [blurX, blurY],
+    uniforms: createUniforms<CrossBilateralFilterStageUniforms>([
+      {
+        stages: [blurX, blurY],
+        uniforms: ["textureScale", "frustumLength", "normalExponent", "depthExponent"],
+      },
+    ]),
+  });
+}

package/src/engines/Cesium/PostProcesses/hbao/index.ts

@@ -0,0 +1,3 @@
+export * from "./AmbientOcclusion";
+export * from "./AmbientOcclusionOutputType";
+export * from "./createAmbientOcclusionStage";

package/src/engines/Cesium/PostProcesses/hbao/shaders/ambientOcclusionGenerate.glsl

@@ -0,0 +1,151 @@
+#ifndef NUM_DIRECTIONS
+#define NUM_DIRECTIONS (8)
+#endif
+
+#ifndef NUM_STEPS
+#define NUM_STEPS (8)
+#endif
+
+#ifndef OUTPUT_TYPE
+#define OUTPUT_TYPE (0)
+#endif
+
+uniform sampler2D depthTexture;
+uniform float textureScale;
+uniform float intensity;
+uniform float bias;
+uniform float maxRadius;
+uniform float frustumLength;
+uniform vec2 focalLength;
+
+in vec2 v_textureCoordinates;
+
+vec2 rotateDirection(const vec2 dir, const vec2 cosSin) {
+  return vec2(
+    dir.x * cosSin.x - dir.y * cosSin.y,
+    dir.x * cosSin.y + dir.y * cosSin.x
+  );
+}
+
+vec2 getStepSize(const vec3 position) {
+  vec2 uvMaxRadius = focalLength * maxRadius / -position.z;
+  return 0.5 * uvMaxRadius / (float(NUM_STEPS) + 1.0);
+}
+
+vec2 getSnappedUV(const vec2 uv) {
+  return round(uv * czm_viewport.zw) / czm_viewport.zw;
+}
+
+float getBiasedTangent(const vec3 v, const float bias) {
+  return v.z / length(v.xy) + tan(bias);
+}
+
+float getSinFromTan(const float x) {
+  return x * inversesqrt(x * x + 1.0);
+}
+
+// Based on:
+// https://github.com/nvpro-samples/gl_ssao/blob/master/hbao.frag.glsl
+// https://github.com/scanberg/hbao/blob/master/resources/shaders/hbao_full_frag.glsl
+float computeOcclusion(
+  vec3 position,
+  vec3 dPdx,
+  vec3 dPdy,
+  vec2 deltaUV,
+  float randomStep
+) {
+  // Offset the first coord with some noise.
+  vec2 uv = v_textureCoordinates + getSnappedUV(randomStep * deltaUV);
+  deltaUV = getSnappedUV(deltaUV);
+
+  // Calculate the tangent vector.
+  vec3 T = dPdx * deltaUV.x + dPdy * deltaUV.y;
+
+  // Get the angle of the tangent vector from the viewspace axis.
+  float tanT = getBiasedTangent(T, bias);
+  float sinT = getSinFromTan(tanT);
+
+  // Sample to find the maximum angle.
+  float ao = 0.0;
+  float prevSinH = sinT;
+  for (int i = 0; i < NUM_STEPS; ++i) {
+    uv += deltaUV;
+
+    float sampleDepth = readDepth(depthTexture, uv);
+    vec3 samplePosition = reconstructPosition(uv, sampleDepth);
+    vec3 view = samplePosition - position;
+    float len = length(view);
+
+    float tanH = view.z / length(view.xy);
+    float sinH = getSinFromTan(tanH);
+    if (len < maxRadius && sinH > prevSinH) {
+      float falloff = 1.0 - len / maxRadius * (len / maxRadius);
+      ao += (sinH - prevSinH) * falloff;
+      prevSinH = sinH;
+    }
+  }
+
+  return ao;
+}
+
+void main() {
+  vec2 uv = v_textureCoordinates;
+  float depth = readDepth(depthTexture, uv);
+  vec3 position = reconstructPosition(uv, depth);
+
+  #if OUTPUT_TYPE != 1
+  if (-position.z > frustumLength) {
+    out_FragColor = vec4(1.0);
+    return;
+  }
+  #endif
+
+  // Should we take czm_pixelRatio into account?
+  vec2 pixelSize = textureScale / czm_viewport.zw;
+  vec3 dPdx;
+  vec3 dPdy;
+  vec3 normal = reconstructNormal(
+    depthTexture,
+    uv,
+    position,
+    depth,
+    pixelSize,
+    dPdx,
+    dPdy
+  );
+
+  // XY for direction and Z for jitter of the first step.
+  vec3 random = computeHighPassRandom3D(uv);
+
+  float ao = 0.0;
+
+  vec2 stepSize = getStepSize(position);
+  float alpha = czm_twoPi / float(NUM_DIRECTIONS);
+  for (
+    int directionIndex = 0;
+    directionIndex < NUM_DIRECTIONS;
+    ++directionIndex
+  ) {
+    // Compute normalized random direction.
+    float theta = alpha * float(directionIndex);
+    vec2 direction = rotateDirection(
+      vec2(cos(theta), sin(theta)),
+      normalize(2.0 * random.xy - 1.0)
+    );
+
+    ao += computeOcclusion(
+      position,
+      dPdx,
+      dPdy,
+      direction * stepSize,
+      random.z
+    );
+  }
+
+  ao /= float(NUM_DIRECTIONS * NUM_STEPS);
+  ao = 1.0 - 1.0 / czm_twoPi * clamp(ao, 0.0, 1.0);
+  ao = pow(ao, intensity);
+
+  // Reuse normal in bilateral filter and read depth in it again.
+  out_FragColor = vec4(ao, packNormal(normal));
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/ambientOcclusionModulate.glsl

@@ -0,0 +1,46 @@
+#ifndef OUTPUT_TYPE
+#define OUTPUT_TYPE (0)
+#endif
+
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+uniform sampler2D ambientOcclusionTexture;
+
+uniform vec3 color;
+uniform float blackPoint;
+uniform float whitePoint;
+uniform float gamma;
+uniform float frustumLength;
+
+in vec2 v_textureCoordinates;
+
+vec3 shade(vec3 color, float a, float b, float p) {
+  return clamp(
+    b * pow(max(color - a, 0.0), vec3(p)) / pow(1.0 - a, p),
+    vec3(0.0),
+    vec3(1.0)
+  );
+}
+
+void main() {
+  vec4 base = texture(colorTexture, v_textureCoordinates);
+  vec4 ao = texture(ambientOcclusionTexture, v_textureCoordinates);
+
+  #if OUTPUT_TYPE == 1 // Occlusion
+  out_FragColor = vec4(vec3(ao.x), base.a);
+  #elif OUTPUT_TYPE == 2 // Normal
+  out_FragColor = vec4(ao.yzw, base.a);
+  #elif OUTPUT_TYPE == 3 // Depth
+  float depth = -readPosition(depthTexture, v_textureCoordinates).z;
+  out_FragColor = vec4(getTurboColormap(depth / frustumLength), base.a);
+  #elif OUTPUT_TYPE == 4 // Weight
+  out_FragColor = vec4(vec3(ao.x), base.a);
+  #elif OUTPUT_TYPE == 5 // Shade
+  out_FragColor = vec4(shade(base.rgb, blackPoint, whitePoint, gamma), base.a);
+  #else
+  out_FragColor = vec4(
+    mix(base.rgb, shade(base.rgb, blackPoint, whitePoint, gamma), 1.0 - ao.x),
+    base.a
+  );
+  #endif // OUTPUT_TYPE
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/crossBilateralFilter.glsl

@@ -0,0 +1,108 @@
+#define SAMPLES (8.0)
+
+#ifndef OUTPUT_TYPE
+#define OUTPUT_TYPE (0)
+#endif
+
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+uniform float textureScale;
+uniform float frustumLength;
+uniform float normalExponent;
+uniform float depthExponent;
+
+in vec2 v_textureCoordinates;
+
+const float sigma = float(SAMPLES) * 0.5 + 0.5;
+const float falloff = 1.0 / (2.0 * sigma * sigma);
+
+float computeWeight(
+  const vec3 normal,
+  const float depth,
+  const vec3 normal0,
+  const float depth0
+) {
+  // Weights are described here: http://sci.utah.edu/~duong/papers/hoang-mssao-cgi-2011-paper.pdf
+  float normalWeight = pow(
+    clamp(dot(normal0, normal), 0.0, 1.0),
+    normalExponent
+  );
+  float depthWeight = pow(1.0 / (1.0 + abs(depth0 - depth)), depthExponent);
+  return normalWeight * depthWeight;
+}
+
+void addWeight(
+  const vec2 uv,
+  const vec2 d,
+  const vec2 dd,
+  const vec3 normal0,
+  const float depth0,
+  inout float ao,
+  inout float weight
+) {
+  vec4 aon = texture(colorTexture, uv + d);
+  vec3 normal = unpackNormal(aon.yzw);
+  // It will be much faster if we were able to write linear depths in the
+  // generate phase.
+  float depth = readPosition(depthTexture, uv + dd).z;
+  float w = computeWeight(normal, depth, normal0, depth0);
+  ao = aon.x * w + ao;
+  weight += w;
+}
+
+void main() {
+  vec2 uv = v_textureCoordinates;
+  vec4 center = texture(colorTexture, uv);
+  float depth0 = readPosition(depthTexture, uv).z;
+
+  if (-depth0 > frustumLength) {
+    #if OUTPUT_TYPE == 4 // Weight
+    out_FragColor = vec4(vec3(0.0), center.yzw);
+    #else
+    out_FragColor = vec4(vec3(1.0), center.yzw);
+    #endif // OUTPUT_TYPE
+    return;
+  }
+
+  vec3 normal0 = unpackNormal(center.yzw);
+
+  #if OUTPUT_TYPE == 4 // Weight
+  float prevWeight = center.x;
+  #endif
+
+  vec2 pixelSize = 1.0 / czm_viewport.zw;
+  #if DIRECTION == 0
+  vec2 delta = vec2(pixelSize.x, 0.0) / textureScale;
+  vec2 depthDelta = vec2(pixelSize.x, 0.0) * czm_pixelRatio;
+  #else
+  vec2 delta = vec2(0.0, pixelSize.y) / textureScale;
+  vec2 depthDelta = vec2(0.0, pixelSize.y) * czm_pixelRatio;
+  #endif // DIRECTION
+
+  float ao = center.x;
+  float weight = 1.0;
+  float r = 1.0;
+
+  for (; r <= SAMPLES / 2.0; r += 1.0) {
+    vec2 d = r * delta;
+    vec2 dd = r * depthDelta;
+    addWeight(uv, d, dd, normal0, depth0, ao, weight);
+    addWeight(uv, -d, -dd, normal0, depth0, ao, weight);
+  }
+  for (r += 0.5; r <= SAMPLES; r += 2.0) {
+    vec2 d = r * delta;
+    vec2 dd = r * depthDelta;
+    addWeight(uv, d, dd, normal0, depth0, ao, weight);
+    addWeight(uv, -d, -dd, normal0, depth0, ao, weight);
+  }
+
+  #if OUTPUT_TYPE == 4 // Weight
+  #if DIRECTION == 0
+  out_FragColor = vec4(weight * 0.05, center.yzw);
+  #else
+  out_FragColor = vec4(prevWeight + weight * 0.05, center.yzw);
+  #endif // DIRECTION
+  #else
+  out_FragColor = vec4(ao / weight, center.yzw);
+  #endif // OUTPUT_TYPE
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/depth.glsl

@@ -0,0 +1,3 @@
+float readDepth(sampler2D depthTexture, vec2 texCoords) {
+  return czm_reverseLogDepth(texture(depthTexture, texCoords).r);
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/globeDepth.glsl

@@ -0,0 +1,15 @@
+uniform sampler2D globeDepthTexture;
+
+float readDepth(sampler2D depthTexture, vec2 texCoords) {
+  // The depth texture doesn't include the terrain depth if
+  // globe.depthTestAgainstTerrain is false, but terrain depth should be taken
+  // into account to compute ambient occlusion. Automatic uniform
+  // czm_globeDepthTexture always includes the terrain depth.
+  // Assume that the terrain is always higher than ellipsoid.
+  return czm_reverseLogDepth(
+    min(
+      texture(depthTexture, texCoords).r,
+      czm_unpackDepth(texture(globeDepthTexture, texCoords))
+    )
+  );
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/highPassRandom.glsl

@@ -0,0 +1,28 @@
+// Based on https://github.com/pmndrs/drei/blob/master/src/core/softShadows.tsx
+
+vec3 computeRandom3D(const vec2 uv) {
+  return vec3(
+    fract(sin(dot(uv, vec2(12.75613, 38.12123))) * 13234.76575),
+    fract(sin(dot(uv, vec2(19.45531, 58.46547))) * 43678.23431),
+    fract(sin(dot(uv, vec2(23.67817, 78.23121))) * 93567.23423)
+  );
+}
+
+vec3 computeLowPassRandom3D(const vec2 uv) {
+  vec3 result = vec3(0.0);
+  result += computeRandom3D(uv + vec2(-1.0, -1.0));
+  result += computeRandom3D(uv + vec2(-1.0, 0.0));
+  result += computeRandom3D(uv + vec2(-1.0, 1.0));
+  result += computeRandom3D(uv + vec2(0.0, -1.0));
+  result += computeRandom3D(uv + vec2(0.0, 0.0));
+  result += computeRandom3D(uv + vec2(0.0, 1.0));
+  result += computeRandom3D(uv + vec2(1.0, -1.0));
+  result += computeRandom3D(uv + vec2(1.0, 0.0));
+  result += computeRandom3D(uv + vec2(1.0, 1.0));
+  result *= 0.111111111; // 1.0 / 9.0
+  return result;
+}
+
+vec3 computeHighPassRandom3D(const vec2 uv) {
+  return computeRandom3D(uv) - computeLowPassRandom3D(uv) + 0.5;
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/packing.glsl

@@ -0,0 +1,7 @@
+vec3 packNormal(const vec3 normal) {
+  return normalize(normal) * 0.5 + 0.5;
+}
+
+vec3 unpackNormal(const vec3 normal) {
+  return normal * 2.0 - 1.0;
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/reconstructNormal.glsl

@@ -0,0 +1,109 @@
+vec3 getMinDiff(const vec3 position, const vec3 right, const vec3 left) {
+  vec3 v1 = right - position;
+  vec3 v2 = position - left;
+  return dot(v1, v1) < dot(v2, v2)
+    ? v1
+    : v2;
+}
+
+// Based on https://wickedengine.net/2019/09/22/improved-normal-reconstruction-from-depth/
+vec3 reconstructNormalNaive(
+  const sampler2D depthTexture,
+  const vec2 uv,
+  const vec3 position,
+  const float depth,
+  const vec2 pixelSize,
+  out vec3 dPdx,
+  out vec3 dPdy
+) {
+  vec2 ddx = vec2(pixelSize.x, 0.0);
+  vec2 ddy = vec2(0.0, pixelSize.y);
+
+  vec3 up = readPosition(depthTexture, uv + ddy);
+  vec3 down = readPosition(depthTexture, uv - ddy);
+  vec3 right = readPosition(depthTexture, uv + ddx);
+  vec3 left = readPosition(depthTexture, uv - ddx);
+
+  dPdx = getMinDiff(position, right, left);
+  dPdy = getMinDiff(position, up, down);
+
+  return normalize(cross(dPdy, dPdx));
+}
+
+vec3 readMinDiff(
+  const sampler2D depthTexture,
+  const vec2 uv,
+  const vec3 position,
+  const float depth,
+  const vec4 depths,
+  const vec2 delta
+) {
+  vec2 e = abs(depths.xy * depths.zw / (2.0 * depths.zw - depths.xy) - depth);
+  return e.x > e.y
+    ? readPosition(depthTexture, uv + delta) - position
+    : position - readPosition(depthTexture, uv - delta);
+}
+
+// Based on https://atyuwen.github.io/posts/normal-reconstruction/
+vec3 reconstructNormalAccurate(
+  const sampler2D depthTexture,
+  const vec2 uv,
+  const vec3 position,
+  const float depth,
+  const vec2 pixelSize,
+  out vec3 dPdx,
+  out vec3 dPdy
+) {
+  vec2 ddx = vec2(pixelSize.x, 0.0);
+  vec2 ddy = vec2(0.0, pixelSize.y);
+
+  vec4 H = vec4(
+    readDepth(depthTexture, uv - ddx),
+    readDepth(depthTexture, uv + ddx),
+    readDepth(depthTexture, ddx * -2.0 + uv),
+    readDepth(depthTexture, ddx * 2.0 + uv)
+  );
+  vec4 V = vec4(
+    readDepth(depthTexture, uv - ddy),
+    readDepth(depthTexture, uv + ddy),
+    readDepth(depthTexture, ddy * -2.0 + uv),
+    readDepth(depthTexture, ddy * 2.0 + uv)
+  );
+
+  dPdx = readMinDiff(depthTexture, uv, position, depth, H, ddx);
+  dPdy = readMinDiff(depthTexture, uv, position, depth, V, ddy);
+
+  return normalize(cross(dPdy, dPdx));
+}
+
+vec3 reconstructNormal(
+  const sampler2D depthTexture,
+  const vec2 uv,
+  const vec3 position,
+  const float depth,
+  const vec2 pixelSize,
+  out vec3 dPdx,
+  out vec3 dPdy
+) {
+  #ifdef USE_ACCURATE_NORMAL
+  return reconstructNormalAccurate(
+    depthTexture,
+    uv,
+    position,
+    depth,
+    pixelSize,
+    dPdx,
+    dPdy
+  );
+  #else
+  return reconstructNormalNaive(
+    depthTexture,
+    uv,
+    position,
+    depth,
+    pixelSize,
+    dPdx,
+    dPdy
+  );
+  #endif
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/reconstructPosition.glsl

@@ -0,0 +1,10 @@
+vec3 reconstructPosition(const vec2 uv, const float depth) {
+  vec2 xy = vec2(uv.x * 2.0 - 1.0, (1.0 - uv.y) * 2.0 - 1.0);
+  vec4 position = czm_inverseProjection * vec4(xy, depth, 1.0);
+  position = position / position.w;
+  return position.xyz;
+}
+
+vec3 readPosition(const sampler2D depthTexture, const vec2 uv) {
+  return reconstructPosition(uv, readDepth(depthTexture, uv));
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/turboColorMap.glsl

@@ -0,0 +1,20 @@
+// Derived from https://gist.github.com/mikhailov-work/0d177465a8151eb6ede1768d51d476c7
+
+const vec4 kRedVec4 = vec4(0.13572138, 4.6153926, -42.66032258, 132.13108234);
+const vec4 kGreenVec4 = vec4(0.09140261, 2.19418839, 4.84296658, -14.18503333);
+const vec4 kBlueVec4 = vec4(0.1066733, 12.64194608, -60.58204836, 110.36276771);
+const vec2 kRedVec2 = vec2(-152.94239396, 59.28637943);
+const vec2 kGreenVec2 = vec2(4.27729857, 2.82956604);
+const vec2 kBlueVec2 = vec2(-89.90310912, 27.34824973);
+
+vec3 getTurboColormap(const float v) {
+  float x = clamp(v, 0.0, 1.0);
+  float x2 = x * x;
+  vec4 v4 = vec4(1.0, x, x2, x2 * x);
+  vec2 v2 = v4.zw * v4.z;
+  return vec3(
+    dot(v4, kRedVec4) + dot(v2, kRedVec2),
+    dot(v4, kGreenVec4) + dot(v2, kGreenVec2),
+    dot(v4, kBlueVec4) + dot(v2, kBlueVec2)
+  );
+}

package/src/engines/Cesium/PostProcesses/hbao/shaders/vogelDisk.glsl

@@ -0,0 +1,13 @@
+// Derived from https://www.gamedev.net/tutorials/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
+
+float getInterleavedGradientNoise(const vec2 uv) {
+  vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
+  return fract(magic.z * fract(dot(uv, magic.xy)));
+}
+
+vec3 getVogelDisk(const float index, const float count, const float phi) {
+  float goldenAngle = 2.4;
+  float theta = index * goldenAngle + phi;
+  float r = sqrt(index + 0.5) / sqrt(count);
+  return vec3(cos(theta), sin(theta), r);
+}

package/src/engines/Cesium/Shaders/CustomShaders/NonPBRLightingShader.ts

@@ -0,0 +1,66 @@
+import {
+  CustomShader,
+  CustomShaderMode,
+  CustomShaderTranslucencyMode,
+  LightingModel,
+} from "cesium";
+
+export const NonPBRWithTextureLightingShader = new CustomShader({
+  mode: CustomShaderMode.MODIFY_MATERIAL, // Need lighting
+  lightingModel: LightingModel.PBR,
+  translucencyMode: CustomShaderTranslucencyMode.OPAQUE,
+  fragmentShaderText: /* glsl */ `
+    void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
+      vec4 baseColorWithAlpha = vec4(1.0);
+
+      // Use texture
+      // ref: https://github.com/CesiumGS/cesium/blob/50468896ca7d6071e0f8fb359598c03879fbf0a2/packages/engine/Source/Shaders/Model/MaterialStageFS.glsl#L71-L85
+      #ifdef HAS_BASE_COLOR_TEXTURE 
+        vec2 baseColorTexCoords = TEXCOORD_BASE_COLOR;
+
+        #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM
+          baseColorTexCoords = computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);
+        #endif
+
+        baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));
+
+        #ifdef HAS_BASE_COLOR_FACTOR
+          baseColorWithAlpha *= u_baseColorFactor;
+        #endif
+      #endif
+
+      // Use attribute's color
+      // ref: https://github.com/CesiumGS/cesium/blob/50468896ca7d6071e0f8fb359598c03879fbf0a2/packages/engine/Source/Shaders/Model/MaterialStageFS.glsl#L89
+      #ifdef HAS_POINT_CLOUD_COLOR_STYLE
+      baseColorWithAlpha = v_pointCloudColor;
+      #elif defined(HAS_COLOR_0)
+      vec4 color = fsInput.attributes.color_0;
+          // .pnts files store colors in the sRGB color space
+          #ifdef HAS_SRGB_COLOR
+          color = czm_srgbToLinear(color);
+          #endif
+      baseColorWithAlpha *= color;
+      #endif
+
+      material.diffuse = baseColorWithAlpha.rgb;
+
+      material.specular = vec3(0.0);
+      material.emissive = vec3(0.0);
+      material.alpha = 1.0;
+    }
+  `,
+});
+
+export const NonPBRLightingShader = new CustomShader({
+  mode: CustomShaderMode.MODIFY_MATERIAL, // Need lighting
+  lightingModel: LightingModel.PBR,
+  translucencyMode: CustomShaderTranslucencyMode.OPAQUE,
+  fragmentShaderText: /* glsl */ `
+    void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
+      material.diffuse = vec3(1.);
+      material.specular = vec3(0.0);
+      material.emissive = vec3(0.0);
+      material.alpha = 1.0;
+    }
+  `,
+});

package/src/engines/Cesium/Shaders/OverriddenShaders/GlobeFS/Definitions.glsl

@@ -0,0 +1,5 @@
+uniform vec3 u_reearth_sphericalHarmonicCoefficients[9];
+uniform bool u_reearth_globeImageBasedLighting;
+
+vec4 reearth_computeImageBasedLightingColor(vec4 color);
+vec3 reearth_calculateElevationMapForGlobe(vec4 colorToAlpha, vec3 color);