From a10eea6e4ce647061813519d5b0ea496f29495b9 Mon Sep 17 00:00:00 2001
From: leonard Wu <364452445@qq.com>
Date: 星期四, 09 八月 2018 09:47:08 +0800
Subject: [PATCH] 同步最新svn内容
---
Assets/Plugins/PostProcessing/Resources/Shaders/ScreenSpaceRaytrace.cginc | 476 +++++++++++++++++++++++++++++-----------------------------
1 files changed, 238 insertions(+), 238 deletions(-)
diff --git a/Assets/Plugins/PostProcessing/Resources/Shaders/ScreenSpaceRaytrace.cginc b/Assets/Plugins/PostProcessing/Resources/Shaders/ScreenSpaceRaytrace.cginc
index ac7abf2..33a497b 100644
--- a/Assets/Plugins/PostProcessing/Resources/Shaders/ScreenSpaceRaytrace.cginc
+++ b/Assets/Plugins/PostProcessing/Resources/Shaders/ScreenSpaceRaytrace.cginc
@@ -1,238 +1,238 @@
-/**
-\author Michael Mara and Morgan McGuire, Casual Effects. 2015.
-*/
-
-#ifndef __SCREEN_SPACE_RAYTRACE__
-#define __SCREEN_SPACE_RAYTRACE__
-
-sampler2D_float _CameraDepthTexture;
-
-float distanceSquared(float2 A, float2 B)
-{
- A -= B;
- return dot(A, A);
-}
-
-float distanceSquared(float3 A, float3 B)
-{
- A -= B;
- return dot(A, A);
-}
-
-void swap(inout float v0, inout float v1)
-{
- float temp = v0;
- v0 = v1;
- v1 = temp;
-}
-
-bool isIntersecting(float rayZMin, float rayZMax, float sceneZ, float layerThickness)
-{
- return (rayZMax >= sceneZ - layerThickness) && (rayZMin <= sceneZ);
-}
-
-void rayIterations(in bool traceBehindObjects, inout float2 P, inout float stepDirection, inout float end, inout int stepCount, inout int maxSteps, inout bool intersecting,
- inout float sceneZ, inout float2 dP, inout float3 Q, inout float3 dQ, inout float k, inout float dk,
- inout float rayZMin, inout float rayZMax, inout float prevZMaxEstimate, inout bool permute, inout float2 hitPixel,
- inout float2 invSize, inout float layerThickness)
-{
- bool stop = intersecting;
-
- UNITY_LOOP
- for (; (P.x * stepDirection) <= end && stepCount < maxSteps && !stop; P += dP, Q.z += dQ.z, k += dk, stepCount += 1)
- {
- // The depth range that the ray covers within this loop iteration.
- // Assume that the ray is moving in increasing z and swap if backwards.
- rayZMin = prevZMaxEstimate;
- //rayZMin = (dQ.z * -0.5 + Q.z) / (dk * -0.5 + k);
- // Compute the value at 1/2 pixel into the future
- rayZMax = (dQ.z * 0.5 + Q.z) / (dk * 0.5 + k);
- prevZMaxEstimate = rayZMax;
-
- if (rayZMin > rayZMax)
- {
- swap(rayZMin, rayZMax);
- }
-
- // Undo the homogeneous operation to obtain the camera-space
- // Q at each point
- hitPixel = permute ? P.yx : P;
-
- sceneZ = tex2Dlod(_CameraDepthTexture, float4(hitPixel * invSize,0,0)).r;
- sceneZ = -LinearEyeDepth(sceneZ);
-
- bool isBehind = (rayZMin <= sceneZ);
- intersecting = isBehind && (rayZMax >= sceneZ - layerThickness);
- stop = traceBehindObjects ? intersecting : isBehind;
-
- } // pixel on ray
-
- P -= dP, Q.z -= dQ.z, k -= dk;
-}
-
-/**
- \param csOrigin must have z < -0.01, and project within the valid screen rectangle
- \param stepRate Set to 1.0 by default, higher to step faster
- */
-bool castDenseScreenSpaceRay
- (float3 csOrigin,
- float3 csDirection,
- float4x4 projectToPixelMatrix,
- float2 csZBufferSize,
- float3 clipInfo,
- float jitterFraction,
- int maxSteps,
- float layerThickness,
- float maxRayTraceDistance,
- out float2 hitPixel,
- int stepRate,
- bool traceBehindObjects,
- out float3 csHitPoint,
- out float stepCount) {
-
- float2 invSize = float2(1.0 / csZBufferSize.x, 1.0 / csZBufferSize.y);
-
- // Initialize to off screen
- hitPixel = float2(-1, -1);
-
- float nearPlaneZ = -0.01;
- // Clip ray to a near plane in 3D (doesn't have to be *the* near plane, although that would be a good idea)
- float rayLength = ((csOrigin.z + csDirection.z * maxRayTraceDistance) > nearPlaneZ) ?
- ((nearPlaneZ - csOrigin.z) / csDirection.z) :
- maxRayTraceDistance;
-
- float3 csEndPoint = csDirection * rayLength + csOrigin;
-
- // Project into screen space
- // This matrix has a lot of zeroes in it. We could expand
- // out these multiplies to avoid multiplying by zero
- // ...but 16 MADDs are not a big deal compared to what's ahead
- float4 H0 = mul(projectToPixelMatrix, float4(csOrigin, 1.0));
- float4 H1 = mul(projectToPixelMatrix, float4(csEndPoint, 1.0));
-
- // There are a lot of divisions by w that can be turned into multiplications
- // at some minor precision loss...and we need to interpolate these 1/w values
- // anyway.
- //
- // Because the caller was required to clip to the near plane,
- // this homogeneous division (projecting from 4D to 2D) is guaranteed
- // to succeed.
- float k0 = 1.0 / H0.w;
- float k1 = 1.0 / H1.w;
-
- // Screen-space endpoints
- float2 P0 = H0.xy * k0;
- float2 P1 = H1.xy * k1;
-
- // Switch the original points to values that interpolate linearly in 2D:
- float3 Q0 = csOrigin * k0;
- float3 Q1 = csEndPoint * k1;
-
-#if 1 // Clipping to the screen coordinates. We could simply modify maxSteps instead
- float yMax = csZBufferSize.y - 0.5;
- float yMin = 0.5;
- float xMax = csZBufferSize.x - 0.5;
- float xMin = 0.5;
-
- // 2D interpolation parameter
- float alpha = 0.0;
- // P0 must be in bounds
- if (P1.y > yMax || P1.y < yMin) {
- float yClip = (P1.y > yMax) ? yMax : yMin;
- float yAlpha = (P1.y - yClip) / (P1.y - P0.y); // Denominator is not zero, since P0 != P1 (or P0 would have been clipped!)
- alpha = yAlpha;
- }
-
- // P0 must be in bounds
- if (P1.x > xMax || P1.x < xMin) {
- float xClip = (P1.x > xMax) ? xMax : xMin;
- float xAlpha = (P1.x - xClip) / (P1.x - P0.x); // Denominator is not zero, since P0 != P1 (or P0 would have been clipped!)
- alpha = max(alpha, xAlpha);
- }
-
- // These are all in homogeneous space, so they interpolate linearly
- P1 = lerp(P1, P0, alpha);
- k1 = lerp(k1, k0, alpha);
- Q1 = lerp(Q1, Q0, alpha);
-#endif
-
- // We're doing this to avoid divide by zero (rays exactly parallel to an eye ray)
- P1 = (distanceSquared(P0, P1) < 0.0001) ? P0 + float2(0.01, 0.01) : P1;
-
- float2 delta = P1 - P0;
-
- // Assume horizontal
- bool permute = false;
- if (abs(delta.x) < abs(delta.y)) {
- // More-vertical line. Create a permutation that swaps x and y in the output
- permute = true;
-
- // Directly swizzle the inputs
- delta = delta.yx;
- P1 = P1.yx;
- P0 = P0.yx;
- }
-
- // From now on, "x" is the primary iteration direction and "y" is the secondary one
-
- float stepDirection = sign(delta.x);
- float invdx = stepDirection / delta.x;
- float2 dP = float2(stepDirection, invdx * delta.y);
-
- // Track the derivatives of Q and k
- float3 dQ = (Q1 - Q0) * invdx;
- float dk = (k1 - k0) * invdx;
-
- dP *= stepRate;
- dQ *= stepRate;
- dk *= stepRate;
-
- P0 += dP * jitterFraction;
- Q0 += dQ * jitterFraction;
- k0 += dk * jitterFraction;
-
- // Slide P from P0 to P1, (now-homogeneous) Q from Q0 to Q1, and k from k0 to k1
- float3 Q = Q0;
- float k = k0;
-
- // We track the ray depth at +/- 1/2 pixel to treat pixels as clip-space solid
- // voxels. Because the depth at -1/2 for a given pixel will be the same as at
- // +1/2 for the previous iteration, we actually only have to compute one value
- // per iteration.
- float prevZMaxEstimate = csOrigin.z;
- stepCount = 0.0;
- float rayZMax = prevZMaxEstimate, rayZMin = prevZMaxEstimate;
- float sceneZ = 100000;
-
- // P1.x is never modified after this point, so pre-scale it by
- // the step direction for a signed comparison
- float end = P1.x * stepDirection;
-
- bool intersecting = isIntersecting(rayZMin, rayZMax, sceneZ, layerThickness);
- // We only advance the z field of Q in the inner loop, since
- // Q.xy is never used until after the loop terminates
-
- //int rayIterations = min(maxSteps, stepsToGetOffscreen);
-
-
- float2 P = P0;
-
- int originalStepCount = 0;
- rayIterations(traceBehindObjects, P, stepDirection, end, originalStepCount, maxSteps, intersecting,
- sceneZ, dP, Q, dQ, k, dk,
- rayZMin, rayZMax, prevZMaxEstimate, permute, hitPixel,
- invSize, layerThickness);
-
-
- stepCount = originalStepCount;
-
- // Loop only advanced the Z component. Now that we know where we are going
- // update xy
- Q.xy += dQ.xy * stepCount;
- // Q is a vector, so we are trying to get by with 1 division instead of 3.
- csHitPoint = Q * (1.0 / k);
-
- return intersecting;
-}
-
-#endif // __SCREEN_SPACE_RAYTRACE__
+/**
+\author Michael Mara and Morgan McGuire, Casual Effects. 2015.
+*/
+
+#ifndef __SCREEN_SPACE_RAYTRACE__
+#define __SCREEN_SPACE_RAYTRACE__
+
+sampler2D_float _CameraDepthTexture;
+
+float distanceSquared(float2 A, float2 B)
+{
+ A -= B;
+ return dot(A, A);
+}
+
+float distanceSquared(float3 A, float3 B)
+{
+ A -= B;
+ return dot(A, A);
+}
+
+void swap(inout float v0, inout float v1)
+{
+ float temp = v0;
+ v0 = v1;
+ v1 = temp;
+}
+
+bool isIntersecting(float rayZMin, float rayZMax, float sceneZ, float layerThickness)
+{
+ return (rayZMax >= sceneZ - layerThickness) && (rayZMin <= sceneZ);
+}
+
+void rayIterations(in bool traceBehindObjects, inout float2 P, inout float stepDirection, inout float end, inout int stepCount, inout int maxSteps, inout bool intersecting,
+ inout float sceneZ, inout float2 dP, inout float3 Q, inout float3 dQ, inout float k, inout float dk,
+ inout float rayZMin, inout float rayZMax, inout float prevZMaxEstimate, inout bool permute, inout float2 hitPixel,
+ inout float2 invSize, inout float layerThickness)
+{
+ bool stop = intersecting;
+
+ UNITY_LOOP
+ for (; (P.x * stepDirection) <= end && stepCount < maxSteps && !stop; P += dP, Q.z += dQ.z, k += dk, stepCount += 1)
+ {
+ // The depth range that the ray covers within this loop iteration.
+ // Assume that the ray is moving in increasing z and swap if backwards.
+ rayZMin = prevZMaxEstimate;
+ //rayZMin = (dQ.z * -0.5 + Q.z) / (dk * -0.5 + k);
+ // Compute the value at 1/2 pixel into the future
+ rayZMax = (dQ.z * 0.5 + Q.z) / (dk * 0.5 + k);
+ prevZMaxEstimate = rayZMax;
+
+ if (rayZMin > rayZMax)
+ {
+ swap(rayZMin, rayZMax);
+ }
+
+ // Undo the homogeneous operation to obtain the camera-space
+ // Q at each point
+ hitPixel = permute ? P.yx : P;
+
+ sceneZ = tex2Dlod(_CameraDepthTexture, float4(hitPixel * invSize,0,0)).r;
+ sceneZ = -LinearEyeDepth(sceneZ);
+
+ bool isBehind = (rayZMin <= sceneZ);
+ intersecting = isBehind && (rayZMax >= sceneZ - layerThickness);
+ stop = traceBehindObjects ? intersecting : isBehind;
+
+ } // pixel on ray
+
+ P -= dP, Q.z -= dQ.z, k -= dk;
+}
+
+/**
+ \param csOrigin must have z < -0.01, and project within the valid screen rectangle
+ \param stepRate Set to 1.0 by default, higher to step faster
+ */
+bool castDenseScreenSpaceRay
+ (float3 csOrigin,
+ float3 csDirection,
+ float4x4 projectToPixelMatrix,
+ float2 csZBufferSize,
+ float3 clipInfo,
+ float jitterFraction,
+ int maxSteps,
+ float layerThickness,
+ float maxRayTraceDistance,
+ out float2 hitPixel,
+ int stepRate,
+ bool traceBehindObjects,
+ out float3 csHitPoint,
+ out float stepCount) {
+
+ float2 invSize = float2(1.0 / csZBufferSize.x, 1.0 / csZBufferSize.y);
+
+ // Initialize to off screen
+ hitPixel = float2(-1, -1);
+
+ float nearPlaneZ = -0.01;
+ // Clip ray to a near plane in 3D (doesn't have to be *the* near plane, although that would be a good idea)
+ float rayLength = ((csOrigin.z + csDirection.z * maxRayTraceDistance) > nearPlaneZ) ?
+ ((nearPlaneZ - csOrigin.z) / csDirection.z) :
+ maxRayTraceDistance;
+
+ float3 csEndPoint = csDirection * rayLength + csOrigin;
+
+ // Project into screen space
+ // This matrix has a lot of zeroes in it. We could expand
+ // out these multiplies to avoid multiplying by zero
+ // ...but 16 MADDs are not a big deal compared to what's ahead
+ float4 H0 = mul(projectToPixelMatrix, float4(csOrigin, 1.0));
+ float4 H1 = mul(projectToPixelMatrix, float4(csEndPoint, 1.0));
+
+ // There are a lot of divisions by w that can be turned into multiplications
+ // at some minor precision loss...and we need to interpolate these 1/w values
+ // anyway.
+ //
+ // Because the caller was required to clip to the near plane,
+ // this homogeneous division (projecting from 4D to 2D) is guaranteed
+ // to succeed.
+ float k0 = 1.0 / H0.w;
+ float k1 = 1.0 / H1.w;
+
+ // Screen-space endpoints
+ float2 P0 = H0.xy * k0;
+ float2 P1 = H1.xy * k1;
+
+ // Switch the original points to values that interpolate linearly in 2D:
+ float3 Q0 = csOrigin * k0;
+ float3 Q1 = csEndPoint * k1;
+
+#if 1 // Clipping to the screen coordinates. We could simply modify maxSteps instead
+ float yMax = csZBufferSize.y - 0.5;
+ float yMin = 0.5;
+ float xMax = csZBufferSize.x - 0.5;
+ float xMin = 0.5;
+
+ // 2D interpolation parameter
+ float alpha = 0.0;
+ // P0 must be in bounds
+ if (P1.y > yMax || P1.y < yMin) {
+ float yClip = (P1.y > yMax) ? yMax : yMin;
+ float yAlpha = (P1.y - yClip) / (P1.y - P0.y); // Denominator is not zero, since P0 != P1 (or P0 would have been clipped!)
+ alpha = yAlpha;
+ }
+
+ // P0 must be in bounds
+ if (P1.x > xMax || P1.x < xMin) {
+ float xClip = (P1.x > xMax) ? xMax : xMin;
+ float xAlpha = (P1.x - xClip) / (P1.x - P0.x); // Denominator is not zero, since P0 != P1 (or P0 would have been clipped!)
+ alpha = max(alpha, xAlpha);
+ }
+
+ // These are all in homogeneous space, so they interpolate linearly
+ P1 = lerp(P1, P0, alpha);
+ k1 = lerp(k1, k0, alpha);
+ Q1 = lerp(Q1, Q0, alpha);
+#endif
+
+ // We're doing this to avoid divide by zero (rays exactly parallel to an eye ray)
+ P1 = (distanceSquared(P0, P1) < 0.0001) ? P0 + float2(0.01, 0.01) : P1;
+
+ float2 delta = P1 - P0;
+
+ // Assume horizontal
+ bool permute = false;
+ if (abs(delta.x) < abs(delta.y)) {
+ // More-vertical line. Create a permutation that swaps x and y in the output
+ permute = true;
+
+ // Directly swizzle the inputs
+ delta = delta.yx;
+ P1 = P1.yx;
+ P0 = P0.yx;
+ }
+
+ // From now on, "x" is the primary iteration direction and "y" is the secondary one
+
+ float stepDirection = sign(delta.x);
+ float invdx = stepDirection / delta.x;
+ float2 dP = float2(stepDirection, invdx * delta.y);
+
+ // Track the derivatives of Q and k
+ float3 dQ = (Q1 - Q0) * invdx;
+ float dk = (k1 - k0) * invdx;
+
+ dP *= stepRate;
+ dQ *= stepRate;
+ dk *= stepRate;
+
+ P0 += dP * jitterFraction;
+ Q0 += dQ * jitterFraction;
+ k0 += dk * jitterFraction;
+
+ // Slide P from P0 to P1, (now-homogeneous) Q from Q0 to Q1, and k from k0 to k1
+ float3 Q = Q0;
+ float k = k0;
+
+ // We track the ray depth at +/- 1/2 pixel to treat pixels as clip-space solid
+ // voxels. Because the depth at -1/2 for a given pixel will be the same as at
+ // +1/2 for the previous iteration, we actually only have to compute one value
+ // per iteration.
+ float prevZMaxEstimate = csOrigin.z;
+ stepCount = 0.0;
+ float rayZMax = prevZMaxEstimate, rayZMin = prevZMaxEstimate;
+ float sceneZ = 100000;
+
+ // P1.x is never modified after this point, so pre-scale it by
+ // the step direction for a signed comparison
+ float end = P1.x * stepDirection;
+
+ bool intersecting = isIntersecting(rayZMin, rayZMax, sceneZ, layerThickness);
+ // We only advance the z field of Q in the inner loop, since
+ // Q.xy is never used until after the loop terminates
+
+ //int rayIterations = min(maxSteps, stepsToGetOffscreen);
+
+
+ float2 P = P0;
+
+ int originalStepCount = 0;
+ rayIterations(traceBehindObjects, P, stepDirection, end, originalStepCount, maxSteps, intersecting,
+ sceneZ, dP, Q, dQ, k, dk,
+ rayZMin, rayZMax, prevZMaxEstimate, permute, hitPixel,
+ invSize, layerThickness);
+
+
+ stepCount = originalStepCount;
+
+ // Loop only advanced the Z component. Now that we know where we are going
+ // update xy
+ Q.xy += dQ.xy * stepCount;
+ // Q is a vector, so we are trying to get by with 1 division instead of 3.
+ csHitPoint = Q * (1.0 / k);
+
+ return intersecting;
+}
+
+#endif // __SCREEN_SPACE_RAYTRACE__
--
Gitblit v1.8.0