@meimu/mutracer 0.1.4 → 0.1.5

package/lib/renderer/glsl/chunks/sampleMaterial.glsl.js

@@ -2,24 +2,24 @@
 // http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral
 import { glsl } from '../../shader.js';
 export default glsl `
-vec3 mU(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gE) {
-float mD = 1.0;
-vec3 ln = vec3(fo(cw(LIGHT_POSITION)), dz(cw(LIGHT_SELECT)));
+vec3 mT(ad si, J mat, ag prepared, inout Path aa, vec3 ffnormal, bool gF) {
+float mC = 1.0;
+vec3 ln = vec3(fp(cw(LIGHT_POSITION)), dz(cw(LIGHT_SELECT)));
 
 LightSampleRec lightSample;
 sampleLight(si.position, ln, lightSample, false);
 lightSample.emission = ai(lightSample.emission, bf);
 
 vec3 lightDir = lightSample.direction;
-vec3 oT = -aa.ray.d;
+vec3 oS = -aa.ray.d;
 float fg = lightSample.pdf;
 
 
 
 
 float cosThetaL = dot(ffnormal, lightDir);
-#ifdef NUM_COAT_NORMAL_MAPS
-if (gE && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
+#ifdef USE_COAT_NORMAL_FRAMES
+if (gF && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }
 #endif
 
 if (fg <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {
@@ -28,7 +28,7 @@ return vec3(0.0);
 
 float scatteringPdf = 0.0;
 vec3 f = vec3(0.0);
-if (gE) {
+if (gF) {
 if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {
 return vec3(0.0);
 }
@@ -36,7 +36,7 @@ f = bI(prepared, lightDir, scatteringPdf);
 }
 else {
 scatteringPdf = bD(
-dot(oT, lightDir),
+dot(oS, lightDir),
 si.mediumAnisotropy
 );
 f = vec3(scatteringPdf);
@@ -46,36 +46,36 @@ if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {
 return vec3(0.0);
 }
 
-Ray mA;
+Ray mz;
 vec3 hi = si.position + EPS * lightDir;
-if (gE) {
+if (gF) {
 const float bZ = 0.1;
 float dr = dot(si.normal, lightDir);
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (mat.coatNormalEnabled) { dr = dot(si.faceNormal, lightDir); }
 #endif
 vec3 geometricNormal = dr < 0.0 ? -si.faceNormal : si.faceNormal;
 dr = abs(dr);
 float hS = dot(geometricNormal, lightDir);
-float oC = dr < bZ
+float oB = dr < bZ
 ? clamp(
 2.0 - (hS + dr) / bZ,
 0.0,
 1.0
 )
 : clamp(1.0 - hS / bZ, 0.0, 1.0);
-hi += si.shadowOffset * oC;
+hi += si.shadowOffset * oB;
 }
-iC(mA, hi, lightDir);
-if (ex(mA, lightSample.dist - EPS, si.triangleIndex)) {
+iC(mz, hi, lightDir);
+if (ex(mz, lightSample.dist - EPS, si.triangleIndex)) {
 return vec3(0.0);
 }
 
 #ifdef USE_ENVMAP
 
 
-if (gE && cosThetaL < 0.0 && ln.z < envLightSelectionPmf) {
-vec4 background = cx(mA.o, lightDir);
+if (gF && cosThetaL < 0.0 && ln.z < envLightSelectionPmf) {
+vec4 background = cx(mz.o, lightDir);
 lightSample.emission = ai(background.rgb * background.a, bf);
 }
 #endif
@@ -90,8 +90,8 @@ return fa > 0.0
 : vec3(0.0);
 }
 
-#ifdef NUM_COAT_NORMAL_MAPS
-vec3 fE(vec3 pG, vec3 tq, vec3 view) {
+#ifdef USE_COAT_NORMAL_FRAMES
+vec3 fF(vec3 pG, vec3 tq, vec3 view) {
 bool qY = dot(tq, view) >= 0.0;
 vec3 uo = qY ? tq : -tq;
 vec3 qX = qY ? pG : -pG;
@@ -99,11 +99,11 @@ if (dot(pG, tq) <= 0.0 || dot(qX, view) <= 1e-6) { return uo; }
 return qX;
 }
 #endif
-void mc(inout ad si, J mat, inout Path aa) {
-vec3 ur = vec3(fo(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
-#ifdef NUM_COAT_NORMAL_MAPS
+void mb(inout ad si, J mat, inout Path aa) {
+vec3 ur = vec3(fp(cw(BSDF_DIRECTION)), dz(cw(BSDF_LOBE)));
+#ifdef USE_COAT_NORMAL_FRAMES
 vec3 bC = si.faceNormal;
-vec3 mF = si.normal;
+vec3 mE = si.normal;
 #endif
 float rN = -dot(si.faceNormal, aa.ray.d);
 float sG = -dot(si.normal, aa.ray.d);
@@ -128,15 +128,15 @@ mat.inside = ndv <= 0.0 && !mat.thinWalled;
 
 mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;
 vec3 ffnormal = ndv >= 0.0 ? normal : -normal;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (mat.coatNormalEnabled) {
 vec3 view = -aa.ray.d;
-float ga = dot(bC, view);
-mat.geometricNormal = ga >= 0.0 ? bC : -bC;
-ffnormal = fE(mF, bC, view);
-mat.coatNormal = fE(si.coatNormal, bC, view);
-mat.inside = ga <= 0.0 && !mat.thinWalled;
-mat.relativeIor = (ga > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
+float gb = dot(bC, view);
+mat.geometricNormal = gb >= 0.0 ? bC : -bC;
+ffnormal = fF(mE, bC, view);
+mat.coatNormal = fF(si.coatNormal, bC, view);
+mat.inside = gb <= 0.0 && !mat.thinWalled;
+mat.relativeIor = (gb > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;
 }
 #endif
 
@@ -151,7 +151,7 @@ ag prepared;
 #ifdef HAS_MEDIUM
 int mediumType = si.mediumType;
 float d = distance(si.position, aa.ray.o);
-vec3 nv = aa.ray.o;
+vec3 nu = aa.ray.o;
 vec3 extinction = si.mediumExtinction;
 vec3 scattering = min(si.mediumScattering, extinction);
 float sC = max(max(extinction.x, extinction.y), extinction.z);
@@ -160,32 +160,32 @@ if (mediumType > 0 && sC > 0.0) {
 
 
 
-int nk = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
-float fD = extinction[nk];
-float ih = fD > 0.0
-? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fD, d)
+int nj = min(int(dz(cw(MEDIUM_CHANNEL)) * 3.0), 2);
+float fE = extinction[nj];
+float ih = fE > 0.0
+? min(-log(max(dz(cw(MEDIUM_DISTANCE)), 1e-7)) / fE, d)
 : d;
 bl = ih < d;
 vec3 ew = exp(-extinction * ih);
-vec3 oa = bl
+vec3 nZ = bl
 ? extinction * ew
 : ew;
-float nL = max(
-(oa.x + oa.y + oa.z) / 3.0,
+float nK = max(
+(nZ.x + nZ.y + nZ.z) / 3.0,
 1e-8
 );
 if (bl) {
-aa.beta *= ew * scattering / nL;
+aa.beta *= ew * scattering / nK;
 
-aa.ray.o = nv + ih * aa.ray.d;
+aa.ray.o = nu + ih * aa.ray.d;
 si.position = aa.ray.o;
-aa.li += mU(si, mat, prepared, aa, ffnormal, false) * aa.beta;
+aa.li += mT(si, mat, prepared, aa, ffnormal, false) * aa.beta;
 
 
-cG = fp(
+cG = fq(
 -aa.ray.d,
 si.mediumAnisotropy,
-fo(cw(PHASE_DIRECTION))
+fp(cw(PHASE_DIRECTION))
 );
 scatteringPdf = bD(
 dot(cG, -aa.ray.d),
@@ -193,7 +193,7 @@ si.mediumAnisotropy
 );
 }
 else {
-aa.beta *= ew / nL;
+aa.beta *= ew / nK;
 }
 }
 #endif
@@ -214,7 +214,7 @@ mat.directionBitangent = si.directionBitangent;
 mat.geometryTangent = si.geometryTangent;
 mat.geometryBitangent = si.geometryBitangent;
 prepared = eH(pS, mat, -aa.ray.d, ffnormal);
-aa.li += mU(si, mat, prepared, aa, ffnormal, true) * aa.beta;
+aa.li += mT(si, mat, prepared, aa, ffnormal, true) * aa.beta;
 
 bool isNextRefraction;
 vec3 f = dv(
@@ -244,7 +244,7 @@ aa.isNextRefraction = isNextRefraction;
 
 
 aa.ray.o = si.position + EPS * cG;
-#ifdef NUM_COAT_NORMAL_MAPS
+#ifdef USE_COAT_NORMAL_FRAMES
 if (mat.coatNormalEnabled) { aa.ray.o = si.position + EPS * (dot(bC, cG) >= 0.0 ? bC : -bC); }
 #endif
 }

package/lib/renderer/glsl/chunks/sampleMaterial.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"sampleMaterial.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleMaterial.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRlB,CAAC","sourcesContent":["// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\nexport default glsl`\nvec3 DirectLight(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {\n  float occluded = 1.0;\n  vec3 lightRnd = vec3(sample2D(bounceDim(LIGHT_POSITION)), sample1D(bounceDim(LIGHT_SELECT)));\n\n  LightSampleRec lightSample;\n  sampleLight(si.position, lightRnd, lightSample, false);\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n\n  vec3 lightDir = lightSample.direction;\n  vec3 viewDir = -path.ray.d;\n  float lightPdf = lightSample.pdf;\n  // Opaque surfaces are rendered two-sided by the core renderer. Use the\n  // face-forward shading normal here as well, otherwise the early-out rejects\n  // every direct-light sample seen from the back of a triangle (for example\n  // the inside of an imported room wall).\n  float cosThetaL = dot(ffnormal, lightDir);\n#ifdef NUM_COAT_NORMAL_MAPS\n  if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }\n#endif\n\n  if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  float scatteringPdf = 0.0;\n  vec3 f = vec3(0.0);\n  if (isSurface) {\n    if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {\n      return vec3(0.0);\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      si.mediumAnisotropy\n    );\n    f = vec3(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  Ray lightRay;\n  vec3 shadowOrigin = si.position + EPS * lightDir;\n  if (isSurface) {\n    const float shadowTerminatorCutoff = 0.1;\n    float normalLight = dot(si.normal, lightDir);\n#ifdef NUM_COAT_NORMAL_MAPS\n    if (mat.coatNormalEnabled) { normalLight = dot(si.faceNormal, lightDir); }\n#endif\n    vec3 geometricNormal = normalLight < 0.0 ? -si.faceNormal : si.faceNormal;\n    normalLight = abs(normalLight);\n    float geometricLight = dot(geometricNormal, lightDir);\n    float offsetAmount = normalLight < shadowTerminatorCutoff\n      ? clamp(\n          2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n          0.0,\n          1.0\n        )\n      : clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0);\n    shadowOrigin += si.shadowOffset * offsetAmount;\n  }\n  initRay(lightRay, shadowOrigin, lightDir);\n  if (intersectSceneShadow(lightRay, lightSample.dist - EPS, si.triangleIndex)) {\n    return vec3(0.0);\n  }\n\n#ifdef USE_ENVMAP\n  // Match the endpoint used by a BSDF-sampled surface transmission, including\n  // a separately displayed or grounded background and its coverage.\n  if (isSurface && cosThetaL < 0.0 && lightRnd.z < envLightSelectionPmf) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathWavelength);\n  }\n#endif\n\n  // Delta lights cannot be sampled by the BSDF strategy, so their MIS weight\n  // is exactly one even when their light-selection PMF is small.\n  float misWeight = lightSample.isDelta\n    ? 1.0\n    : sampling_power_heuristic(lightPdf, scatteringPdf);\n  return misWeight > 0.0\n    ? misWeight * lightSample.emission * f / lightPdf\n    : vec3(0.0);\n}\n\n#ifdef NUM_COAT_NORMAL_MAPS\nvec3 coat_frame_normal(vec3 inputNormal, vec3 face, vec3 view) {\n  bool front = dot(face, view) >= 0.0;\n  vec3 ffFace = front ? face : -face;\n  vec3 ffInput = front ? inputNormal : -inputNormal;\n  if (dot(inputNormal, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n#endif\nvoid SampleMaterial(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {\n  vec3 matRnd = vec3(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n#ifdef NUM_COAT_NORMAL_MAPS\n  vec3 originalFace = si.faceNormal;\n  vec3 originalNormal = si.normal;\n#endif\n  float ndv1 = -dot(si.faceNormal, path.ray.d);\n  float ndv2 = -dot(si.normal, path.ray.d);\n  if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {\n    // Always treat thin material as entering medium\n    if (ndv1 < 0.0) {\n      si.faceNormal = -si.faceNormal;\n      ndv1 = -ndv1;\n    }\n    if (ndv2 < 0.0) {\n      si.normal = -si.normal;\n      ndv2 = -ndv2;\n    }\n  }\n  // In same edge cases normal is not torwards the camera while we can still see the face.\n  // We need to choose faceNormal in this case.\n  bool useFaceN = ndv1 >= 0.0 && ndv2 < 0.0;\n  float ndv = useFaceN ? ndv1 : ndv2;\n  vec3 normal = useFaceN ? si.faceNormal : si.normal;\n\n  mat.inside = ndv <= 0.0 && !mat.thinWalled;\n  // In or out\n  mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;\n  vec3 ffnormal = ndv >= 0.0 ? normal : -normal;\n#ifdef NUM_COAT_NORMAL_MAPS\n  if (mat.coatNormalEnabled) {\n    vec3 view = -path.ray.d;\n    float geometricView = dot(originalFace, view);\n    mat.geometricNormal = geometricView >= 0.0 ? originalFace : -originalFace;\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    mat.coatNormal = coat_frame_normal(si.coatNormal, originalFace, view);\n    mat.inside = geometricView <= 0.0 && !mat.thinWalled;\n    mat.relativeIor = (geometricView > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;\n  }\n#endif\n\n\n  float scatteringPdf;\n  vec3 scatterDir;\n  path.scatteringIsDelta = false;\n  bool mediumSampled = false;\n  bool crossedBoundary = false;\n  OpenPbrPreparedBsdf prepared;\n\n#ifdef HAS_MEDIUM\n  int mediumType = si.mediumType;\n  float d = distance(si.position, path.ray.o);\n  vec3 segmentOrigin = path.ray.o;\n  vec3 extinction = si.mediumExtinction;\n  vec3 scattering = min(si.mediumScattering, extinction);\n  float majorant = max(max(extinction.x, extinction.y), extinction.z);\n  if (mediumType > 0 && majorant > 0.0) {\n    // Sample one RGB extinction channel and divide by the mixture PDF. This\n    // is the homogeneous-medium estimator used by PBRT and avoids the very\n    // large exp((majorant - extinction) * distance) weights produced by\n    // majorant tracking when OpenPBR SSS radii differ strongly by channel.\n    int mediumChannel = min(int(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n    float channelExtinction = extinction[mediumChannel];\n    float scatterDist = channelExtinction > 0.0\n      ? min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d)\n      : d;\n    mediumSampled = scatterDist < d;\n    vec3 transmittance = exp(-extinction * scatterDist);\n    vec3 density = mediumSampled\n      ? extinction * transmittance\n      : transmittance;\n    float mediumPdf = max(\n      (density.x + density.y + density.z) / 3.0,\n      1e-8\n    );\n    if (mediumSampled) {\n      path.beta *= transmittance * scattering / mediumPdf;\n      // Move from the start of the segment, not from its end surface.\n      path.ray.o = segmentOrigin + scatterDist * path.ray.d;\n      si.position = path.ray.o;\n      path.li += DirectLight(si, mat, prepared, path, ffnormal, false) * path.beta;\n\n      // Pick a new direction based on the phase function\n      scatterDir = sampling_henyey_greenstein(\n        -path.ray.d,\n        si.mediumAnisotropy,\n        sample2D(bounceDim(PHASE_DIRECTION))\n      );\n      scatteringPdf = sampling_henyey_greenstein_phase(\n        dot(scatterDir, -path.ray.d),\n        si.mediumAnisotropy\n      );\n    }\n    else {\n      path.beta *= transmittance / mediumPdf;\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    path.li += mat.emission * path.beta;\n    if (mat.materialType == UNLIT) {\n      path.abort = true;\n      return;\n    }\n    vec3 surfaceTangent = vec3(0.0);\n#ifdef USE_TANGENT\n    surfaceTangent = si.tangent;\n#endif\n    mat.directionTangent = si.directionTangent;\n    mat.directionBitangent = si.directionBitangent;\n    mat.geometryTangent = si.geometryTangent;\n    mat.geometryBitangent = si.geometryBitangent;\n    prepared = openpbr_prepare(surfaceTangent, mat, -path.ray.d, ffnormal);\n    path.li += DirectLight(si, mat, prepared, path, ffnormal, true) * path.beta;\n    // Sample BSDF for color and outgoing direction\n    bool isNextRefraction;\n    vec3 f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      scatterDir,\n      scatteringPdf,\n      isNextRefraction\n    );\n    // Null-boundary transmission is discrete and has no NEE competitor.\n    path.scatteringIsDelta = !prepared.material.thinWalled &&\n      abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&\n      prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;\n    // Match WebGPU: rejected VNDF/refraction proposals have no continuation.\n    // Tracing their fallback direction with the incoming throughput invents\n    // light paths, especially after total internal reflection inside glass.\n    if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      path.scatteringPdf = 0.0;\n      path.abort = true;\n      return;\n    }\n    path.beta *= f / scatteringPdf;\n    crossedBoundary = !mat.thinWalled &&\n      isNextRefraction;\n    path.isNextRefraction = isNextRefraction;\n    // TODO prefer the opaque surface when transmission surface and opaque surface are overlapped.\n    // Or the ray go out from transmission material will miss the opque surface.\n    path.ray.o = si.position + EPS * scatterDir;\n#ifdef NUM_COAT_NORMAL_MAPS\n    if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(originalFace, scatterDir) >= 0.0 ? originalFace : -originalFace); }\n#endif\n  }\n\n  path.scatteringPdf = scatteringPdf;\n  initRay(path.ray, path.ray.o, scatterDir);\n  if (mediumSampled) {\n    path.isNextRefraction = false;\n  }\n  path.fromEye = false;\n\n#ifdef HAS_MEDIUM\n  // A reflected ray stays in its current medium. Only a sampled transmission\n  // event crosses the boundary of a medium-bearing closed mesh.\n  if (!mediumSampled && crossedBoundary && mat.mediumType > 0) {\n    if (ndv1 >= 0.0) {\n      si.mediumType = mat.mediumType;\n      si.mediumExtinction = mat.mediumExtinction;\n      si.mediumScattering = mat.mediumScattering;\n      si.mediumAnisotropy = mat.mediumAnisotropy;\n    }\n    else {\n      si.mediumType = 0;\n      si.mediumExtinction = vec3(0.0);\n      si.mediumScattering = vec3(0.0);\n      si.mediumAnisotropy = 0.0;\n    }\n  }\n#endif\n}\n`;\n"]}
+{"version":3,"file":"sampleMaterial.glsl.js","sourceRoot":"","sources":["../../../../src/renderer/glsl/chunks/sampleMaterial.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,iIAAiI;AAEjI,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,eAAe,IAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRlB,CAAC","sourcesContent":["// Estimate the direct lighting integral using multiple importance sampling\n// http://www.pbr-book.org/3ed-2018/Light_Transport_I_Surface_Reflection/Direct_Lighting.html#EstimatingtheDirectLightingIntegral\n\nimport { glsl } from '../../shader.js';\nexport default glsl`\nvec3 DirectLight(SurfaceInteraction si, OpenPbrResolvedMaterial mat, OpenPbrPreparedBsdf prepared, inout Path path, vec3 ffnormal, bool isSurface) {\n  float occluded = 1.0;\n  vec3 lightRnd = vec3(sample2D(bounceDim(LIGHT_POSITION)), sample1D(bounceDim(LIGHT_SELECT)));\n\n  LightSampleRec lightSample;\n  sampleLight(si.position, lightRnd, lightSample, false);\n  lightSample.emission = sampling_spectral_rgb_filter(lightSample.emission, pathWavelength);\n\n  vec3 lightDir = lightSample.direction;\n  vec3 viewDir = -path.ray.d;\n  float lightPdf = lightSample.pdf;\n  // Opaque surfaces are rendered two-sided by the core renderer. Use the\n  // face-forward shading normal here as well, otherwise the early-out rejects\n  // every direct-light sample seen from the back of a triangle (for example\n  // the inside of an imported room wall).\n  float cosThetaL = dot(ffnormal, lightDir);\n#ifdef USE_COAT_NORMAL_FRAMES\n  if (isSurface && mat.coatNormalEnabled) { cosThetaL = dot(mat.geometricNormal, lightDir); }\n#endif\n\n  if (lightPdf <= 0.0 || max(max(lightSample.emission.x, lightSample.emission.y), lightSample.emission.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  float scatteringPdf = 0.0;\n  vec3 f = vec3(0.0);\n  if (isSurface) {\n    if (cosThetaL <= 0.0 && mat.transmissionWeight <= 0.0 && mat.subsurfaceWeight <= 0.0) {\n      return vec3(0.0);\n    }\n    f = openpbr_eval_prepared(prepared, lightDir, scatteringPdf);\n  }\n  else {\n    scatteringPdf = sampling_henyey_greenstein_phase(\n      dot(viewDir, lightDir),\n      si.mediumAnisotropy\n    );\n    f = vec3(scatteringPdf);\n  }\n\n  if (scatteringPdf <= 0.0 || max(max(f.x, f.y), f.z) <= 0.0) {\n    return vec3(0.0);\n  }\n\n  Ray lightRay;\n  vec3 shadowOrigin = si.position + EPS * lightDir;\n  if (isSurface) {\n    const float shadowTerminatorCutoff = 0.1;\n    float normalLight = dot(si.normal, lightDir);\n#ifdef USE_COAT_NORMAL_FRAMES\n    if (mat.coatNormalEnabled) { normalLight = dot(si.faceNormal, lightDir); }\n#endif\n    vec3 geometricNormal = normalLight < 0.0 ? -si.faceNormal : si.faceNormal;\n    normalLight = abs(normalLight);\n    float geometricLight = dot(geometricNormal, lightDir);\n    float offsetAmount = normalLight < shadowTerminatorCutoff\n      ? clamp(\n          2.0 - (geometricLight + normalLight) / shadowTerminatorCutoff,\n          0.0,\n          1.0\n        )\n      : clamp(1.0 - geometricLight / shadowTerminatorCutoff, 0.0, 1.0);\n    shadowOrigin += si.shadowOffset * offsetAmount;\n  }\n  initRay(lightRay, shadowOrigin, lightDir);\n  if (intersectSceneShadow(lightRay, lightSample.dist - EPS, si.triangleIndex)) {\n    return vec3(0.0);\n  }\n\n#ifdef USE_ENVMAP\n  // Match the endpoint used by a BSDF-sampled surface transmission, including\n  // a separately displayed or grounded background and its coverage.\n  if (isSurface && cosThetaL < 0.0 && lightRnd.z < envLightSelectionPmf) {\n    vec4 background = sampleBackgroundFromRay(lightRay.o, lightDir);\n    lightSample.emission = sampling_spectral_rgb_filter(background.rgb * background.a, pathWavelength);\n  }\n#endif\n\n  // Delta lights cannot be sampled by the BSDF strategy, so their MIS weight\n  // is exactly one even when their light-selection PMF is small.\n  float misWeight = lightSample.isDelta\n    ? 1.0\n    : sampling_power_heuristic(lightPdf, scatteringPdf);\n  return misWeight > 0.0\n    ? misWeight * lightSample.emission * f / lightPdf\n    : vec3(0.0);\n}\n\n#ifdef USE_COAT_NORMAL_FRAMES\nvec3 coat_frame_normal(vec3 inputNormal, vec3 face, vec3 view) {\n  bool front = dot(face, view) >= 0.0;\n  vec3 ffFace = front ? face : -face;\n  vec3 ffInput = front ? inputNormal : -inputNormal;\n  if (dot(inputNormal, face) <= 0.0 || dot(ffInput, view) <= 1e-6) { return ffFace; }\n  return ffInput;\n}\n#endif\nvoid SampleMaterial(inout SurfaceInteraction si, OpenPbrResolvedMaterial mat, inout Path path) {\n  vec3 matRnd = vec3(sample2D(bounceDim(BSDF_DIRECTION)), sample1D(bounceDim(BSDF_LOBE)));\n#ifdef USE_COAT_NORMAL_FRAMES\n  vec3 originalFace = si.faceNormal;\n  vec3 originalNormal = si.normal;\n#endif\n  float ndv1 = -dot(si.faceNormal, path.ray.d);\n  float ndv2 = -dot(si.normal, path.ray.d);\n  if ((mat.transmissionWeight > 0.0 || mat.subsurfaceWeight > 0.0) && mat.thinWalled) {\n    // Always treat thin material as entering medium\n    if (ndv1 < 0.0) {\n      si.faceNormal = -si.faceNormal;\n      ndv1 = -ndv1;\n    }\n    if (ndv2 < 0.0) {\n      si.normal = -si.normal;\n      ndv2 = -ndv2;\n    }\n  }\n  // In same edge cases normal is not torwards the camera while we can still see the face.\n  // We need to choose faceNormal in this case.\n  bool useFaceN = ndv1 >= 0.0 && ndv2 < 0.0;\n  float ndv = useFaceN ? ndv1 : ndv2;\n  vec3 normal = useFaceN ? si.faceNormal : si.normal;\n\n  mat.inside = ndv <= 0.0 && !mat.thinWalled;\n  // In or out\n  mat.relativeIor = ndv > 0.0 ? (1.0 / mat.specularIor) : mat.specularIor;\n  vec3 ffnormal = ndv >= 0.0 ? normal : -normal;\n#ifdef USE_COAT_NORMAL_FRAMES\n  if (mat.coatNormalEnabled) {\n    vec3 view = -path.ray.d;\n    float geometricView = dot(originalFace, view);\n    mat.geometricNormal = geometricView >= 0.0 ? originalFace : -originalFace;\n    ffnormal = coat_frame_normal(originalNormal, originalFace, view);\n    mat.coatNormal = coat_frame_normal(si.coatNormal, originalFace, view);\n    mat.inside = geometricView <= 0.0 && !mat.thinWalled;\n    mat.relativeIor = (geometricView > 0.0 || mat.thinWalled) ? 1.0 / mat.specularIor : mat.specularIor;\n  }\n#endif\n\n\n  float scatteringPdf;\n  vec3 scatterDir;\n  path.scatteringIsDelta = false;\n  bool mediumSampled = false;\n  bool crossedBoundary = false;\n  OpenPbrPreparedBsdf prepared;\n\n#ifdef HAS_MEDIUM\n  int mediumType = si.mediumType;\n  float d = distance(si.position, path.ray.o);\n  vec3 segmentOrigin = path.ray.o;\n  vec3 extinction = si.mediumExtinction;\n  vec3 scattering = min(si.mediumScattering, extinction);\n  float majorant = max(max(extinction.x, extinction.y), extinction.z);\n  if (mediumType > 0 && majorant > 0.0) {\n    // Sample one RGB extinction channel and divide by the mixture PDF. This\n    // is the homogeneous-medium estimator used by PBRT and avoids the very\n    // large exp((majorant - extinction) * distance) weights produced by\n    // majorant tracking when OpenPBR SSS radii differ strongly by channel.\n    int mediumChannel = min(int(sample1D(bounceDim(MEDIUM_CHANNEL)) * 3.0), 2);\n    float channelExtinction = extinction[mediumChannel];\n    float scatterDist = channelExtinction > 0.0\n      ? min(-log(max(sample1D(bounceDim(MEDIUM_DISTANCE)), 1e-7)) / channelExtinction, d)\n      : d;\n    mediumSampled = scatterDist < d;\n    vec3 transmittance = exp(-extinction * scatterDist);\n    vec3 density = mediumSampled\n      ? extinction * transmittance\n      : transmittance;\n    float mediumPdf = max(\n      (density.x + density.y + density.z) / 3.0,\n      1e-8\n    );\n    if (mediumSampled) {\n      path.beta *= transmittance * scattering / mediumPdf;\n      // Move from the start of the segment, not from its end surface.\n      path.ray.o = segmentOrigin + scatterDist * path.ray.d;\n      si.position = path.ray.o;\n      path.li += DirectLight(si, mat, prepared, path, ffnormal, false) * path.beta;\n\n      // Pick a new direction based on the phase function\n      scatterDir = sampling_henyey_greenstein(\n        -path.ray.d,\n        si.mediumAnisotropy,\n        sample2D(bounceDim(PHASE_DIRECTION))\n      );\n      scatteringPdf = sampling_henyey_greenstein_phase(\n        dot(scatterDir, -path.ray.d),\n        si.mediumAnisotropy\n      );\n    }\n    else {\n      path.beta *= transmittance / mediumPdf;\n    }\n  }\n#endif\n\n  // Direct lighting\n  if (!mediumSampled) {\n    path.li += mat.emission * path.beta;\n    if (mat.materialType == UNLIT) {\n      path.abort = true;\n      return;\n    }\n    vec3 surfaceTangent = vec3(0.0);\n#ifdef USE_TANGENT\n    surfaceTangent = si.tangent;\n#endif\n    mat.directionTangent = si.directionTangent;\n    mat.directionBitangent = si.directionBitangent;\n    mat.geometryTangent = si.geometryTangent;\n    mat.geometryBitangent = si.geometryBitangent;\n    prepared = openpbr_prepare(surfaceTangent, mat, -path.ray.d, ffnormal);\n    path.li += DirectLight(si, mat, prepared, path, ffnormal, true) * path.beta;\n    // Sample BSDF for color and outgoing direction\n    bool isNextRefraction;\n    vec3 f = openpbr_sample_prepared(\n      prepared,\n      matRnd,\n      scatterDir,\n      scatteringPdf,\n      isNextRefraction\n    );\n    // Null-boundary transmission is discrete and has no NEE competitor.\n    path.scatteringIsDelta = !prepared.material.thinWalled &&\n      abs(prepared.material.relativeIor - 1.0) <= 1e-6 &&\n      prepared.probabilities[OPENPBR_LOBE_TRANSMISSION] >= 1.0 - 1e-6;\n    // Match WebGPU: rejected VNDF/refraction proposals have no continuation.\n    // Tracing their fallback direction with the incoming throughput invents\n    // light paths, especially after total internal reflection inside glass.\n    if (!(scatteringPdf > 0.0) || any(isnan(f)) || any(isinf(f)) ||\n        dot(scatterDir, scatterDir) < 0.5) {\n      path.scatteringPdf = 0.0;\n      path.abort = true;\n      return;\n    }\n    path.beta *= f / scatteringPdf;\n    crossedBoundary = !mat.thinWalled &&\n      isNextRefraction;\n    path.isNextRefraction = isNextRefraction;\n    // TODO prefer the opaque surface when transmission surface and opaque surface are overlapped.\n    // Or the ray go out from transmission material will miss the opque surface.\n    path.ray.o = si.position + EPS * scatterDir;\n#ifdef USE_COAT_NORMAL_FRAMES\n    if (mat.coatNormalEnabled) { path.ray.o = si.position + EPS * (dot(originalFace, scatterDir) >= 0.0 ? originalFace : -originalFace); }\n#endif\n  }\n\n  path.scatteringPdf = scatteringPdf;\n  initRay(path.ray, path.ray.o, scatterDir);\n  if (mediumSampled) {\n    path.isNextRefraction = false;\n  }\n  path.fromEye = false;\n\n#ifdef HAS_MEDIUM\n  // A reflected ray stays in its current medium. Only a sampled transmission\n  // event crosses the boundary of a medium-bearing closed mesh.\n  if (!mediumSampled && crossedBoundary && mat.mediumType > 0) {\n    if (ndv1 >= 0.0) {\n      si.mediumType = mat.mediumType;\n      si.mediumExtinction = mat.mediumExtinction;\n      si.mediumScattering = mat.mediumScattering;\n      si.mediumAnisotropy = mat.mediumAnisotropy;\n    }\n    else {\n      si.mediumType = 0;\n      si.mediumExtinction = vec3(0.0);\n      si.mediumScattering = vec3(0.0);\n      si.mediumAnisotropy = 0.0;\n    }\n  }\n#endif\n}\n`;\n"]}

package/lib/renderer/glsl/chunks/sampleShadowCatcher.glsl.js

@@ -16,28 +16,28 @@ return candidate == 0u ? cw(slot) : cw(9u + (candidate - 1u) * 3u + slot);
 }
 
 void sampleShadowCatcher(ad si, int bounce, inout Path aa) {
-vec3 oT = -aa.ray.d;
+vec3 oS = -aa.ray.d;
 
 #if defined(NUM_LIGHTS) || defined(USE_ENVMAP)
 float visibility = 0.0;
 for (uint candidate = 0u; candidate < SHADOW_CATCHER_LIGHT_SAMPLES; candidate++) {
 LightSampleRec lightSample;
 vec3 ln = vec3(
-fo(ky(candidate, LIGHT_POSITION)),
+fp(ky(candidate, LIGHT_POSITION)),
 dz(ky(candidate, LIGHT_SELECT))
 );
 sampleLight(si.position, ln, lightSample, false);
 
 vec3 lightDir = lightSample.direction;
 float cosThetaL = dot(si.normal, lightDir);
-float pM = dot(si.normal, oT) * cosThetaL;
-bool mD = false;
+float pM = dot(si.normal, oS) * cosThetaL;
+bool mC = false;
 if (pM >= 0.0) {
 Ray ray;
 iC(ray, si.position + EPS * lightDir, lightDir);
-mD = ex(ray, lightSample.dist - EPS, si.triangleIndex);
+mC = ex(ray, lightSample.dist - EPS, si.triangleIndex);
 }
-visibility += mD ? 0.0 : 1.0;
+visibility += mC ? 0.0 : 1.0;
 }
 
 aa.alpha = visibility / float(SHADOW_CATCHER_LIGHT_SAMPLES);

package/lib/renderer/glsl/chunks/sampling.glsl.js

@@ -6,27 +6,27 @@ export default glsl `
 
 vec3 aQ(vec3 view, vec2 alpha, vec2 samplePoint) {
 vec3 rm = vec3(alpha, 1.0);
-vec3 gj = normalize(rm * view);
-float uh = min(gj.z, 1.0);
+vec3 gk = normalize(rm * view);
+float uh = min(gk.z, 1.0);
 float qQ = 1.0 + uh;
 float rh = (1.0 - samplePoint.y) * qQ;
 float rR = samplePoint.y * qQ;
 float sI = rh + (1.0 - uh);
 float fl = sqrt(max(0.0, sI * rR));
 float br = TWOPI * samplePoint.x;
-vec3 lJ = vec3(
-gj.x + fl * cos(br),
-gj.y + fl * sin(br),
+vec3 lI = vec3(
+gk.x + fl * cos(br),
+gk.y + fl * sin(br),
 rh
 );
-return normalize(rm * lJ);
+return normalize(rm * lI);
 }
 
-float gK(vec3 oq, vec2 alpha) {
+float gL(vec3 oo, vec2 alpha) {
 vec3 hr = vec3(
-oq.x / alpha.x,
-oq.y / alpha.y,
-oq.z
+oo.x / alpha.x,
+oo.y / alpha.y,
+oo.z
 );
 float ap = dot(hr, hr);
 return 1.0 / (
@@ -40,9 +40,9 @@ if (eF <= 1e-8) {
 return 0.0;
 }
 vec2 ic = alpha * direction.xy;
-float lK = dot(ic, ic)
+float lJ = dot(ic, ic)
 / (eF * eF);
-return 2.0 / (1.0 + sqrt(1.0 + lK));
+return 2.0 / (1.0 + sqrt(1.0 + lJ));
 }
 
 float aE(float au) {
@@ -58,17 +58,17 @@ if (kl >= 1.0) {
 return 1.0;
 }
 
-float lU = sqrt(max(0.0, 1.0 - kl));
-float ba = (iA - cJ * lU)
-/ max(iA + cJ * lU, 1e-8);
-float pN = (cJ * iA - lU)
-/ max(cJ * iA + lU, 1e-8);
+float lT = sqrt(max(0.0, 1.0 - kl));
+float ba = (iA - cJ * lT)
+/ max(iA + cJ * lT, 1e-8);
+float pN = (cJ * iA - lT)
+/ max(cJ * iA + lT, 1e-8);
 return 0.5 * (
 ba * ba + pN * pN
 );
 }
 
-vec2 gh(vec2 samplePoint) {
+vec2 gi(vec2 samplePoint) {
 vec2 offset = 2.0 * samplePoint - vec2(1.0);
 if (offset.x == 0.0 && offset.y == 0.0) {
 return vec2(0.0);
@@ -88,21 +88,21 @@ return radius * vec2(cos(angle), sin(angle));
 }
 
 vec3 bi(vec2 samplePoint) {
-vec2 kF = gh(samplePoint);
+vec2 kF = gi(samplePoint);
 return vec3(
 kF,
 sqrt(max(0.0, 1.0 - dot(kF, kF)))
 );
 }
 
-float aG(float pr, float nO) {
-float scale = max(pr, nO);
+float aG(float pr, float nN) {
+float scale = max(pr, nN);
 if (scale <= 0.0) {
 return 0.0;
 }
-vec2 normalized = vec2(pr, nO) / scale;
-vec2 oP = normalized * normalized;
-return oP.x / (oP.x + oP.y);
+vec2 normalized = vec2(pr, nN) / scale;
+vec2 oO = normalized * normalized;
+return oO.x / (oO.x + oO.y);
 }
 
 void aL(in vec3 normal, out vec3 tangent, out vec3 bitangent) {
@@ -135,12 +135,12 @@ return rgb * tN;
 
 float eN(
 float wavelength,
-float hg,
+float hh,
 float hp,
 float qs
 ) {
 if (wavelength == 0.0 || hp <= 0.0) {
-return hg;
+return hh;
 }
 
 const float FRAUNHOFER_C = 656.3;
@@ -150,15 +150,15 @@ float jR = 1.0 / (
 1.0 / (FRAUNHOFER_F * FRAUNHOFER_F)
 - 1.0 / (FRAUNHOFER_C * FRAUNHOFER_C)
 );
-float nh = max(qs / hp, 1e-6);
-float qR = (hg - 1.0) * jR / nh;
-float tl = hg
+float ng = max(qs / hp, 1e-6);
+float qR = (hh - 1.0) * jR / ng;
+float tl = hh
 - qR / (FRAUNHOFER_D * FRAUNHOFER_D);
 return tl + qR / (wavelength * wavelength);
 }
 
-vec3 fp(
-vec3 gy,
+vec3 fq(
+vec3 gz,
 float anisotropy,
 vec2 samplePoint
 ) {
@@ -178,10 +178,10 @@ float ud = sqrt(max(0.0, 1.0 - au * au));
 float br = TWOPI * samplePoint.x;
 vec3 tangent;
 vec3 bitangent;
-aL(gy, tangent, bitangent);
+aL(gz, tangent, bitangent);
 return tangent * (ud * cos(br))
 + bitangent * (ud * sin(br))
-+ gy * au;
++ gz * au;
 }
 
 float bD(float au, float anisotropy) {

package/lib/renderer/glsl/chunks/sobol.glsl.js

@@ -99,18 +99,18 @@ return CAMERA_BEVEL_BASE + uint(BEVEL_SAMPLES) + cF * BOUNCE_STRIDE + slot;
 
 uvec4 hl;
 uint hm;
-bool fB = false;
+bool fC = false;
 bool dg = false;
 uint dF;
-uint gu;
+uint gv;
 vec2 eQ;
 void dw(uint dim) {
 
 uint kd = bc.x + bc.y * uint(round(1.0 / pixelSize.x));
 uvec4 key = uvec4(dim, bd, kd, uint(sequenceSeed));
-if (fB && all(equal(hl, key)) && hm == uint(zSobolLogSPP)) { return; }
+if (fC && all(equal(hl, key)) && hm == uint(zSobolLogSPP)) { return; }
 hl = key; hm = uint(zSobolLogSPP);
-fB = true; dg = false;
+fC = true; dg = false;
 uint ij = aq(aq(kd, dim), uint(sequenceSeed));
 uint index = bd;
 if (samplingPattern == 1) {
@@ -129,14 +129,14 @@ if (bd != 0u) { jb += 1u; }
 ij = aq(ij, jb);
 }
 dF = sK(index, aq(ij, 0u));
-gu = ij;
+gv = ij;
 uint x = reverseBits(iE(dF, aq(ij, 1u)));
 eQ.x = float(x >> 8u) * (1.0 / 16777216.0);
 }
 vec2 kS(uint dim) {
 dw(dim);
 if (!dg) {
-uint y = sK(rl(dF), aq(gu, 2u));
+uint y = sK(rl(dF), aq(gv, 2u));
 eQ.y = float(y >> 8u) * (1.0 / 16777216.0);
 dg = true;
 }
@@ -147,7 +147,7 @@ if (samplingPattern == 2) { return EPS + (1.0 - 2.0*EPS)*rand(); }
 dw(dim);
 return EPS + (1.0 - 2.0*EPS) * eQ.x;
 }
-vec2 fo(uint dim) {
+vec2 fp(uint dim) {
 if (samplingPattern == 2) {
 float x = dz(dim); float y = dz(dim);
 return vec2(x,y);

package/lib/renderer/glsl/chunks/uvProjection.glsl.js

@@ -58,7 +58,7 @@ float theta = atan(pos.z, pos.x) / (2.0 * PI) + 0.5;
 return vec2(theta, pos.y);
 }
 
-vec2 gH(int fk, vec3 pos, vec3 normal, vec2 uvScale) {
+vec2 gI(int fk, vec3 pos, vec3 normal, vec2 uvScale) {
 if (fk == ${uvProjectionConstants.triplanar + ''}) {
 return iR(pos, normal, uvScale);
 } else if (fk == ${uvProjectionConstants.spherical + ''}) {

package/lib/renderer/glsl/depthQuery.frag.js

@@ -35,7 +35,7 @@ vec4 target = viewProjectionInv * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
 Ray ray;
 iC(ray, origin.xyz / origin.w, normalize(target.xyz * origin.w - origin.xyz * target.w));
 vec3 eye = viewInv[3].xyz;
-vec3 ol = -normalize(viewInv[2].xyz);
+vec3 oj = -normalize(viewInv[2].xyz);
 ad si;
 si.triangleIndex = -1;
 for (int layer = 0; layer < 32; layer++) {
@@ -44,7 +44,7 @@ if (!si.hit) return;
 J material;
 eX(material, si.materialIndex, si.uv, si.uv1, si.instanceIndex, si.vertexColor);
 if (material.materialType != SHADOW_CATCHER && material.alpha > 0.0) {
-out_depth.r = max(dot(si.position - eye, ol), 0.0);
+out_depth.r = max(dot(si.position - eye, oj), 0.0);
 return;
 }
 ray.o = si.position + ray.d * (EPS * 0.02);