Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

19.7 KB
Raw Blame
// Bounded light tracing for delta-source caustics. Finite sources already have
// camera-path estimators and are deliberately absent from this source mixture.
// Header16 words, hash heads, then16-word immutable photon records.
@group(0) @binding(7) var<storage,read_write> photon_data:array<atomic<u32>>;
fn photon_word(index:u32)->u32 {return atomicLoad(&photon_data[index]);}
fn photon_float(index:u32)->f32 {return bitcast<f32>(photon_word(index));}
fn photon_vector(index:u32)->vec3<f32> {return vec3<f32>(photon_float(index),photon_float(index+1u),photon_float(index+2u));}
fn photon_store_vector(index:u32,value:vec3<f32>) {
    atomicStore(&photon_data[index],bitcast<u32>(value.x));
    atomicStore(&photon_data[index+1u],bitcast<u32>(value.y));
    atomicStore(&photon_data[index+2u],bitcast<u32>(value.z));
}
fn photon_cell(position:vec3<f32>)->vec3<i32> {
    return vec3<i32>(floor((position-photon_vector(6u))/photon_float(2u)));
}
fn photon_hash(cell:vec3<i32>)->u32 {
    let words=bitcast<vec3<u32>>(cell);
    return ((words.x*73856093u)^(words.y*19349663u)^(words.z*83492791u))&(photon_word(1u)-1u);
}
fn photon_record(index:u32)->u32 {return 16u+photon_word(1u)+index*16u;}
fn photon_bad_medium() {atomicOr(&failures[7],4u);}
fn photon_deposit(index:u32,position:vec3<f32>,incoming:vec3<f32>,flux:vec3<f32>,normal:vec3<f32>,receiver:u32,kind:u32,side:i32,source:u32) {
    let record=photon_record(index);
    photon_store_vector(record,position);photon_store_vector(record+4u,incoming);
    photon_store_vector(record+8u,flux);photon_store_vector(record+12u,normal);
    atomicStore(&photon_data[record+7u],receiver);atomicStore(&photon_data[record+11u],kind);
    let side_code=select(select(0u,1u,side>0),2u,side<0);
    atomicStore(&photon_data[record+15u],side_code|(source<<2u));
    let previous=atomicExchange(&photon_data[16u+photon_hash(photon_cell(position))],index);
    atomicStore(&photon_data[record+3u],previous);
}
// One uniformly selected eligible receiver per emitted path. Final multiplication
// by the bounded visit count preserves every receiver's expected power without
// allocating photons*depth records. The separate RNG never changes transport.
struct PhotonReservoir {
    visits:u32,rng:u32,position:vec3<f32>,incoming:vec3<f32>,flux:vec3<f32>,normal:vec3<f32>,receiver:u32,kind:u32,side:i32,
    source:vec3<f32>,source_low:vec3<f32>,minimum:f32,source_index:u32,
};
fn photon_offer(reservoir:ptr<function,PhotonReservoir>,point:PrecisePoint,incoming:vec3<f32>,flux:vec3<f32>,normal:vec3<f32>,receiver:u32,kind:u32,side:i32) {
    if (*reservoir).minimum>0.0 && length(precise_point_delta(point.hi,point.lo,(*reservoir).source,(*reservoir).source_low))<(*reservoir).minimum {punctual_count(0u);return;}
    if !all(flux>=vec3<f32>(0.0)) || !all(flux<=vec3<f32>(3.4e38)) {atomicOr(&failures[7],1u);return;}
    if !any(flux>vec3<f32>(0.0)) {return;}
    (*reservoir).visits+=1u;
    let count=(*reservoir).visits;
    // Naga30's SPIR-V writer cannot cache a pointer-to-field call argument
    // introduced in a short-circuit branch. Keep the same draws in a local RNG.
    var selected=count==1u;
    if count>1u {
        var selection_rng=(*reservoir).rng;
        selected=random(&selection_rng)<1.0/f32(count);
        (*reservoir).rng=selection_rng;
    }
    if selected {
        (*reservoir).position=point.hi+point.lo;(*reservoir).incoming=incoming;(*reservoir).flux=flux;
        (*reservoir).normal=normal;(*reservoir).receiver=receiver;(*reservoir).kind=kind;(*reservoir).side=side;
    }
}
@compute @workgroup_size(32)
fn photon_clear(@builtin(global_invocation_id) invocation:vec3<u32>) {
    if invocation.x>=u.sampling.z {return;}
    let index=photon_word(5u)+invocation.x;let heads=photon_word(1u);
    if index<heads {atomicStore(&photon_data[16u+index],0xffffffffu);}
    else if index<heads+photon_word(0u) {atomicStore(&photon_data[photon_record(index-heads)+11u],0u);}
}
fn photon_unit_sphere(rng:ptr<function,u32>)->vec3<f32> {
    let z=1.0-2.0*random(rng);let phi=2.0*PI*random(rng);let r=sqrt(max(0.0,1.0-z*z));
    return vec3<f32>(r*cos(phi),r*sin(phi),z);
}
@compute @workgroup_size(32)
fn photon_emit(@builtin(global_invocation_id) invocation:vec3<u32>) {
    if invocation.x>=u.sampling.z {return;}
    let index=photon_word(5u)+invocation.x;let count=photon_word(0u);
    if index>=count {return;}
    var reservoir:PhotonReservoir;
    reservoir.rng=index^(photon_word(4u)*0x85ebca6bu)^0x6b8b4567u;
    photon_trace(index,&reservoir);
    if reservoir.visits>0u {
        let flux=reservoir.flux*f32(reservoir.visits);
        if !all(flux>=vec3<f32>(0.0)) || !all(flux<=vec3<f32>(3.4e38)) {atomicOr(&failures[7],1u);return;}
        photon_deposit(index,reservoir.position,reservoir.incoming,flux,reservoir.normal,reservoir.receiver,reservoir.kind,reservoir.side,reservoir.source_index);
    }
}
fn photon_trace(index:u32,reservoir:ptr<function,PhotonReservoir>) {
    let count=photon_word(0u);
    var rng=index^(photon_word(4u)*0x9e3779b9u)^0x8da6b343u;
    let studio=u.environment.w>0.0;
    let directions=select(3u,u32(u.light_count.x),studio);
    let punctual=select(0u,u32(u.light_count.y),studio);
    let sources=directions+punctual;
    if sources==0u {return;}
    let selected=min(sources-1u,u32(random(&rng)*f32(sources)));
    (*reservoir).source_index=select(0u,selected-directions+1u,selected>=directions);
    var origin=vec3<f32>(0.0);var origin_low=vec3<f32>(0.0);
    var direction=vec3<f32>(0.0,0.0,-1.0);var flux=vec3<f32>(0.0);
    var source_minimum=0.0;
    if selected<directions {
        var toward=FIXED_LIGHTS[min(selected,2u)].xyz;
        var irradiance=vec3<f32>(FIXED_LIGHTS[min(selected,2u)].w*u.lighting.z*u.studio_weights[min(selected,2u)]);
        if studio {let light=u.directional_lights[min(selected,7u)];toward=light.direction.xyz;irradiance=light.color.xyz*light.direction.w;}
        direction=-toward;
        let center=(photon_vector(6u)+photon_vector(9u))*0.5;
        let radius=length(photon_vector(9u)-photon_vector(6u))*0.5;
        if !(radius>0.0) {return;}
        let axis=select(vec3<f32>(0.0,0.0,1.0),vec3<f32>(0.0,1.0,0.0),abs(direction.z)>0.9);
        let x=unit(cross(axis,direction));let y=cross(direction,x);
        let r=radius*sqrt(random(&rng));let phi=2.0*PI*random(&rng);
        origin=center-direction*(radius+max(u.lighting.x*2.0,radius*0.000001))+r*(cos(phi)*x+sin(phi)*y);
        flux=irradiance*(PI*radius*radius*f32(sources)/f32(count));
    } else {
        let light=u.punctual_lights[min(selected-min(selected,directions),7u)];
        origin=light.position.xyz;origin_low=light.position_low.xyz;source_minimum=light.position_low.w;
        var density=1.0/(4.0*PI);var cone=1.0;
        if light.cone.y>0.0 {
            let cosine=1.0-random(&rng)*(1.0-light.cone.x);let phi=2.0*PI*random(&rng);
            let sine=sqrt(max(0.0,1.0-cosine*cosine));
            direction=from_local(vec3<f32>(sine*cos(phi),sine*sin(phi),cosine),light.axis.xyz);
            density=1.0/(2.0*PI*(1.0-light.cone.x));
            let blend=clamp((cosine-light.cone.x)/(light.axis.w-light.cone.x),0.0,1.0);
            cone=blend*blend*(3.0-2.0*blend);
        } else {direction=photon_unit_sphere(&rng);}
        flux=light.color.xyz*(light.color.w*light.position.w*light.position.w*cone*f32(sources)/(density*f32(count)));
    }
    if !any(flux>vec3<f32>(0.0)) {return;}
    var wavelength=0.0;
    if (geometry[2]&0x40000000u)!=0u {
        let channel=min(2u,u32(random(&rng)*3.0));wavelength=glass_wavelength(channel);
        var mask=vec3<f32>(0.0);mask[channel]=3.0;flux*=mask;
    }
    transport_wavelength=wavelength;
    let source_position=origin;let source_position_low=origin_low;
    (*reservoir).source=source_position;(*reservoir).source_low=source_position_low;(*reservoir).minimum=source_minimum;
    var media:array<Medium,MEDIUM_CAPACITY>;var medium_count=0u;
    let first=origin_boundary(origin+origin_low,direction);
    if !first.valid {photon_bad_medium();return;}
    if first.hit.triangle!=0xffffffffu && !initialize_media_spectral(first.hit.triangle,direction,&media,&medium_count,wavelength) {photon_bad_medium();return;}
    var previous=origin;var previous_low=origin_low;var excluded=0xffffffffu;var minimum=0.0;var optical=false;
    let maximum=photon_word(3u);
    for(var depth=0u;depth<maximum;depth+=1u) {
        let hit=trace_precise(origin,origin_low,direction,false,excluded,minimum,medium_count>0u);
        let emitter=emitter_hit_precise(origin,origin_low,direction,minimum);
        if medium_count>0u && media[medium_count-1u].scatter.x>0.0 {
            let current=media[medium_count-1u];let flight=-log(1.0-random(&rng))/current.scatter.x;
            if flight<min(hit.distance,emitter.distance) {
                let point=origin+origin_low+direction*flight;
                flux*=exp(-current.sigma*length(precise_point_delta(point,vec3<f32>(0.0),previous,previous_low)));
                if optical {photon_offer(reservoir,PrecisePoint(point,vec3<f32>(0.0)),-direction,flux,vec3<f32>(0.0),bitcast<u32>(current.id),3u,0);}
                direction=sample_hg(direction,current.scatter.y,&rng);
                // Rounded free-flight positions must remain in the same certified
                // chain. Reuse its existing stack; never move a point to fit it.
                let expected=medium_count;let expected_top=current.id;
                let collision=origin_boundary(point,direction);
                if !collision.valid || collision.hit.triangle==0xffffffffu {photon_bad_medium();return;}
                if !initialize_media_spectral(collision.hit.triangle,direction,&media,&medium_count,wavelength) {photon_bad_medium();return;}
                if medium_count!=expected || media[medium_count-1u].id!=expected_top {photon_bad_medium();return;}
                origin=point;origin_low=vec3<f32>(0.0);
                previous=point;previous_low=vec3<f32>(0.0);excluded=0xffffffffu;minimum=0.0;optical=true;continue;
            }
        }
        if emitter.distance<hit.distance {return;}
        if hit.triangle==0xffffffffu {if medium_count>0u {photon_bad_medium();}return;}
        let t=triangle(hit.triangle);let point=surface_point_precise(t,hit.bary);
        let outward=unit(cross(t.p1.xyz-t.p0.xyz,t.p2.xyz-t.p0.xyz));let entering=dot(outward,direction)<0.0;
        let geometric=select(-outward,outward,entering);
        if medium_count>0u {flux*=exp(-media[medium_count-1u].sigma*length(precise_point_delta(point.hi,point.lo,previous,previous_low)));}
        if !all(flux>=vec3<f32>(0.0)) || !all(flux<=vec3<f32>(3.4e38)) {atomicOr(&failures[7],1u);return;}
        if !any(flux>vec3<f32>(0.0)) {return;}
        if t.base.w<=0.0 {
            if optical {photon_offer(reservoir,point,-direction,flux,geometric,hit.triangle,1u,0);}
            return;
        }
        var normal=unit(t.n0.xyz*hit.bary.x+t.n1.xyz*hit.bary.y+t.n2.xyz*hit.bary.z);
        if dot(normal,geometric)<0.0 {normal=-normal;}
        if dot(normal,-direction)<=0.0 {normal=geometric;}
        // All light tracing belongs to the reciprocal physical-normal mode.
        normal=geometric;
        var ni=1.0;if medium_count>0u {ni=media[medium_count-1u].ior;}
        var nt=glass_ior(t.parameters.z,t.glass.y,wavelength);
        if t.parameters.w>=0.0 {
            if medium_count>0u {photon_bad_medium();return;}
            if glass_rough_active(t,ni,nt) {
                normal=glass_macro_normal(direction,normal,geometric,ni,nt);
                var internal=false;var escaped=false;
                for(var event=0u;event<maximum-depth;event+=1u) {
                    let macro_normal=select(-normal,normal,dot(direction,normal)<0.0);
                    let virtual_geometric=select(-geometric,geometric,dot(direction,normal)<0.0);
                    let face_outward=select(virtual_geometric,-virtual_geometric,internal);
                    let side=select(-1,1,dot(face_outward,outward)>0.0);
                    if optical {photon_offer(reservoir,point,-direction,flux,outward,hit.triangle,2u,side);}
                    let incident_ior=select(ni,nt,internal);let next_ior=select(nt,ni,internal);
                    let sampled=glass_interface(t,direction,macro_normal,virtual_geometric,incident_ior,next_ior,wavelength,false,0u,1u,&rng);
                    if !sampled.valid {return;}
                    flux*=sampled.weight;
                    direction=sampled.direction;optical=true;
                    if (!internal && !sampled.transmitted) || (internal && sampled.transmitted) {depth+=event;escaped=true;break;}
                    internal=true;let cosine=abs(dot(direction,normal));
                    if cosine==0.0 {return;}
                    if t.parameters.w>0.0 {flux*=exp(-t.optics.xyz*(t.parameters.w/cosine));}
                }
                if !escaped || dot(direction,normal)*dot(direction,geometric)<=0.0 {return;}
            } else {
                var f=dielectric(clamp(dot(normal,-direction),0.0,1.0),ni,nt);
                let bent=refract(direction,normal,ni/nt);
                if (f.z>=0.0 && dot(bent,geometric)>=0.0) || dot(reflect(direction,normal),geometric)<=0.0 {normal=geometric;f=dielectric(clamp(dot(normal,-direction),0.0,1.0),ni,nt);}
                let weights=glass_sheet(t,f,clamp(dot(normal,-direction),0.0,1.0),ni,nt,wavelength);
                let r=dot(weights.reflection,vec3<f32>(1.0/3.0));let tr=dot(weights.transmission,vec3<f32>(1.0/3.0));
                if r+tr<=0.0 {return;}let probability=r/(r+tr);
                if random(&rng)<probability {let outgoing=reflect(direction,normal);flux*=weights.reflection/probability;direction=outgoing;optical=true;}
                else {flux*=weights.transmission/(1.0-probability);optical=optical || t.coat.w<=0.0;}
            }
            origin=point.hi+point.lo+direction*(u.lighting.x*2.0);origin_low=vec3<f32>(0.0);excluded=0xffffffffu;minimum=u.lighting.x;
        } else {
            if entering {
                var parent=0.0;if t.interior.w>0.0 {parent=triangle(max(u32(t.interior.w),1u)-1u).optics.w;}
                var actual=0.0;if medium_count>0u {actual=media[medium_count-1u].id;}
                if parent!=actual {photon_bad_medium();return;}
            } else {
                if medium_count==0u || media[medium_count-1u].id!=t.optics.w {photon_bad_medium();return;}
                nt=1.0;if medium_count>1u {nt=media[medium_count-2u].ior;}
            }
            // Geometric-normal fallback matches smooth camera transport before
            // drawing a visible rough normal. Wrong-side rough samples are null.
            normal=glass_macro_normal(direction,normal,geometric,ni,nt);
            if optical && glass_rough_active(t,ni,nt) {photon_offer(reservoir,point,-direction,flux,outward,hit.triangle,2u,0);}
            let sampled=glass_interface(t,direction,normal,geometric,ni,nt,wavelength,false,0u,1u,&rng);
            if !sampled.valid {return;}
            flux*=sampled.weight;direction=sampled.direction;optical=true;
            if sampled.transmitted {
                if entering {
                    if medium_count>=MEDIUM_CAPACITY {photon_bad_medium();return;}
                    media[medium_count]=Medium(t.optics.w,nt,t.optics.xyz,t.interior.xy);medium_count+=1u;
                } else {medium_count-=1u;}
            }
            if abs(dot(direction,geometric))<1e-6 {return;}
            origin=point.hi;origin_low=point.lo;excluded=hit.triangle;minimum=0.0;
        }
        previous=point.hi;previous_low=point.lo;
    }
}
fn photon_gather(t:Triangle,position:vec3<f32>,normal:vec3<f32>,geometric:vec3<f32>,view:vec3<f32>) -> vec3<f32> {
    let count=photon_word(0u);if count==0u || t.base.w>0.0 {return vec3<f32>(0.0);}
    let radius=photon_float(2u);let center=photon_cell(position);var result=vec3<f32>(0.0);
    for(var z=-1;z<=1;z+=1) {for(var y=-1;y<=1;y+=1) {for(var x=-1;x<=1;x+=1) {
        let cell=center+vec3<i32>(x,y,z);var index=photon_word(16u+photon_hash(cell));var visited=0u;
        loop {
            if index==0xffffffffu || index>=count || visited>=count {break;}visited+=1u;
            let record=photon_record(index);let point=photon_vector(record);let delta=point-position;
            if photon_word(record+11u)==1u && photon_receiver_allowed(record,position) && all(photon_cell(point)==cell) && dot(delta,delta)<=radius*radius && abs(dot(delta,geometric))<=radius*0.1 && dot(photon_vector(record+12u),geometric)>0.0 && triangle(min(photon_word(record+7u),max(geometry[0],1u)-1u)).optics.w==t.optics.w {
                let incoming=photon_vector(record+4u);
                if dot(incoming,normal)>0.0 && dot(incoming,geometric)>0.0 {result+=brdf(t,normal,view,incoming)*photon_vector(record+8u)*(dot(incoming,normal)/dot(incoming,geometric));}
            }
            index=photon_word(record+3u);
        }
    }}}
    return result/(PI*radius*radius);
}
fn photon_enabled()->bool {return photon_word(0u)>0u;}
fn photon_receiver_allowed(record:u32,position:vec3<f32>)->bool {
    let source=photon_word(record+15u)>>2u;
    if source==0u {return true;}
    if source>u32(u.light_count.y) {return false;}
    let light=u.punctual_lights[min(max(source,1u)-1u,7u)];
    return length(precise_point_delta(position,vec3<f32>(0.0),light.position.xyz,light.position_low.xyz))>=light.position_low.w;
}
fn photon_gather_glass(t:Triangle,position:vec3<f32>,normal:vec3<f32>,geometric:vec3<f32>,incident:vec3<f32>,ni:f32,nt:f32,wavelength:f32,side:i32)->vec3<f32> {
    let count=photon_word(0u);if count==0u {return vec3<f32>(0.0);}
    let radius=photon_float(2u);let center=photon_cell(position);var result=vec3<f32>(0.0);
    let outward=unit(cross(t.p1.xyz-t.p0.xyz,t.p2.xyz-t.p0.xyz));
    for(var z=-1;z<=1;z+=1) {for(var y=-1;y<=1;y+=1) {for(var x=-1;x<=1;x+=1) {
        let cell=center+vec3<i32>(x,y,z);var index=photon_word(16u+photon_hash(cell));var visited=0u;
        loop {
            if index==0xffffffffu || index>=count || visited>=count {break;}visited+=1u;
            let record=photon_record(index);let point=photon_vector(record);let delta=point-position;
            let side_code=select(select(0u,1u,side>0),2u,side<0);
            if photon_word(record+11u)==2u && (photon_word(record+15u)&3u)==side_code && photon_receiver_allowed(record,position) && all(photon_cell(point)==cell) && dot(delta,delta)<=radius*radius && abs(dot(delta,outward))<=radius*0.1 && dot(photon_vector(record+12u),outward)>0.0 && triangle(min(photon_word(record+7u),max(geometry[0],1u)-1u)).optics.w==t.optics.w {
                let incoming=photon_vector(record+4u);let projected=abs(dot(incoming,geometric));
                if projected>0.0 {result+=glass_evaluate_cosine(t.glass,incident,incoming,normal,geometric,ni,nt,wavelength)*photon_vector(record+8u)/projected;}
            }
            index=photon_word(record+3u);
        }
    }}}
    return result/(PI*radius*radius);
}
fn photon_gather_volume(position:vec3<f32>,incident:vec3<f32>,medium:Medium)->vec3<f32> {
    let count=photon_word(0u);if count==0u || medium.scatter.x<=0.0 {return vec3<f32>(0.0);}
    let radius=photon_float(2u);let center=photon_cell(position);var result=vec3<f32>(0.0);
    for(var z=-1;z<=1;z+=1) {for(var y=-1;y<=1;y+=1) {for(var x=-1;x<=1;x+=1) {
        let cell=center+vec3<i32>(x,y,z);var index=photon_word(16u+photon_hash(cell));var visited=0u;
        loop {
            if index==0xffffffffu || index>=count || visited>=count {break;}visited+=1u;
            let record=photon_record(index);let point=photon_vector(record);let delta=point-position;
            if photon_word(record+11u)==3u && photon_word(record+7u)==bitcast<u32>(medium.id) && photon_receiver_allowed(record,position) && all(photon_cell(point)==cell) && dot(delta,delta)<=radius*radius {
                result+=photon_vector(record+8u)*glass_hg_phase(dot(incident,photon_vector(record+4u)),medium.scatter.y);
            }
            index=photon_word(record+3u);
        }
    }}}
    return result*(3.0/(4.0*PI*radius*radius*radius*medium.scatter.x));
}