Photon-Centric Shading with VM-Based Interpretive Transport : A Programmable Light Engine

inline float schlickReflectance(float cosIncident, float indexRatio) {
    float r0 = (1.0f - indexRatio) / (1.0f + indexRatio);
    r0 = r0 * r0;
    return r0 + (1.0f - r0) * std::pow(1.0f - std::fabs(cosIncident), 5.0f);
}

inline bool refract(const Vec3& incident, const Vec3& normal,
                    float indexRatio, Vec3& refracted) {
    float cosIncident = std::clamp(incident.dot(normal), -1.0f, 1.0f);
    float etaI = 1.0f, etaT = indexRatio;
    Vec3 n = normal;

    // Handle inside/outside transition
    if (cosIncident > 0) {
        std::swap(etaI, etaT);
        n = normal * -1.0f;
    }

    float eta = etaI / etaT;
    float k = 1.0f - eta * eta * (1.0f - cosIncident * cosIncident);

    // Total internal reflection check
    if (k < 0) return false;

    refracted = incident * eta + n * (eta * cosIncident - std::sqrt(k));
    return true;
}

Vec3 cosineWeightedDirection(const Vec3& normal) {
    // Generate points on unit disk
    float u = uniformFloat();
    float v = uniformFloat();
    float radius = std::sqrt(u);
    float theta = 2.0f * 3.14159265359f * v;

    // Convert to hemisphere coordinates
    float x = radius * std::cos(theta);
    float y = radius * std::sin(theta);
    float z = std::sqrt(std::max(0.0f, 1.0f - u));

    // Build orthonormal basis
    Vec3 tangent = std::fabs(normal.z) < 0.999f
        ? Vec3{0, 0, 1} : Vec3{1, 0, 0};
    tangent = tangent.cross(normal).normalized();
    Vec3 bitangent = normal.cross(tangent);

    return (tangent * x + bitangent * y + normal * z).normalized();
}

// Sample point on light source
Vec3 lightPoint, lightNormal;
float lightPdf;  // PDF with respect to area
Vec3 lightEmission = light.samplePoint(rng, lightPoint, lightPdf, lightNormal);

// Compute geometry factor components
Vec3 toLight = lightPoint - hitPoint;
float distanceSquared = toLight.dot(toLight);
float distance = std::sqrt(distanceSquared);
toLight = toLight / distance;

float cosineHit = std::max(0.0f, hit.normal.dot(toLight));
float cosineLight = std::max(0.0f, lightNormal.dot(-toLight));

// BRDF for diffuse surface
Vec3 brdf = albedo * (1.0f / 3.14159265359f);

// Final contribution
float geometryFactor = cosineHit * cosineLight / distanceSquared;
Vec3 contribution = lightEmission * brdf * (geometryFactor / lightPdf);

class DiffuseMaterial : public Material {
    Vec3 albedoColor;

public:
    CodeBlock compileShader() const override {
        CodeBlock block;
        // Sample direct lighting with albedo
        block.instructions.push_back({
            Opcode::DirectLighting,
            albedoColor.x, albedoColor.y, albedoColor.z, 0
        });
        // Scatter for indirect lighting
        block.instructions.push_back({
            Opcode::Scatter,
            albedoColor.x, albedoColor.y, albedoColor.z, 0
        });
        block.instructions.push_back({Opcode::Return, 0, 0, 0, 0});
        return block;
    }
};

class GlassMaterial : public Material {
    float refractiveIndex;

public:
    CodeBlock compileShader() const override {
        CodeBlock block;
        // Compute Fresnel reflectance
        block.instructions.push_back({Opcode::Fresnel, refractiveIndex, 0, 0, 0});
        // Jump based on Fresnel probability
        block.instructions.push_back({Opcode::JumpProbability, -1, 0, 0, 4});
        // Refraction path
        block.instructions.push_back({Opcode::Refract, refractiveIndex, 0, 0, 0});
        block.instructions.push_back({Opcode::Return, 0, 0, 0, 0});
        // Reflection path
        block.instructions.push_back({Opcode::Reflect, 0, 0, 0, 0});
        block.instructions.push_back({Opcode::Return, 0, 0, 0, 0});
        return block;
    }
};

