bool Renderer::buildAccelerationStructures(const std::vector<Entity *> &entities)
{
    // 1. Create BLAS for each unique mesh
    for (auto &mesh : uniqueMeshes) {
        buildBlas(mesh); // Compiles mesh data into a GPU-optimized format
    }

    // 2. Create TLAS by instancing BLASs
    std::vector<vk::AccelerationStructureInstanceKHR> instances;
    for (auto &entity : entities) {
        auto mesh = entity->getComponent<MeshComponent>();
        auto transform = entity->getComponent<TransformComponent>();

        vk::AccelerationStructureInstanceKHR instance{};
        instance.transform = toVkTransform(transform->getMatrix());
        instance.accelerationStructureReference = getBufferDeviceAddress(mesh->blas.buffer);
        instance.mask = 0xFF; // Allows filtering objects during ray tests
        instances.push_back(instance);
    }
    buildTlas(instances);

    return true;
}

[[vk::binding(11, 0)]] RaytracingAccelerationStructure tlas;

static const float RASTER_SHADOW_EPS = 0.002;

bool traceShadowOccluded(float3 origin, float3 direction, float tMin, float tMax)
{
    RayDesc ray;
    ray.Origin = origin;
    ray.Direction = direction;
    ray.TMin = tMin;
    ray.TMax = tMax;

    RayQuery<RAY_FLAG_NONE> q;
    q.TraceRayInline(
        tlas,
        RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH, // Optimization: any hit is enough to shadow
        0xFF,
        ray
    );

    while (q.Proceed()) {
        // q.Proceed() steps through potential hits.
        // For simple opaque shadows, we don't need logic here.
    }

    return (q.CommittedStatus() == COMMITTED_TRIANGLE_HIT);
}

// Inside the fragment shader lighting loop
float3 L = normalize(light.position.xyz - input.WorldPos);
float distToLight = length(light.position.xyz - input.WorldPos);

// Important: Move the origin slightly along the normal to prevent the ray
// from immediately hitting the surface it started from.
float3 shadowOrigin = input.WorldPos + N * RASTER_SHADOW_EPS;

bool occluded = traceShadowOccluded(shadowOrigin, L, RASTER_SHADOW_EPS, distToLight);

if (!occluded) {
    // Add diffuse and specular contributions if not in shadow
    directLighting += calculatePBR(L, V, N, ...);
}

// Generate a random sample on a disk to simulate light area
float2 diskSample = rqSampleDisk(rngState);
float3 samplePos = lightPos + (T * diskSample.x + B * diskSample.y) * lightRadius;

float3 L = normalize(samplePos - worldPos);
float distToLight = length(samplePos - worldPos);

// Trace a ray toward the sampled point on the light
bool occluded = traceShadowOccluded(shadowOrigin, L, RASTER_SHADOW_EPS, distToLight);

float visibilityAcc = 0.0;
for (int i = 0; i < shadowSampleCount; ++i) {
    // ... calculate jittered L ...
    visibilityAcc += traceShadowOccluded(...) ? 0.0 : 1.0;
}
float finalVisibility = visibilityAcc / float(shadowSampleCount);

// Use visibility to scale the light's contribution
directLighting += calculatePBR(...) * finalVisibility;