Skip to content

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

10.1 KB
Raw Blame
// Optional dielectric extensions. Legacy materials do not execute these draws
// or allocate their extra packed material lane.
var<private> transport_wavelength: f32=0.0;
var<private> transport_medium_id: f32=0.0;
var<private> transport_medium_ior: f32=1.0;
var<private> transport_medium_sigma: vec3<f32>=vec3<f32>(0.0);
var<private> transport_medium_scatter: f32=0.0;
var<private> transport_source_triangle: u32=0xffffffffu;
var<private> transport_connection_origin: vec3<f32>=vec3<f32>(0.0);
var<private> transport_connection_origin_low: vec3<f32>=vec3<f32>(0.0);
var<private> transport_boundary_connection: bool=false;
fn glass_wavelength(channel: u32) -> f32 {
    return array<f32,3>(610.0,550.0,460.0)[channel];
}
fn glass_ior(base: f32, abbe: f32, wavelength: f32) -> f32 {
    if abbe<=0.0 || wavelength<=0.0 {return base;}
    let f=486.1327;let c=656.2725;let d=587.5618;
    let b=((base-1.0)/abbe)/(1.0/(f*f)-1.0/(c*c));
    return base+b*(1.0/(wavelength*wavelength)-1.0/(d*d));
}
fn glass_cmul(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
    return vec2<f32>(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);
}
fn glass_cdiv(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
    return vec2<f32>(dot(a,b),a.y*b.x-a.x*b.y)/dot(b,b);
}
fn glass_complex_cosine(incident_sine_squared: f32, ni: f32, nt: f32) -> vec2<f32> {
    let square=1.0-(ni/nt)*(ni/nt)*incident_sine_squared;
    return vec2<f32>(sqrt(max(square,0.0)),sqrt(max(-square,0.0)));
}
// Lossless coherent single film between the actual incident and transmitted
// media. Complex admittances retain evanescent waves and frustrated film TIR.
fn glass_film_polarization(cosine: f32, ni: f32, nt: f32, nf: f32, thickness: f32, wavelength: f32, p: bool) -> f32 {
    let sin2=max(0.0,1.0-cosine*cosine);
    let cf=glass_complex_cosine(sin2,ni,nf);
    let ct=glass_complex_cosine(sin2,ni,nt);
    let q0=vec2<f32>(select(ni*cosine,cosine/ni,p),0.0);
    let qf=cf*select(nf,1.0/nf,p);
    let qt=ct*select(nt,1.0/nt,p);
    let phase=cf*(2.0*PI*nf*thickness/wavelength);
    var numerator=vec2<f32>(0.0);var denominator=vec2<f32>(0.0);
    if dot(phase,phase)<0.0001 {
        // Characteristic-matrix limit avoids Airy's cancellation/0÷0 at the
        // film critical angle. sin(phase)/qf has a finite analytic limit.
        let phase2=glass_cmul(phase,phase);
        let phase4=glass_cmul(phase2,phase2);
        let cosine_phase=vec2<f32>(1.0,0.0)-phase2*0.5+phase4/24.0;
        let sinc=vec2<f32>(1.0,0.0)-phase2/6.0+phase4/120.0;
        let ratio=sinc*(2.0*PI*thickness/wavelength*select(1.0,nf*nf,p));
        let a=cosine_phase+glass_cmul(vec2<f32>(-ratio.y,ratio.x),qt);
        let qsin=glass_cmul(qf,glass_cmul(phase,sinc));
        let b=vec2<f32>(-qsin.y,qsin.x)+glass_cmul(cosine_phase,qt);
        numerator=glass_cmul(q0,a)-b;denominator=glass_cmul(q0,a)+b;
    } else {
        let r01=glass_cdiv(q0-qf,q0+qf);
        let r12=glass_cdiv(qf-qt,qf+qt);
        // This decaying form stays finite for thick evanescent films.
        let wave=exp(-2.0*phase.y)*vec2<f32>(cos(2.0*phase.x),sin(2.0*phase.x));
        let delayed=glass_cmul(r12,wave);
        numerator=r01+delayed;denominator=vec2<f32>(1.0,0.0)+glass_cmul(r01,delayed);
    }
    let reflected=glass_cdiv(numerator,denominator);
    return clamp(dot(reflected,reflected),0.0,1.0);
}
fn glass_film(cosine: f32, ni: f32, nt: f32, nf: f32, thickness: f32, wavelength: f32) -> vec2<f32> {
    let bare=dielectric(cosine,ni,nt);
    if thickness<=0.0 || nf==ni || nf==nt {return bare.xy;}
    if bare.z<0.0 {return vec2<f32>(1.0);}
    if cosine==0.0 {
        if ni!=nt || ni!=nf {return vec2<f32>(1.0);}
        return vec2<f32>(0.0);
    }
    return vec2<f32>(glass_film_polarization(cosine,ni,nt,nf,thickness,wavelength,false),glass_film_polarization(cosine,ni,nt,nf,thickness,wavelength,true));
}
fn glass_reflection(t: Triangle, cosine: f32, ni: f32, nt: f32, wavelength: f32) -> vec3<f32> {
    let bare=dielectric(cosine,ni,nt);
    if t.glass.z<=0.0 {return vec3<f32>((bare.x+bare.y)*0.5);}
    if wavelength>0.0 {
        let f=glass_film(cosine,ni,nt,t.glass.w,t.glass.z,wavelength);
        return vec3<f32>((f.x+f.y)*0.5);
    }
    var result=vec3<f32>(0.0);
    for(var channel=0u;channel<3u;channel+=1u) {
        let f=glass_film(cosine,ni,nt,t.glass.w,t.glass.z,glass_wavelength(channel));
        result[channel]=(f.x+f.y)*0.5;
    }
    return result;
}
fn glass_sheet(t: Triangle, f: vec3<f32>, cosine: f32, ni: f32, nt: f32, wavelength: f32) -> Sheet {
    if t.glass.z<=0.0 {return sheet(t,f);}
    if f.z<0.0 {return Sheet(vec3<f32>(1.0),vec3<f32>(0.0));}
    var attenuation=vec3<f32>(1.0);
    if t.parameters.w>0.0 {
        if f.z==0.0 {atomicOr(&failures[7],2u);return Sheet(vec3<f32>(0.0),vec3<f32>(0.0));}
        attenuation=exp(-t.optics.xyz*(t.parameters.w/f.z));
    }
    var result=Sheet(vec3<f32>(0.0),vec3<f32>(0.0));
    for(var channel=0u;channel<3u;channel+=1u) {
        let lambda=select(glass_wavelength(channel),wavelength,wavelength>0.0);
        let coated=glass_film(cosine,ni,nt,t.glass.w,t.glass.z,lambda);
        let s=sheet_polarization(coated.x,attenuation);
        let p=sheet_polarization(coated.y,attenuation);
        result.reflection[channel]=(s.reflection[channel]+p.reflection[channel])*0.5;
        result.transmission[channel]=(s.transmission[channel]+p.transmission[channel])*0.5;
    }
    return result;
}
fn glass_smith_weight(nv: f32, nl: f32, alpha: f32) -> f32 {
    let cv=abs(nv);let cl=abs(nl);
    if cv<=0.0 || cl<=0.0 {return 0.0;}
    let sv=sqrt(cv*cv+alpha*alpha*max(0.0,1.0-cv*cv));
    let sl=sqrt(cl*cl+alpha*alpha*max(0.0,1.0-cl*cl));
    // Height-correlated G2/G1 without squared tangent division or inf/inf.
    if cv>=cl {let ratio=cl/cv;return ratio*(cv+sv)/(sv*ratio+sl);}
    return (cv+sv)/(sv+sl*(cv/cl));
}
fn glass_visible_normal(n: vec3<f32>, view: vec3<f32>, alpha: f32, variates: vec2<f32>) -> vec3<f32> {
    let axis=select(vec3<f32>(0.0,0.0,1.0),vec3<f32>(1.0,0.0,0.0),abs(n.z)>=0.9);
    let x=unit(cross(axis,n));let y=cross(n,x);
    let v=vec3<f32>(dot(view,x),dot(view,y),dot(view,n));
    let stretched=unit(vec3<f32>(alpha*v.xy,v.z));
    let length_squared=dot(stretched.xy,stretched.xy);
    var t1=vec3<f32>(1.0,0.0,0.0);
    if length_squared>0.0 {t1=vec3<f32>(-stretched.y,stretched.x,0.0)/sqrt(length_squared);}
    let t2=cross(stretched,t1);
    let radius=sqrt(variates.x);let phi=2.0*PI*variates.y;
    let a=radius*cos(phi);var b=radius*sin(phi);
    let s=(1.0+stretched.z)*0.5;
    b=(1.0-s)*sqrt(max(0.0,1.0-a*a))+s*b;
    let normal=a*t1+b*t2+sqrt(max(0.0,1.0-a*a-b*b))*stretched;
    let h=unit(vec3<f32>(alpha*normal.xy,max(0.0,normal.z)));
    return unit(x*h.x+y*h.y+n*h.z);
}
struct GlassEvent {direction:vec3<f32>,weight:vec3<f32>,transmitted:bool,valid:bool};
fn glass_rough_active(t:Triangle,ni:f32,nt:f32)->bool {
    return t.glass.x>0.0 && !(ni==nt && (t.glass.z<=0.0 || t.glass.w==ni));
}
fn glass_macro_normal(incident:vec3<f32>,normal:vec3<f32>,geometric:vec3<f32>,ni:f32,nt:f32)->vec3<f32> {
    if glass_geometric_normals() {return geometric;}
    let f=dielectric(clamp(dot(normal,-incident),0.0,1.0),ni,nt);
    let transmitted=refract(incident,normal,ni/nt);
    if (f.z>=0.0 && dot(transmitted,geometric)>=0.0) || dot(reflect(incident,normal),geometric)<=0.0 {return geometric;}
    return normal;
}
fn glass_interface(t:Triangle,incident:vec3<f32>,macro_normal:vec3<f32>,geometric:vec3<f32>,ni:f32,nt:f32,wavelength:f32,radiance:bool,stratum:u32,strata:u32,rng:ptr<function,u32>) -> GlassEvent {
    var normal=macro_normal;
    let rough=glass_rough_active(t,ni,nt);
    if rough && dot(macro_normal,-incident)<=0.0 {return GlassEvent(incident,vec3<f32>(0.0),false,false);}
    if rough {normal=glass_visible_normal(macro_normal,-incident,t.glass.x*t.glass.x,vec2<f32>(random(rng),random(rng)));}
    let f=dielectric(clamp(dot(normal,-incident),0.0,1.0),ni,nt);
    let reflection=glass_reflection(t,clamp(dot(normal,-incident),0.0,1.0),ni,nt,wavelength);
    let probability=dot(reflection,vec3<f32>(1.0/3.0));
    var branch=random(rng);
    if strata>1u {branch=(f32(stratum)+branch)/f32(strata);*rng^=(stratum+1u)*0x85ebca6bu;}
    let reflected=branch<probability;
    var outgoing=reflect(incident,normal);var weight=vec3<f32>(0.0);
    if reflected {
        if dot(outgoing,geometric)<=0.0 {return GlassEvent(outgoing,weight,false,false);}
        weight=reflection/probability;
    } else {
        outgoing=unit(refract(incident,normal,ni/nt));
        if f.z<0.0 || dot(outgoing,geometric)>=0.0 {return GlassEvent(outgoing,weight,true,false);}
        weight=(vec3<f32>(1.0)-reflection)/(1.0-probability);
        if radiance {weight*=(ni/nt)*(ni/nt);}
    }
    if rough {weight*=glass_smith_weight(dot(macro_normal,-incident),dot(macro_normal,outgoing),t.glass.x*t.glass.x);}
    return GlassEvent(outgoing,weight,!reflected,true);
}
struct GlassSheetWalk {direction:vec3<f32>,weight:vec3<f32>,consumed:u32,valid:bool};
fn glass_rough_sheet(t:Triangle,incident:vec3<f32>,normal:vec3<f32>,outside:f32,inside:f32,wavelength:f32,radiance:bool,remaining:u32,stratum:u32,strata:u32,rng:ptr<function,u32>) -> GlassSheetWalk {
    var direction=incident;var weight=vec3<f32>(1.0);var internal=false;
    for(var event=0u;event<remaining;event+=1u) {
        let macro_normal=select(-normal,normal,dot(direction,normal)<0.0);
        let ni=select(outside,inside,internal);let nt=select(inside,outside,internal);
        let sampled=glass_interface(t,direction,macro_normal,macro_normal,ni,nt,wavelength,radiance,stratum,select(1u,strata,event==0u),rng);
        if !sampled.valid {return GlassSheetWalk(sampled.direction,vec3<f32>(0.0),event+1u,false);}
        direction=sampled.direction;weight*=sampled.weight;
        if (!internal && !sampled.transmitted) || (internal && sampled.transmitted) {return GlassSheetWalk(direction,weight,event+1u,true);}
        internal=true;
        let cosine=abs(dot(direction,normal));
        if cosine==0.0 {return GlassSheetWalk(direction,vec3<f32>(0.0),event+1u,false);}
        if t.parameters.w>0.0 {weight*=exp(-t.optics.xyz*(t.parameters.w/cosine));}
        if !any(weight>vec3<f32>(0.0)) {return GlassSheetWalk(direction,weight,event+1u,false);}
    }
    return GlassSheetWalk(direction,vec3<f32>(0.0),remaining,false);
}