struct Geometry { size:vec4<u32>, transfer:vec4<u32> }
@group(0) @binding(0) var<storage,read> source:array<u32>;
@group(0) @binding(1) var<storage,read> palette:array<u32>;
@group(0) @binding(2) var<storage,read> columns:array<vec2<u32>>;
@group(0) @binding(3) var<storage,read> rows:array<vec2<u32>>;
@group(0) @binding(4) var<storage,read_write> output:array<u32>;
@group(0) @binding(5) var<uniform> geometry:Geometry;
@compute @workgroup_size(8,8) fn blit(@builtin(global_invocation_id) id:vec3<u32>) {
if id.x>=geometry.size.y || id.y>=geometry.size.z {return;}
let xs=columns[id.x]; let ys=rows[id.y];
var value=0u;
for(var y=ys.x;y<ys.y;y++) {
for(var x=xs.x;x<xs.y;x++) {value=max(value,source[y*geometry.size.x+x]);}
}
if geometry.size.w!=0u {value=palette[value];}
if geometry.transfer.x!=0u {value=direct_color(value);}
output[id.y*geometry.size.y+id.x]=value;
}
@compute @workgroup_size(8,8) fn packed_copy(@builtin(global_invocation_id) id:vec3<u32>) {
if id.x>=geometry.size.y || id.y>=geometry.size.z {return;}
let index=id.y*geometry.size.y+id.x;
var value=columns[index].x;
let depth=geometry.size.w;
let mask=(1u<<depth)-1u;
for(var lane=0u;lane<8u/depth;lane++) {
let bit=id.x*8u+lane*depth;
if bit>=geometry.transfer.y && bit<geometry.transfer.y+geometry.transfer.z*depth {
let source_bit=geometry.transfer.x+bit-geometry.transfer.y;
var pixel=(source[id.y*geometry.size.x+source_bit/8u]>>(8u-depth-source_bit%8u))&mask;
if geometry.transfer.w!=0u {pixel=palette[pixel];}
let shift=8u-depth-bit%8u;
value=(value&~(mask<<shift))|(pixel<<shift);
}
}
output[index]=value;
}
fn direct_color(pixel:u32) -> u32 {
var rgb=vec3<u32>((pixel>>16u)&255u,(pixel>>8u)&255u,pixel&255u);
if geometry.transfer.x==16u {
let channels=vec3<u32>((pixel>>10u)&31u,(pixel>>5u)&31u,pixel&31u);
rgb=((channels*65535u+vec3<u32>(15u))/31u)>>vec3<u32>(8u);
}
let depth=geometry.transfer.y;
if depth==32u {return (rgb.x<<16u)|(rgb.y<<8u)|rgb.z;}
if depth==16u {return ((rgb.x>>3u)<<10u)|((rgb.y>>3u)<<5u)|(rgb.z>>3u);}
// Exact squared-distance comparison against black/white after 8-to-16-bit expansion.
if depth==1u && geometry.transfer.x==32u {return select(0u,1u,rgb.x+rgb.y+rgb.z<=382u);}
let requested_color=vec3<i32>(rgb>>vec3<u32>(3u));
var best=0u; var best_distance=0xffffffffu;
for(var i=0u;i<geometry.transfer.z;i++) {
let color=palette[i];
let delta=requested_color-vec3<i32>(i32((color>>10u)&31u),i32((color>>5u)&31u),i32(color&31u));
let distance=u32(delta.x*delta.x+delta.y*delta.y+delta.z*delta.z);
if distance<best_distance {best=i;best_distance=distance;}
}
return best;
}
@group(0) @binding(6) var<storage,read> coverage:array<u32>;
@compute @workgroup_size(8,8) fn blit_cells(@builtin(global_invocation_id) id:vec3<u32>) {
if id.x>=geometry.size.y || id.y>=geometry.size.z {return;}
let xs=columns[id.x]; let ys=rows[id.y];
var value=0u;
for(var y=ys.x;y<ys.y;y++) {
for(var x=xs.x;x<xs.y;x++) {value=max(value,source[y*geometry.size.x+x]);}
}
let index=id.y*geometry.size.y+id.x;
var covered=true;
if (coverage[0]&1u)!=0u {covered=coverage[index+3u]!=0u;}
if (coverage[0]&2u)!=0u && (value&coverage[2])==coverage[1] {covered=false;}
if geometry.size.w!=0u {value=palette[value];}
if geometry.transfer.x!=0u {value=direct_color(value);}
output[index*2u]=value;
output[index*2u+1u]=select(0u,1u,covered);
}
@group(0) @binding(7) var<storage,read> arithmetic:array<u32>;
fn arithmetic_rgb(pixel:u32,clut:u32) -> vec3<u32> {
let depth=arithmetic[0];
if depth==16u {
return (vec3<u32>((pixel>>10u)&31u,(pixel>>5u)&31u,pixel&31u)*65535u+vec3<u32>(15u))/31u;
}
if depth==32u {return vec3<u32>((pixel>>16u)&255u,(pixel>>8u)&255u,pixel&255u)*257u;}
let offset=clut+pixel*3u;
return vec3<u32>(arithmetic[offset],arithmetic[offset+1u],arithmetic[offset+2u]);
}
fn arithmetic_channel(s:u32,d:u32,op:u32) -> u32 {
switch arithmetic[1] {
case 32u: {return (s*op+d*(65536u-op))>>16u;}
case 33u: {return min(min(s+d,65535u),op);}
case 34u: {return (s+d)&65535u;}
case 35u: {return max(s-min(s,d),op);}
case 37u: {return max(s,d);}
case 38u: {return (s+65536u-d)&65535u;}
default: {return min(s,d);}
}
}
fn arithmetic_pixel(s:u32,d:u32) -> u32 {
let depth=arithmetic[0];let mode=arithmetic[1];
if depth==1u {
if mode==32u {return s;}
if mode==33u || mode==37u {return d&~s;}
if mode==34u || mode==38u {return d^s;}
return d|s;
}
let clut=6u+arithmetic[2]*3u;
let source_rgb=arithmetic_rgb(s,6u);let destination_rgb=arithmetic_rgb(d,clut);
let rgb=vec3<u32>(arithmetic_channel(source_rgb.x,destination_rgb.x,arithmetic[3]),
arithmetic_channel(source_rgb.y,destination_rgb.y,arithmetic[4]),
arithmetic_channel(source_rgb.z,destination_rgb.z,arithmetic[5]));
if depth==16u {return ((rgb.x>>11u)<<10u)|((rgb.y>>11u)<<5u)|(rgb.z>>11u);}
if depth==32u {return ((rgb.x>>8u)<<16u)|((rgb.y>>8u)<<8u)|(rgb.z>>8u);}
let requested_color=vec3<i32>(rgb>>vec3<u32>(11u));
var best=0u;var best_distance=0xffffffffu;
for(var i=0u;i<arithmetic[2];i++) {
let base=clut+i*3u;
let color=vec3<i32>(i32(arithmetic[base]>>11u),i32(arithmetic[base+1u]>>11u),i32(arithmetic[base+2u]>>11u));
let delta=requested_color-color;
let distance=u32(delta.x*delta.x+delta.y*delta.y+delta.z*delta.z);
if distance<best_distance {best=i;best_distance=distance;}
}
return best;
}
@compute @workgroup_size(8,8) fn blit_arithmetic(@builtin(global_invocation_id) id:vec3<u32>) {
if id.x>=geometry.size.y || id.y>=geometry.size.z {return;}
let xs=columns[id.x];let ys=rows[id.y];
let raw=source[ys.x*geometry.size.x+xs.x];
let index=id.y*geometry.size.y+id.x;
var covered=true;
if (coverage[0]&1u)!=0u {covered=coverage[index+3u]!=0u;}
if (coverage[0]&2u)!=0u && (raw&coverage[2])==coverage[1] {covered=false;}
let background=arithmetic[6u+arithmetic[2]*6u+index];
output[index*2u]=arithmetic_pixel(raw,background);
output[index*2u+1u]=select(0u,1u,covered);
}
@group(0) @binding(8) var<storage,read> deep_mask:array<u32>;
fn deep_rgb(depth:u32,pixel:u32,clut:u32) -> vec3<u32> {
if depth==1u {return select(vec3<u32>(0u),vec3<u32>(65535u),pixel==0u);}
if depth==16u {
let c=vec3<u32>((pixel>>10u)&31u,(pixel>>5u)&31u,pixel&31u);
if (deep_mask[3]&256u)!=0u {return (c<<vec3<u32>(11u))|(c<<vec3<u32>(6u))|(c<<vec3<u32>(1u))|(c>>vec3<u32>(4u));}
return (c*65535u+vec3<u32>(15u))/31u;
}
if depth==32u {return vec3<u32>((pixel>>16u)&255u,(pixel>>8u)&255u,pixel&255u)*257u;}
let base=clut+pixel*3u;return vec3<u32>(deep_mask[base],deep_mask[base+1u],deep_mask[base+2u]);
}
fn deep_encode(rgb:vec3<u32>,clut:u32) -> u32 {
let depth=deep_mask[1];
if depth==1u {return select(0u,1u,rgb.x+rgb.y+rgb.z<=98302u);}
if depth==16u {return ((rgb.x>>11u)<<10u)|((rgb.y>>11u)<<5u)|(rgb.z>>11u);}
if depth==32u {return ((rgb.x>>8u)<<16u)|((rgb.y>>8u)<<8u)|(rgb.z>>8u);}
if (deep_mask[3]&256u)!=0u {
// Classic inverse tables pin exact white to the first endpoint even
// when the terminal entry duplicates white; exact black prefers last.
if all(rgb==vec3<u32>(65535u)) && all(vec3<u32>(deep_mask[clut],deep_mask[clut+1u],deep_mask[clut+2u])==rgb) {return 0u;}
let last=deep_mask[5]-1u;
let endpoint=clut+last*3u;
if all(rgb==vec3<u32>(deep_mask[endpoint],deep_mask[endpoint+1u],deep_mask[endpoint+2u])) {return last;}
var best=0u;var best_low=0xffffffffu;var best_high=0xffffffffu;
for(var i=0u;i<deep_mask[5];i++) {
let base=clut+i*3u;
let color=vec3<u32>(deep_mask[base],deep_mask[base+1u],deep_mask[base+2u]);
if all(rgb==color) {return i;}
let delta=max(rgb,color)-min(rgb,color);
let square=delta*delta;
let rg=square.x+square.y;
let low=rg+square.z;
let high=select(0u,1u,rg<square.x)+select(0u,1u,low<rg);
if high<best_high || (high==best_high && low<best_low) {best=i;best_low=low;best_high=high;}
}
return best;
}
let requested_color=vec3<i32>(rgb>>vec3<u32>(11u));
var best=0u;var best_distance=0xffffffffu;
for(var i=0u;i<deep_mask[5];i++) {
let base=clut+i*3u;
let color=vec3<i32>(i32(deep_mask[base]>>11u),i32(deep_mask[base+1u]>>11u),i32(deep_mask[base+2u]>>11u));
let delta=requested_color-color;let distance=u32(delta.x*delta.x+delta.y*delta.y+delta.z*delta.z);
if distance<best_distance {best=i;best_distance=distance;}
}
return best;
}
fn deep_boolean(s:u32,d:u32) -> u32 {
var bits=0xffffffffu;if deep_mask[1]<32u {bits=(1u<<deep_mask[1])-1u;}
switch (deep_mask[3]&63u) {
case 1u: {return s|d;}
case 2u: {return s^d;}
case 3u: {return (~s)&d&bits;}
case 4u: {return (~s)&bits;}
case 5u: {return ((~s)&bits)|d;}
case 6u: {return ((~s)&bits)^d;}
case 7u: {return s&d;}
default: {return s;}
}
}
@compute @workgroup_size(8,8) fn blit_deep_mask(@builtin(global_invocation_id) id:vec3<u32>) {
if id.x>=geometry.size.y || id.y>=geometry.size.z {return;}
let raw=source[rows[id.y].x*geometry.size.x+columns[id.x].x];
let index=id.y*geometry.size.y+id.x;
let destination_clut=11u+deep_mask[4]*3u;
let mask_clut=destination_clut+deep_mask[5]*3u;
let mask_pixels=mask_clut+deep_mask[6]*3u;
let mask_columns=mask_pixels+deep_mask[7]*deep_mask[8];
let mask_rows=mask_columns+deep_mask[9];
let mask_pixel=deep_mask[mask_pixels+deep_mask[mask_rows+id.y]*deep_mask[7]+deep_mask[mask_columns+id.x]];
let destination=deep_mask[mask_rows+deep_mask[10]+index];
var covered=true;
if (coverage[0]&1u)!=0u {covered=coverage[index+3u]!=0u;}
if (coverage[0]&2u)!=0u && (raw&coverage[2])==coverage[1] {covered=false;}
var source_rgb=deep_rgb(deep_mask[0],raw,11u);
var value=0u;
if deep_mask[2]==1u {
covered=covered && mask_pixel!=0u;
value=deep_boolean(deep_encode(source_rgb,destination_clut),destination);
} else {
if (deep_mask[3]&63u)>=1u && (deep_mask[3]&63u)<=7u {
source_rgb=deep_rgb(deep_mask[1],deep_boolean(deep_encode(source_rgb,destination_clut),destination),destination_clut);
}
let d=deep_rgb(deep_mask[1],destination,destination_clut);
let m=deep_rgb(deep_mask[2],mask_pixel,mask_clut);
// Complementary weights keep the rounded numerator below 2^32.
let rgb=(source_rgb*(vec3<u32>(65535u)-m)+d*m+vec3<u32>(32767u))/65535u;
value=deep_encode(rgb,destination_clut);
}
output[index*2u]=value;output[index*2u+1u]=select(0u,1u,covered);
}