274 lines
12 KiB
Plaintext
274 lines
12 KiB
Plaintext
import Common;
|
|
import MaterialParameter;
|
|
import LightEnv;
|
|
import VertexData;
|
|
import Material;
|
|
import StaticMeshVertexData;
|
|
import MATERIAL_FILE_NAME;
|
|
import RayTracingData;
|
|
import Scene;
|
|
|
|
// simplification: all BLAS only have 1 geometry
|
|
|
|
/*vec3 nextEventEstimation(vec3 accmat, vec3 w, vec3 x, vec3 nl, float kt, bool useAtt, vec3 rnd) {
|
|
uint triId = 0;
|
|
uint sphereId = 0;
|
|
ShadingParams paramsls;
|
|
Material matls;
|
|
vec3 result = vec3(0);
|
|
// Direct Illumination: Next Event Estimation over any present lights
|
|
for (int i = spheres.length(); i-->0;) {
|
|
Sphere ls = spheres[i];
|
|
if (all(equal(ls.e, vec3(0)))) continue; // skip non-emissive spheres
|
|
vec3 xc = ls.geo.xyz - x;
|
|
vec3 sw = normalize(xc), su = normalize(cross((abs(sw.x)>.1 ? vec3(0,1,0) : vec3(1,0,0)), sw)), sv = cross(sw,su);
|
|
float cos_a_max = sqrt(float(1 - ls.geo.w*ls.geo.w / dot(xc,xc)));
|
|
float cos_a = 1 - rnd.x + rnd.x*cos_a_max, sin_a = sqrt(1 - cos_a*cos_a);
|
|
float phi = 2 * pi * rnd.y;
|
|
vec3 l = normalize(su*cos(phi)*sin_a + sv*sin(phi)*sin_a + sw*cos_a); // sampled direction towards light
|
|
if (intersect(Ray(x,l), matls, paramsls, sphereId, triId) && sphereId == i) { // test if shadow ray hits this light
|
|
source float omega = 2 * pi * (1-cos_a_max); if(useAtt) { float tau = exp(-kt * length(x - paramsls.x)); result += max(dot(l,nl),0) *
|
|
ls.e * omega * tau; } else { result += accmat / pi * max(dot(l,nl),0) * ls.e * omega; // brdf term obj.c.xyz already in accmat, 1/pi
|
|
for brdf
|
|
}
|
|
}
|
|
}
|
|
for(int i = meshLights.length(); i-->0;) {
|
|
MeshDescriptor mesh = meshes[meshLights[i]];
|
|
for(int j = 0; j < mesh.numIndices; j+=3) {
|
|
vec3 A = vec3(vertices[mesh.vertexOffset + indices[mesh.indexOffset + j + 0]]);
|
|
vec3 B = vec3(vertices[mesh.vertexOffset + indices[mesh.indexOffset + j + 1]]);
|
|
vec3 C = vec3(vertices[mesh.vertexOffset + indices[mesh.indexOffset + j + 2]]);
|
|
float b1 = 1 - sqrt(rnd.x);
|
|
float b2 = (1 - rnd.y) * sqrt(rnd.x);
|
|
float b3 = rnd.y * sqrt(rnd.x);
|
|
vec3 P = A * b1 + B * b2 + C * b3;
|
|
vec3 omega = P - x;
|
|
vec3 l = normalize(omega);
|
|
float v = 0.f;
|
|
if(intersect(Ray(x,l), matls, paramsls, sphereId, triId) && triId == j) {
|
|
v = 1.0f;
|
|
}
|
|
vec3 e1 = C - A;
|
|
vec3 e2 = B - A;
|
|
float area = length(cross(e1, e2)) / 2;
|
|
float rayLen = length(omega);
|
|
float cosTheta = dot(nl, l);
|
|
float cosThetaDash = dot(paramsls.n, -l);
|
|
float factor = area * (cosThetaDash / (rayLen * rayLen));
|
|
if(useAtt) {
|
|
float tau = phase(w, l) * exp(-kt * length(x - paramsls.x));
|
|
result += tau * matls.e * max(cosTheta, 0) * factor;
|
|
} else {
|
|
result += accmat * (matls.e * max(cosTheta, 0) * factor) / pi;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
*/
|
|
|
|
const static float ka = 0;
|
|
const static float ks = 0;
|
|
const static float3 fogEmm = float3(0, 0.01, 0.01);
|
|
|
|
const static float eps = 1e-5;
|
|
[shader("closesthit")]
|
|
void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttributes attr) {
|
|
hitValue.hit = true;
|
|
// todo: replace with anyhit shader
|
|
if (hitValue.anyHit)
|
|
return;
|
|
|
|
const float3 barycentricCoords = float3(1.0f - attr.barycentrics.x - attr.barycentrics.y, attr.barycentrics.x, attr.barycentrics.y);
|
|
|
|
InstanceData inst = pScene.instances[InstanceID()];
|
|
MeshData m = pScene.meshData[InstanceID()];
|
|
|
|
// offset into the index buffer
|
|
uint indexOffset = m.indicesRange.offset;
|
|
// added to indices to reference correct part of global mesh pool
|
|
uint vertexOffset = pScene.meshletInfos[m.meshletRange.offset].indicesOffset;
|
|
|
|
uint vertexIndex0 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 0];
|
|
uint vertexIndex1 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 1];
|
|
uint vertexIndex2 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 2];
|
|
|
|
VertexAttributes attr0 = pVertexData.getAttributes(vertexIndex0);
|
|
VertexAttributes attr1 = pVertexData.getAttributes(vertexIndex1);
|
|
VertexAttributes attr2 = pVertexData.getAttributes(vertexIndex2);
|
|
|
|
FragmentParameter f0 = attr0.getParameter(inst.transformMatrix, inst.inverseTransformMatrix);
|
|
FragmentParameter f1 = attr1.getParameter(inst.transformMatrix, inst.inverseTransformMatrix);
|
|
FragmentParameter f2 = attr2.getParameter(inst.transformMatrix, inst.inverseTransformMatrix);
|
|
|
|
FragmentParameter params = FragmentParameter.interpolate(f0, f1, f2, barycentricCoords);
|
|
|
|
hitValue.params = params.getLightingParameter();
|
|
hitValue.materialParams = params.getMaterialParameter();
|
|
|
|
LightingParameter lightingParams = hitValue.params;
|
|
lightingParams.viewDir_WS = -WorldRayDirection();
|
|
let brdf = Material.prepare(hitValue.materialParams);
|
|
|
|
float3 normal_WS = brdf.getNormal();
|
|
float3 normalLight_WS = dot(normal_WS, WorldRayDirection()) < 0 ? normal_WS : -normal_WS;
|
|
float3 intersection_WS = lightingParams.position_WS;
|
|
|
|
hitValue.depth++;
|
|
float3 rnd = rand01(hitValue.rndSeed);
|
|
// float kt = ka + ks;
|
|
// float s = -log(rnd.z) / kt;
|
|
// if (s < RayTCurrent()) {
|
|
// float3 xs = WorldRayOrigin() + s * WorldRayDirection();
|
|
// float p = kt * rnd.z;
|
|
// if (hitValue.depth > 5) {
|
|
// if (rnd.z >= p) return;
|
|
// else brdf.baseColor /= p;
|
|
// }
|
|
// float3 ldirect = nextEventEstimation(brdf.baseColor, WorldRayDirection(), xs, -WorldRayDirection(), kt, true, rnd);
|
|
// hitValue.light += (fogEmm + ks * ldirect) / kt;
|
|
// accmat *= ks / kt;
|
|
// rayDesc.Origin = xs;
|
|
// rayDesc.Direction = float3(
|
|
// cos(2*PI*rnd.x)*sqrt(1-rnd.y*rnd.y),
|
|
// sin(2*PI*rnd.x)*sqrt(1-rnd.y*rnd.y),
|
|
// rnd.y
|
|
// );
|
|
// TraceRay(scene, 0, 0xff, 0, 0, rayDesc);
|
|
// }
|
|
|
|
float p = max(max(brdf.getBaseColor().x, brdf.getBaseColor().y), brdf.getBaseColor().z);
|
|
if (hitValue.depth > 5) {
|
|
if (rnd.z >= p)
|
|
return;
|
|
}
|
|
|
|
hitValue.light += brdf.getEmissive() * hitValue.emissive + brdf.evaluateAmbient(lightingParams.viewDir_WS);
|
|
//-- Ideal DIFFUSE reflection
|
|
// if(bool(useNEE)) {
|
|
// accrad += nextEventEstimation(accmat, r.d, params.x, params.nl, kt, false, rnd);
|
|
//}
|
|
// Only trace shadow rays for direct lighting at shallow depths
|
|
if (hitValue.depth <= 3) {
|
|
for (uint i = 0; i < pLightEnv.numDirectionalLights; ++i) {
|
|
float3 x = intersection_WS;
|
|
float3 l = -pLightEnv.directionalLights[i].direction.xyz;
|
|
RayDesc rayDesc;
|
|
rayDesc.TMax = 10000.0f;
|
|
rayDesc.TMin = eps;
|
|
rayDesc.Origin = x;
|
|
rayDesc.Direction = l;
|
|
RayPayload payload;
|
|
payload.depth = hitValue.depth;
|
|
payload.emissive = 1;
|
|
payload.anyHit = true;
|
|
payload.hit = false;
|
|
payload.rndSeed = hitValue.rndSeed;
|
|
TraceRay(pRayTracingParams.scene, RAY_FLAG_CULL_BACK_FACING_TRIANGLES | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH, 0xff, 0, 0, 0,
|
|
rayDesc, payload);
|
|
|
|
// we have missed all geometry, so directional light is affecting us
|
|
if (!payload.hit) {
|
|
hitValue.light += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
|
|
}
|
|
}
|
|
for (uint i = 0; i < pLightEnv.numPointLights; ++i) {
|
|
RayPayload payload;
|
|
payload.rndSeed = hitValue.rndSeed;
|
|
float3 x = intersection_WS;
|
|
float3 l = pLightEnv.pointLights[i].position_WS.xyz - intersection_WS;
|
|
if (length(l) > pLightEnv.pointLights[i].colorRange.w) {
|
|
continue;
|
|
}
|
|
RayDesc rayDesc;
|
|
rayDesc.TMax = 1.0f;
|
|
rayDesc.TMin = eps;
|
|
rayDesc.Origin = x;
|
|
rayDesc.Direction = l;
|
|
TraceRay(pRayTracingParams.scene, RAY_FLAG_CULL_BACK_FACING_TRIANGLES | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH, 0xff, 0, 0, 0,
|
|
rayDesc, payload);
|
|
|
|
// hitting only after the light
|
|
if (!payload.hit) {
|
|
hitValue.light += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
|
|
}
|
|
}
|
|
} // end depth <= 2 direct lighting guard
|
|
// Indirect Illumination: probabilistic diffuse/specular importance sampling
|
|
if (hitValue.depth < 3) {
|
|
float3 V = -WorldRayDirection();
|
|
float3 N = normalLight_WS;
|
|
float rough = brdf.getRoughness();
|
|
float met = brdf.getMetallic();
|
|
float3 F0 = lerp(float3(0.04), brdf.getBaseColor(), met);
|
|
float NdotV = max(dot(N, V), 0.001);
|
|
float3 F = F0 + (1 - F0) * pow(1 - NdotV, 5.0);
|
|
float specProb = clamp((F.x + F.y + F.z) / 3.0, 0.1, 0.9);
|
|
|
|
RayDesc rayDesc;
|
|
rayDesc.TMax = 10000.0f;
|
|
rayDesc.TMin = eps;
|
|
rayDesc.Origin = intersection_WS;
|
|
|
|
float3 bounceWeight = float3(0);
|
|
bool validBounce = true;
|
|
|
|
if (rnd.z < specProb) {
|
|
// GGX importance sampling for specular reflection
|
|
float a = max(rough * rough, 0.001);
|
|
float a2 = a * a;
|
|
float phi = 2.0 * PI * rnd.x;
|
|
float cosTheta = sqrt((1.0 - rnd.y) / (1.0 + (a2 - 1.0) * rnd.y));
|
|
float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
|
|
|
|
float3 u = normalize(cross(abs(N.x) > 0.1 ? float3(0, 1, 0) : float3(1, 0, 0), N));
|
|
float3 v = cross(N, u);
|
|
float3 H = normalize(u * cos(phi) * sinTheta + v * sin(phi) * sinTheta + N * cosTheta);
|
|
float3 L = reflect(-V, H);
|
|
rayDesc.Direction = L;
|
|
|
|
float NdotL = dot(N, L);
|
|
float NdotH = max(dot(N, H), 0.0);
|
|
float VdotH = max(dot(V, H), 0.0);
|
|
|
|
if (NdotL <= 0) {
|
|
validBounce = false;
|
|
} else {
|
|
// Smith G term
|
|
float k = (rough + 1);
|
|
k = (k * k) / 8;
|
|
float G = (NdotV / (NdotV * (1 - k) + k)) * (NdotL / (NdotL * (1 - k) + k));
|
|
// Fresnel at half-vector
|
|
float3 Fh = F0 + (max(float3(1.0 - rough), F0) - F0) * pow(clamp(1 - VdotH, 0, 1), 5.0);
|
|
// Monte Carlo weight: F * G * VdotH / (NdotH * NdotV * specProb)
|
|
bounceWeight = Fh * G * VdotH / (NdotH * NdotV * specProb + 0.0001);
|
|
}
|
|
} else {
|
|
// Cosine-weighted importance sampling for diffuse
|
|
float r1 = 2 * PI * rnd.x, r2 = rnd.y, r2s = sqrt(r2);
|
|
float3 w = N;
|
|
float3 u = normalize(cross(abs(w.x) > 0.1 ? float3(0, 1, 0) : float3(1, 0, 0), w));
|
|
float3 v = cross(w, u);
|
|
rayDesc.Direction = normalize(u * cos(r1) * r2s + v * sin(r1) * r2s + w * sqrt(1 - r2));
|
|
// Diffuse weight: kd * baseColor / (1 - specProb)
|
|
float3 kd = (1 - F) * (1 - met);
|
|
bounceWeight = kd * brdf.getBaseColor() / (1 - specProb);
|
|
}
|
|
|
|
if (validBounce) {
|
|
RayPayload payload;
|
|
payload.light = float3(0);
|
|
payload.hit = false;
|
|
payload.emissive = 0;
|
|
payload.depth = hitValue.depth;
|
|
payload.anyHit = false;
|
|
payload.rndSeed = hitValue.rndSeed + 1;
|
|
TraceRay(pRayTracingParams.scene, RAY_FLAG_CULL_BACK_FACING_TRIANGLES, 0xff, 0, 0, 0, rayDesc, payload);
|
|
hitValue.light += bounceWeight * payload.light;
|
|
}
|
|
}
|
|
// hitValue.light /= p;
|
|
}
|