static Vec3 executeShader(const Scene& scene, const RectangularLight& light,
                            RandomGenerator& rng, const HitRecord& hit,
                            Ray& nextRay, Vec3& throughput,
                            ExecutionContext& context) {
    Vec3 radiance{0, 0, 0};

    while (true) {
        const CodeBlock& block = scene.getShaderProgram().blocks[context.currentBlock];
        const Instruction& instruction = block.instructions[context.instructionPointer];

        switch (instruction.opcode) {
            case Opcode::Scatter: {
                Vec3 albedo{instruction.paramA, instruction.paramB, instruction.paramC};
                nextRay.direction = rng.cosineWeightedDirection(hit.normal);
                throughput = throughput * albedo;
                context.instructionPointer++;
                break;
            }

            case Opcode::JumpProbability: {
                float probability = instruction.paramA < 0
                    ? context.reflectionProbability
                    : instruction.paramA;
                if (rng.uniformFloat() < probability) {
                    context.instructionPointer = instruction.targetAddress;
                } else {
                    context.instructionPointer++;
                }
                break;
            }
            // ... other opcodes ...
        }
    }
    return radiance;
}

pixel(320,320)
hit white
  direct
  scatter
  ret
hit mirror
  call
  reflect
  ret
  ret
hit glass
  fresnel
  jmp
  refract
  ret
---

class MirrorMaterial : public Material {
    int reflectionLibraryId;

public:
    CodeBlock compileShader() const override {
        CodeBlock block;
        // Call the shared reflection implementation
        block.instructions.push_back({Opcode::Call, 0, 0, 0, reflectionLibraryId});
        block.instructions.push_back({Opcode::Return, 0, 0, 0, 0});
        return block;
    }
};

Scene scene;

// Register materials
int whiteMaterial = scene.addMaterial(
    std::make_unique<DiffuseMaterial>(Vec3{0.78f, 0.78f, 0.78f}, "white")
);
int mirrorMaterial = scene.addMaterial(
    std::make_unique<MirrorMaterial>(0, "mirror")
);
int glassMaterial = scene.addMaterial(
    std::make_unique<GlassMaterial>(1.5f, "glass")
);

// Build geometry
scene.addGeometry(std::make_unique<Sphere>(Vec3{0, 0, 3}, 0.5f, glassMaterial));

// Compile all shaders to VM bytecode
scene.compileShaders();

// Create renderer with debugging enabled
WavefrontRenderer renderer(scene, camera, light, settings);
renderer.render();

// Save outputs including debug information
renderer.saveImage("beauty.ppm");
renderer.saveHeatMap("complexity.ppm");
renderer.saveDebugTrace("photon_trace.txt");
renderer.saveIRDump("shader_bytecode.txt");

case Opcode::DirectLighting: {
    Vec3 albedo{instruction.paramA, instruction.paramB, instruction.paramC};

    // Sample a point on the light
    Vec3 lightPoint, lightNormal;
    float lightPdf;
    Vec3 lightEmission = light.samplePoint(rng, lightPoint, lightPdf, lightNormal);

    // Compute geometry
    Vec3 toLight = lightPoint - hitPoint;
    float distanceSquared = toLight.dot(toLight);
    float distance = std::sqrt(distanceSquared);
    toLight = toLight / distance;

    // Check visibility
    Ray shadowRay{hitPoint, toLight};
    HitRecord shadowHit = scene.traceRay(shadowRay);

    if (!shadowHit.isHit || shadowHit.distance > distance - 1e-3f) {
        // Compute contribution
        float cosineHit = std::max(0.0f, hit.normal.dot(toLight));
        float cosineLight = std::max(0.0f, lightNormal.dot(-toLight));

        Vec3 brdf = albedo * (1.0f / 3.14159265359f);
        float geometryFactor = cosineHit * cosineLight / distanceSquared;

        radiance += lightEmission * brdf * (geometryFactor / lightPdf);
    }

    context.instructionPointer++;
    break;
}

// Instead of interpreting, compile to native code
class JITCompiler {
    using ShaderFunc = Vec3(*)(
        const HitRecord&,
        Ray&,
        Vec3&,
        RandomGenerator&
    );

    ShaderFunc compile(const CodeBlock& block) {
        // Use LLVM or similar to generate native code
        // Each opcode becomes inlined assembly
        // Branches become native jumps
        // No more switch statements!

        return generatedFunction;
    }
};