diff --git a/b/8b0b5899ed/audio-worklet.js b/b/8b0b5899ed/audio-worklet.js new file mode 100644 index 0000000000000000000000000000000000000000..63486f5e2eaa0d13e7e9b44a73c167b4c6acff6f --- /dev/null +++ b/b/8b0b5899ed/audio-worklet.js @@ -0,0 +1,29 @@ +// AudioWorklet processor: plays the engine mixer's stereo output from the ring buffer in the shared wasm memory +// (platform/audio/browser_audio_wasm.cpp). Header (uint32 words): write, read, capacity, heartbeat; float data (interleaved L R) at byte 64. +class GameAudio extends AudioWorkletProcessor { + constructor(options) { + super(); + const { memory, ring, capacity } = options.processorOptions; + this.hdr = new Int32Array(memory.buffer, ring, 8); // word 4: peak sample since the page last looked (x 1e6), diagnostics + this.data = new Float32Array(memory.buffer, ring + 64, capacity * 2); + this.mask = capacity - 1; + } + process(inputs, outputs) { + const out = outputs[0], left = out[0], right = out[1] || out[0], n = left.length; + const read = Atomics.load(this.hdr, 1), write = Atomics.load(this.hdr, 0); + const avail = (write - read) >>> 0, take = Math.min(avail, n); + for (let i = 0; i < take; i++) { + const at = ((read + i) & this.mask) * 2; + left[i] = this.data[at]; + right[i] = this.data[at + 1]; + } + let peak = 0; + for (let i = 0; i < take; i++) peak = Math.max(peak, Math.abs(left[i]), Math.abs(right[i])); + if (peak > 0) Atomics.store(this.hdr, 4, Math.max(Atomics.load(this.hdr, 4), (peak * 1e6) | 0)); + for (let i = take; i < n; i++) { left[i] = 0; right[i] = 0; } // underrun: silence + Atomics.store(this.hdr, 1, (read + take) | 0); + Atomics.add(this.hdr, 3, 1); + return true; + } +} +registerProcessor('game-audio', GameAudio); diff --git a/b/8b0b5899ed/game.js b/b/8b0b5899ed/game.js new file mode 100644 index 0000000000000000000000000000000000000000..1c4df45e9c7831396824de363605dac4aa8db6f7 --- /dev/null +++ b/b/8b0b5899ed/game.js @@ -0,0 +1 @@ +var Module=typeof Module!="undefined"?Module:{};var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var ENVIRONMENT_IS_PTHREAD=ENVIRONMENT_IS_WORKER&&globalThis.name=="em-pthread";(function(){const lines=[];const name=typeof ENVIRONMENT_IS_PTHREAD!=="undefined"&&ENVIRONMENT_IS_PTHREAD?"pthread":"main";const remoteLog=!!Module["remoteLog"]||/[?&]log=1/.test(self.location.search);let logChannel=null;globalThis.__logFlush=function(){if(!lines.length)return;try{(logChannel||(logChannel=new BroadcastChannel("game-log"))).postMessage(lines.splice(0).join("\n"))}catch(e){lines.length=0}};globalThis.__log=remoteLog?function(s){lines.push(s);globalThis.__logFlush()}:function(){};const ring=[];let crashSent=0;globalThis.__crash=function(kind,text){if(crashSent++>=3)return;try{new BroadcastChannel("game-crash").postMessage({kind,thread:name,text:String(text).slice(0,4e3),heap:typeof(growMemViews(),HEAPU8)!=="undefined"?(growMemViews(),HEAPU8).length/1048576|0:-1,tail:ring.slice()})}catch(e){}};addEventListener("error",function(e){const s="THREAD ERROR ("+name+"): "+(e.error&&e.error.stack||e.message);console.error(s);globalThis.__log(s);globalThis.__logFlush();globalThis.__crash("error",s)});const bc=new BroadcastChannel("game-progress");const stages=[[/^Audio rpf =/,24,"Mounting archives"],[/Using Settings/,38,"Reading settings"],[/created D3D11/,45,"Starting graphics"],[/CShaderLib::Init/,50,"Loading shaders"],[/LOAD_ADDITIONAL_TEXT - finished/,56,"Loading text"],[/Starting audio thread/,62,"Starting audio"],[/Loading singleplayer metadata/,66,"Loading audio metadata"],[/^Loading SRL file/,72,"Starting scripts"],[/Removing prologue IPL light groups/,84,"Loading the world"]];let sent=0,chose=false;const lastStage=stages[stages.length-1][1];function progress(s){if(!chose&&s.startsWith("[wasm] start mode: ")){const m=/^\[wasm\] start mode: (waiting|story|sandbox on env_test|sandbox|none)/.exec(s);if(m&&m[1]==="waiting")bc.postMessage({choice:true});else if(m){chose=true;bc.postMessage({commit:true,mode:{story:1,sandbox:2,"sandbox on env_test":3}[m[1]]||0})}return}if(sent>=lastStage)return;for(const st of stages)if(st[1]>sent&&st[0].test(s)){sent=st[1];bc.postMessage({pct:st[1],label:st[2]})}}const pending=[];let lastConsole=0,lastMem=0;function consoleLine(s){if(!s||/Hang Detect|^Pool |clashes with a global|from Loading effect|Couldn't find an enum name/.test(s))return;pending.push(s.length>200?s.slice(0,200):s);if(pending.length>40)pending.shift();const now=performance.now();if(remoteLog&&now-lastMem>5e3&&typeof(growMemViews(),HEAPU8)!=="undefined"){lastMem=now;globalThis.__log("[mem] wasm memory "+((growMemViews(),HEAPU8).length/1048576|0)+" MB ("+name+")"+(typeof PThread!=="undefined"&&PThread.runningWorkers?", pthreads running "+PThread.runningWorkers.length+", idle in pool "+PThread.unusedWorkers.length:""))}if(now-lastConsole>150){lastConsole=now;bc.postMessage({lines:pending.splice(0)})}}addEventListener("unhandledrejection",function(e){const s="THREAD REJECTION ("+name+"): "+(e.reason&&e.reason.stack||e.reason);console.error(s);globalThis.__log(s);globalThis.__logFlush();globalThis.__crash("rejection",s)});const fullConsole=!!Module["fullConsole"]||/[?&]console=1/.test(self.location.search);const important=/^(Error|Warning|Fatal|Assert|THREAD|ABORT|EXIT|\[wasm\]|\[io\]|\[wgpu\])|\*\* POSSIBLE STALL/;let consoleWindow=0,consoleShown=0,consoleHidden=0;function toConsole(s){if(fullConsole)return true;if(!important.test(s))return false;const now=performance.now();if(now-consoleWindow>=1e3){if(consoleHidden)console.warn("[console] "+consoleHidden+" lines of this thread not shown here (the server log has them; ?console=1 shows everything)");consoleWindow=now;consoleShown=0;consoleHidden=0}if(consoleShown<100){consoleShown++;return true}consoleHidden++;return false}Module["print"]=function(s){if(toConsole(s))console.log(s);globalThis.__log(s);progress(s);consoleLine(s);ring.push(s.length>300?s.slice(0,300):s);if(ring.length>60)ring.shift()};Module["printErr"]=function(s){if(toConsole(s))console.error(s);globalThis.__log(s);progress(s);consoleLine(s);ring.push(s.length>300?s.slice(0,300):s);if(ring.length>60)ring.shift()}})();var programArgs=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName;if(ENVIRONMENT_IS_WORKER){_scriptName=self.location.href}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var wasmModule;var ABORT=false;var EXITSTATUS;class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}function growMemViews(){if(wasmMemory.buffer!=HEAP8.buffer){updateMemoryViews()}}var startWorker;if(ENVIRONMENT_IS_PTHREAD){var initializedJS=false;self.onunhandledrejection=e=>{throw e.reason||e};function handleMessage(e){try{var msgData=e.data;var cmd=msgData.cmd;if(cmd==1){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);startWorker=()=>{postMessage({cmd:3});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};for(const handler of msgData.handlers){if(!Module[handler]||Module[handler].proxy){Module[handler]=(...args)=>{postMessage({cmd:9,handler,args})};if(handler=="print")out=Module[handler];if(handler=="printErr")err=Module[handler]}}wasmMemory=msgData.wasmMemory;updateMemoryViews();wasmModule=msgData.wasmModule;createWasm();run();startWorker()}else if(cmd==2){establishStackSpace(msgData.pthread_ptr);__emscripten_thread_init(msgData.pthread_ptr,0,0,1,0,0);PThread.threadInitTLS();__emscripten_thread_mailbox_await(msgData.pthread_ptr);if(!initializedJS){initializedJS=true}try{invokeEntryPoint(msgData.start_routine,msgData.arg)}catch(ex){if(ex!="unwind"){throw ex}}}else if(cmd==4){if(initializedJS){checkMailbox()}}else if(cmd){err(`worker: received unknown command ${cmd}`);err(msgData)}}catch(ex){if(runtimeInitialized)__emscripten_thread_crashed();throw ex}}self.onmessage=handleMessage}var runtimeInitialized=false;var runtimeExited=false;function getMemoryBuffer(){return wasmMemory.buffer}function updateMemoryViews(){if(HEAP8?.buffer?.growable)return;var b=getMemoryBuffer();HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function initMemory(){if(ENVIRONMENT_IS_PTHREAD){return}{var INITIAL_MEMORY=3221225472;wasmMemory=new WebAssembly.Memory({initial:BigInt(INITIAL_MEMORY/65536),maximum:262144n,shared:true,address:"i64"})}updateMemoryViews()}function preRun(){var preRun=Module["preRun"];if(preRun){if(typeof preRun=="function")preRun=[preRun];onPreRuns.push(...preRun)}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;if(ENVIRONMENT_IS_PTHREAD)return;SOCKFS.root=FS.mount(SOCKFS,{},null);if(!Module["noFSInit"]&&!FS.initialized)FS.init();TTY.init();wasmExports["__wasm_call_ctors"]();FS.ignorePermissions=false}function exitRuntime(){___funcs_on_exit();FS.quit();TTY.shutdown();PThread.terminateRuntime();runtimeExited=true}function postRun(){var postRun=Module["postRun"];if(postRun){if(typeof postRun=="function")postRun=[postRun];onPostRuns.push(...postRun)}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("game.wasm")}function getBinarySync(file){if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){assignWasmImports();var imports={env:wasmImports,wasi_snapshot_preview1:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=applySignatureConversions(wasmExports);registerTLSInit(wasmExports["_emscripten_tls_init"]);assignWasmExports(wasmExports);wasmModule=module;return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"],result["module"])}var info=getWasmImports();var instantiateWasm=Module["instantiateWasm"];if(instantiateWasm){return new Promise(resolve=>{instantiateWasm(info,(inst,mod)=>resolve(receiveInstance(inst,mod)))})}if(ENVIRONMENT_IS_PTHREAD){var instance=new WebAssembly.Instance(wasmModule,getWasmImports());return receiveInstance(instance,wasmModule)}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP8;var terminateWorker=worker=>{worker.terminate();worker.onmessage=e=>{}};var cleanupThread=pthread_ptr=>{var worker=PThread.pthreads[pthread_ptr];PThread.returnWorkerToPool(worker)};var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var dependenciesPromise=null;var resolveRunDependencies=async()=>dependenciesPromise;var runDependencies=0;var dependenciesPromiseResolve=null;var removeRunDependency=id=>{runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(!runDependencies){dependenciesPromiseResolve()}};var addRunDependency=id=>{if(!runDependencies){dependenciesPromise=new Promise(resolve=>dependenciesPromiseResolve=resolve)}runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)};var spawnThread=threadParams=>{var worker=PThread.getNewWorker();if(!worker){return 6}PThread.pthreads[threadParams.pthread_ptr]=worker;worker.pthread_ptr=threadParams.pthread_ptr;var msg={cmd:2,start_routine:threadParams.startRoutine,arg:threadParams.arg,pthread_ptr:threadParams.pthread_ptr};worker.postMessage(msg,threadParams.transferList);return 0};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var stackSave=()=>_emscripten_stack_get_current();var stackRestore=val=>__emscripten_stack_restore(val);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var HEAPF64;var HEAP64;var proxyToMainThread=(funcIndex,emAsmAddr,proxyMode,...callArgs)=>{var bufSize=8*callArgs.length*2;var sp=stackSave();var args=stackAlloc(bufSize);var b=args/8;for(var arg of callArgs){if(typeof arg=="bigint"){(growMemViews(),HEAP64)[b++]=1n;(growMemViews(),HEAP64)[b++]=arg}else{(growMemViews(),HEAP64)[b++]=0n;(growMemViews(),HEAPF64)[b++]=arg}}var rtn=__emscripten_run_js_on_main_thread(funcIndex,emAsmAddr,bufSize,args,proxyMode);stackRestore(sp);return rtn};function _proc_exit(code){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(0,0,1,code);EXITSTATUS=code;if(!keepRuntimeAlive()){PThread.terminateAllThreads();Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))}function exitOnMainThread(returnCode){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(1,0,0,returnCode);_exit(returnCode)}var exitJS=(status,implicit)=>{EXITSTATUS=status;if(ENVIRONMENT_IS_PTHREAD){exitOnMainThread(status);throw"unwind"}if(!keepRuntimeAlive()){exitRuntime()}_proc_exit(status)};var _exit=exitJS;var waitAsyncPolyfilled=!Atomics.waitAsync||globalThis.navigator?.userAgent&&Number((navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./)||[])[2])<91;var HEAP32;var PThread={unusedWorkers:[],tlsInitFunctions:[],pthreads:{},init(){if(!ENVIRONMENT_IS_PTHREAD){PThread.initMainThread()}},initMainThread(){var pthreadPoolSize=Math.min(160,navigator.hardwareConcurrency<=2?28:36+4*navigator.hardwareConcurrency);while(pthreadPoolSize--){PThread.allocateUnusedWorker()}addOnPreRun(async()=>{var pthreadPoolReady=PThread.loadWasmModuleToAllWorkers();addRunDependency("loading-workers");await pthreadPoolReady;removeRunDependency("loading-workers")})},terminateAllThreads:()=>{for(var worker of Object.values(PThread.pthreads)){terminateWorker(worker)}for(var worker of PThread.unusedWorkers){terminateWorker(worker)}PThread.unusedWorkers=[];PThread.pthreads={}},clearMailboxAwait:pthread_ptr=>{if(!waitAsyncPolyfilled){Atomics.notify((growMemViews(),HEAP32),pthread_ptr/4)}},terminateRuntime:()=>{PThread.terminateAllThreads();var pthread_ptr=_pthread_self();___set_thread_state(0,0,0,1);PThread.clearMailboxAwait(pthread_ptr)},returnWorkerToPool:worker=>{var pthread_ptr=worker.pthread_ptr;delete PThread.pthreads[pthread_ptr];PThread.unusedWorkers.push(worker);worker.pthread_ptr=0;PThread.clearMailboxAwait(pthread_ptr);__emscripten_thread_free_data(pthread_ptr)},threadInitTLS(){PThread.tlsInitFunctions.forEach(f=>f())},loadWasmModuleToWorker:worker=>new Promise(onFinishedLoading=>{worker.onmessage=e=>{var d=e.data;var cmd=d.cmd;if(d.targetThread&&d.targetThread!=_pthread_self()){var targetWorker=PThread.pthreads[d.targetThread];targetWorker?.postMessage(d);return}if(d==="setimmediate"||d==="_si"){worker.postMessage(d);return}switch(cmd){case 4:checkMailbox();break;case 5:spawnThread(d);break;case 6:callUserCallback(()=>cleanupThread(d.thread));break;case 3:onFinishedLoading(worker);break;case 9:Module[d.handler](...d.args);break;default:if(cmd)err(`worker sent an unknown command ${cmd}`)}};worker.onerror=e=>{var message="worker sent an error!";err(`${message} ${e.filename}:${e.lineno}: ${e.message}`);throw e};var handlers=[];var knownHandlers=["onExit","onAbort","print","printErr"];for(var handler of knownHandlers){if(Module.propertyIsEnumerable(handler)){handlers.push(handler)}}worker.postMessage({cmd:1,handlers,wasmMemory,wasmModule})}),async loadWasmModuleToAllWorkers(){if(ENVIRONMENT_IS_PTHREAD){return}let pthreadPoolReady=Promise.all(PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker));return pthreadPoolReady},allocateUnusedWorker(){var worker;var pthreadMainJs=_scriptName;if(Module["mainScriptUrlOrBlob"]){pthreadMainJs=Module["mainScriptUrlOrBlob"];if(typeof pthreadMainJs!="string"){pthreadMainJs=URL.createObjectURL(pthreadMainJs)}}worker=new Worker(pthreadMainJs,{name:"em-pthread"});PThread.unusedWorkers.push(worker);return worker},getNewWorker(){if(PThread.unusedWorkers.length==0){var newWorker=PThread.allocateUnusedWorker();PThread.loadWasmModuleToWorker(newWorker)}return PThread.unusedWorkers.pop()}};var onPostRuns=[];var HEAPU64;function establishStackSpace(pthread_ptr){var stackHigh=Number((growMemViews(),HEAPU64)[(pthread_ptr+80)/8]);var stackSize=Number((growMemViews(),HEAPU64)[(pthread_ptr+88)/8]);var stackLow=stackHigh-stackSize;_emscripten_stack_set_limits(stackHigh,stackLow);stackRestore(stackHigh)}var wasmTableMirror=[];var getWasmTableEntry=funcPtr=>{funcPtr=Number(funcPtr);var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(BigInt(funcPtr))}return func};var invokeEntryPoint=(ptr,arg)=>{runtimeKeepaliveCounter=0;noExitRuntime=0;var result=(a1=>Number(getWasmTableEntry(ptr).call(null,BigInt(a1))))(arg);function finish(result){if(keepRuntimeAlive()){EXITSTATUS=result;return}__emscripten_thread_exit(result)}finish(result)};var noExitRuntime=false;var registerTLSInit=tlsInitFunc=>PThread.tlsInitFunctions.push(tlsInitFunc);var wasmMemory;function pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(2,0,1,pthread_ptr,attr,startRoutine,arg);return ___pthread_create_js(pthread_ptr,attr,startRoutine,arg)}var _emscripten_has_threading_support=()=>!!globalThis.SharedArrayBuffer;var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>numINT53_MAX?NaN:Number(num);function ___pthread_create_js(pthread_ptr,attr,startRoutine,arg){pthread_ptr=bigintToI53Checked(pthread_ptr);attr=bigintToI53Checked(attr);startRoutine=bigintToI53Checked(startRoutine);arg=bigintToI53Checked(arg);if(!_emscripten_has_threading_support()){return 6}var transferList=[];var error=0;if(ENVIRONMENT_IS_PTHREAD&&(!transferList.length||error)){return pthreadCreateProxied(pthread_ptr,attr,startRoutine,arg)}if(error)return error;var threadParams={startRoutine,pthread_ptr,arg,transferList};if(ENVIRONMENT_IS_PTHREAD){threadParams.cmd=5;postMessage(threadParams,transferList);return 0}return spawnThread(threadParams)}var initRandomFill=()=>view=>(view.set(crypto.getRandomValues(new Uint8Array(view.byteLength))),0);var randomFill=view=>(randomFill=initRandomFill())(view);var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.slice(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.slice(0,-1)}return root+dir},basename:path=>path&&path.match(/([^\/]+|\/)\/*$/)[1],join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).slice(1);to=PATH_FS.resolve(to).slice(1);function trim(arr){var start=0;for(;start=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.buffer instanceof ArrayBuffer?heapOrArray.subarray(idx,endPtr):heapOrArray.slice(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var FS_stdin_getChar_buffer=[];var lengthBytesUTF8=str=>{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var intArrayFromString=(stringy,dontAddNull,length)=>{var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array};var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output?.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var mmapAlloc=size=>{abort()};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=MEMFS.emptyFileContents??=new Uint8Array(0)}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){return node.contents.subarray(0,node.usedBytes)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents.length;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>0);if(prevCapacity)newCapacity=Math.max(newCapacity,256);var oldContents=MEMFS.getFileDataAsTypedArray(node);node.contents=new Uint8Array(newCapacity);node.contents.set(oldContents)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;var oldContents=node.contents;node.contents=new Uint8Array(newSize);node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)));node.usedBytes=newSize},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]!=null){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){if(!MEMFS.doesNotExistError){MEMFS.doesNotExistError=new FS.ErrnoError(44);MEMFS.doesNotExistError.stack=""}throw MEMFS.doesNotExistError},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);buffer.set(contents.subarray(position,position+size),offset);return size},write(stream,buffer,offset,length,position,canOwn){if(buffer.buffer===(growMemViews(),HEAP8).buffer){canOwn=false}if(!length)return 0;var node=stream.node;node.mtime=node.ctime=Date.now();if(canOwn){node.contents=buffer.subarray(offset,offset+length);node.usedBytes=length}else if(!node.usedBytes&&!position){node.contents=buffer.slice(offset,offset+length);node.usedBytes=length}else{MEMFS.expandFileStorage(node,position+length);node.contents.set(buffer.subarray(offset,offset+length),position);node.usedBytes=Math.max(node.usedBytes,position+length)}return length},llseek(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.usedBytes}}if(position<0){throw new FS.ErrnoError(28)}return position},mmap(stream,length,position,prot,flags){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}var ptr;var allocated;var contents=stream.node.contents;if(!(flags&2)&&contents.buffer===(growMemViews(),HEAP8).buffer){allocated=false;ptr=contents.byteOffset}else{allocated=true;ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}if(contents){if(position>0||position+length{if(typeof str!="string")return str;var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_fileDataToTypedArray=data=>{if(typeof data=="string"){data=intArrayFromString(data,true)}if(!data.subarray){data=new Uint8Array(data)}return data};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var asyncLoad=async url=>{var arrayBuffer=await readAsync(url);return new Uint8Array(arrayBuffer)};var FS_createDataFile=(...args)=>FS.createDataFile(...args);var getUniqueRunDependency=id=>id;var preloadPlugins=[];var FS_handledByPreloadPlugin=async(byteArray,fullname)=>{if(typeof Browser!="undefined")Browser.init();for(var plugin of preloadPlugins){if(plugin["canHandle"](fullname)){return plugin["handle"](byteArray,fullname)}}return byteArray};var FS_preloadFile=async(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);addRunDependency(dep);try{var byteArray=url;if(typeof url=="string"){byteArray=await asyncLoad(url)}byteArray=await FS_handledByPreloadPlugin(byteArray,fullname);preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}}finally{removeRunDependency(dep)}};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{FS_preloadFile(parent,name,url,canRead,canWrite,dontCreateFile,canOwn,preFinish).then(onload).catch(onerror)};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,filesystems:null,syncFSRequests:0,ErrnoError:class{name="ErrnoError";constructor(errno){this.errno=errno}},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}addListener(cb,exclusive=false){var entry={cb,exclusive};var listeners=this.listeners??=new Set;listeners.add(entry);return{listeners,entry}}notifyListeners(flags){if(!this.listeners)return;var excl;for(var entry of this.listeners){if(entry.exclusive)(excl||=[]).push(entry);else entry.cb(flags)}if(excl){var i=(this.exclTurn||0)%excl.length;this.exclTurn=i+1;excl[i].cb(flags)}}},lookupPath(path,opts={}){if(!path){throw new FS.ErrnoError(44)}opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}if(perms.includes("w")&&!(node.mode&146)){return 2}if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else if(FS.isDir(node.mode)){return 31}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}var mode=FS.flagsToPermissionString(flags);if(FS.isDir(node.mode)){if(mode!=="r"||flags&(512|64)){return 31}}return FS.nodePermissions(node,mode)},checkOpExists(op,err){if(!op){throw new FS.ErrnoError(err)}return op},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},doSetAttr(stream,node,attr){var setattr=stream?.stream_ops.setattr;var arg=setattr?stream:node;setattr??=node.node_ops.setattr;FS.checkOpExists(setattr,63);try{setattr(arg,attr)}catch(e){if(e instanceof RangeError){throw new FS.ErrnoError(22)}throw e}},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}for(var mount of mounts){if(mount.type.syncfs){mount.type.syncfs(mount,populate,done)}else{done(null)}}},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);for(var[hash,current]of Object.entries(FS.nameTable)){while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}}node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name){throw new FS.ErrnoError(28)}if(name==="."||name===".."){throw new FS.ErrnoError(20)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){return FS.statfsNode(FS.lookupPath(path,{follow:true}).node)},statfsStream(stream){return FS.statfsNode(stream.node)},statfsNode(node){var rtn={bsize:4096,frsize:4096,blocks:1e6,bfree:5e5,bavail:5e5,files:FS.nextInode,ffree:FS.nextInode-1,fsid:42,flags:2,namelen:255};if(node.node_ops.statfs){Object.assign(rtn,node.node_ops.statfs(node.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var dir of dirs){if(!dir)continue;if(d||PATH.isAbs(path))d+="/";d+=dir;try{FS.mkdir(d,mode)}catch(e){if(e.errno!=20)throw e}}},mkdev(path,mode,dev){if(typeof dev=="undefined"){dev=mode;mode=438}mode|=8192;return FS.mknod(path,mode,dev)},symlink(oldpath,newpath){if(!PATH_FS.resolve(oldpath)){throw new FS.ErrnoError(44)}var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.symlink){throw new FS.ErrnoError(63)}return parent.node_ops.symlink(parent,newname,oldpath)},link(oldpath,newpath,flags){var lookup=FS.lookupPath(newpath,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var newname=PATH.basename(newpath);var errCode=FS.mayCreate(parent,newname);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.link){throw new FS.ErrnoError(34)}return parent.node_ops.link(parent,newname,oldpath,flags)},rename(old_path,new_path){var old_dirname=PATH.dirname(old_path);var new_dirname=PATH.dirname(new_path);var old_name=PATH.basename(old_path);var new_name=PATH.basename(new_path);var lookup,old_dir,new_dir;lookup=FS.lookupPath(old_path,{parent:true});old_dir=lookup.node;lookup=FS.lookupPath(new_path,{parent:true});new_dir=lookup.node;if(!old_dir||!new_dir)throw new FS.ErrnoError(44);if(old_dir.mount!==new_dir.mount){throw new FS.ErrnoError(75)}var old_node=FS.lookupNode(old_dir,old_name);var relative=PATH_FS.relative(old_path,new_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(28)}relative=PATH_FS.relative(new_path,old_dirname);if(relative.charAt(0)!=="."){throw new FS.ErrnoError(55)}var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(old_node===new_node){return}var isdir=FS.isDir(old_node.mode);var errCode=FS.mayDelete(old_dir,old_name,isdir);if(errCode){throw new FS.ErrnoError(errCode)}errCode=new_node?FS.mayDelete(new_dir,new_name,isdir):FS.mayCreate(new_dir,new_name);if(errCode){throw new FS.ErrnoError(errCode)}if(!old_dir.node_ops.rename){throw new FS.ErrnoError(63)}if(FS.isMountpoint(old_node)||new_node&&FS.isMountpoint(new_node)){throw new FS.ErrnoError(10)}if(new_dir!==old_dir){errCode=FS.nodePermissions(old_dir,"w");if(errCode){throw new FS.ErrnoError(errCode)}}FS.hashRemoveNode(old_node);try{old_dir.node_ops.rename(old_node,new_dir,new_name);old_node.parent=new_dir}catch(e){throw e}finally{FS.hashAddNode(old_node)}},rmdir(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,true);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.rmdir){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.rmdir(parent,name);FS.destroyNode(node)},readdir(path){var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;var readdir=FS.checkOpExists(node.node_ops.readdir,54);return readdir(node)},unlink(path){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;if(!parent){throw new FS.ErrnoError(44)}var name=PATH.basename(path);var node=FS.lookupNode(parent,name);var errCode=FS.mayDelete(parent,name,false);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.unlink){throw new FS.ErrnoError(63)}if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}parent.node_ops.unlink(parent,name);FS.destroyNode(node)},readlink(path){var lookup=FS.lookupPath(path);var link=lookup.node;if(!link){throw new FS.ErrnoError(44)}if(!link.node_ops.readlink){throw new FS.ErrnoError(28)}return link.node_ops.readlink(link)},stat(path,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});var node=lookup.node;var getattr=FS.checkOpExists(node.node_ops.getattr,63);return getattr(node)},fstat(fd){var stream=FS.getStreamChecked(fd);var node=stream.node;var getattr=stream.stream_ops.getattr;var arg=getattr?stream:node;getattr??=node.node_ops.getattr;FS.checkOpExists(getattr,63);return getattr(arg)},lstat(path){return FS.stat(path,true)},doChmod(stream,node,mode,dontFollow){FS.doSetAttr(stream,node,{mode:mode&4095|node.mode&~4095,ctime:Date.now(),dontFollow})},chmod(path,mode,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChmod(null,node,mode,dontFollow)},lchmod(path,mode){FS.chmod(path,mode,true)},fchmod(fd,mode){var stream=FS.getStreamChecked(fd);FS.doChmod(stream,stream.node,mode,false)},doChown(stream,node,dontFollow){FS.doSetAttr(stream,node,{timestamp:Date.now(),dontFollow})},chown(path,uid,gid,dontFollow){var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:!dontFollow});node=lookup.node}else{node=path}FS.doChown(null,node,dontFollow)},lchown(path,uid,gid){FS.chown(path,uid,gid,true)},fchown(fd,uid,gid){var stream=FS.getStreamChecked(fd);FS.doChown(stream,stream.node,false)},doTruncate(stream,node,len){if(FS.isDir(node.mode)){throw new FS.ErrnoError(31)}if(!FS.isFile(node.mode)){throw new FS.ErrnoError(28)}var errCode=FS.nodePermissions(node,"w");if(errCode){throw new FS.ErrnoError(errCode)}FS.doSetAttr(stream,node,{size:len,timestamp:Date.now()})},truncate(path,len){if(len<0){throw new FS.ErrnoError(28)}var node;if(typeof path=="string"){var lookup=FS.lookupPath(path,{follow:true});node=lookup.node}else{node=path}FS.doTruncate(null,node,len)},ftruncate(fd,len){var stream=FS.getStreamChecked(fd);if(len<0||(stream.flags&2097155)===0){throw new FS.ErrnoError(28)}FS.doTruncate(stream,stream.node,len)},utime(path,atime,mtime,dontFollow){var lookup=FS.lookupPath(path,{follow:!dontFollow});FS.doSetAttr(null,lookup.node,{atime,mtime,dontFollow})},open(path,flags,mode=438){if(path===""){throw new FS.ErrnoError(44)}flags=FS_modeStringToFlags(flags);if(flags&64){mode=mode&4095|32768}else{mode=0}var node;var isDirPath;if(typeof path=="object"){node=path}else{isDirPath=path.endsWith("/");var lookup=FS.lookupPath(path,{follow:!(flags&131072),noent_okay:true});node=lookup.node;path=lookup.path}var created=false;if(flags&64){if(node){if(flags&128){throw new FS.ErrnoError(20)}}else if(isDirPath){throw new FS.ErrnoError(31)}else{node=FS.mknod(path,mode|511,0);created=true}}if(!node){throw new FS.ErrnoError(44)}if(FS.isChrdev(node.mode)){flags&=~512}if(flags&65536&&!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}if(!created){var errCode=FS.mayOpen(node,flags);if(errCode){throw new FS.ErrnoError(errCode)}}if(flags&512&&!created){FS.truncate(node,0)}flags&=~(128|512|131072);var stream=FS.createStream({node,path:FS.getPath(node),flags,seekable:true,position:0,stream_ops:node.stream_ops,ungotten:[],error:false});if(stream.stream_ops.open){stream.stream_ops.open(stream)}if(created){FS.chmod(node,mode&511)}return stream},close(stream){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(stream.getdents)stream.getdents=null;stream.node?.notifyListeners(32);try{if(stream.stream_ops.close){stream.stream_ops.close(stream)}}catch(e){throw e}finally{FS.closeStream(stream.fd)}stream.fd=null},isClosed(stream){return stream.fd===null},llseek(stream,offset,whence){if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if(!stream.seekable||!stream.stream_ops.llseek){throw new FS.ErrnoError(70)}if(whence!=0&&whence!=1&&whence!=2){throw new FS.ErrnoError(28)}stream.position=stream.stream_ops.llseek(stream,offset,whence);stream.ungotten=[];return stream.position},read(stream,buffer,offset,length,position){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.read){throw new FS.ErrnoError(28)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesRead=stream.stream_ops.read(stream,buffer,offset,length,position);if(!seeking)stream.position+=bytesRead;return bytesRead},write(stream,buffer,offset,length,position,canOwn){if(length<0||position<0){throw new FS.ErrnoError(28)}if(FS.isClosed(stream)){throw new FS.ErrnoError(8)}if((stream.flags&2097155)===0){throw new FS.ErrnoError(8)}if(FS.isDir(stream.node.mode)){throw new FS.ErrnoError(31)}if(!stream.stream_ops.write){throw new FS.ErrnoError(28)}if(stream.seekable&&stream.flags&1024){FS.llseek(stream,0,2)}var seeking=typeof position!="undefined";if(!seeking){position=stream.position}else if(!stream.seekable){throw new FS.ErrnoError(70)}var bytesWritten=stream.stream_ops.write(stream,buffer,offset,length,position,canOwn);if(!seeking)stream.position+=bytesWritten;return bytesWritten},mmap(stream,length,position,prot,flags){if(prot&2&&!(flags&2)&&(stream.flags&2097155)!==2){throw new FS.ErrnoError(2)}if((stream.flags&2097155)===1){throw new FS.ErrnoError(2)}if(!stream.stream_ops.mmap){throw new FS.ErrnoError(43)}if(!length){throw new FS.ErrnoError(28)}return stream.stream_ops.mmap(stream,length,position,prot,flags)},msync(stream,buffer,offset,length,mmapFlags){if(!stream.stream_ops.msync){return 0}return stream.stream_ops.msync(stream,buffer,offset,length,mmapFlags)},ioctl(stream,cmd,arg){if(!stream.stream_ops.ioctl){throw new FS.ErrnoError(59)}return stream.stream_ops.ioctl(stream,cmd,arg)},readFile(path,opts={}){opts.flags=opts.flags??0;opts.encoding=opts.encoding??"binary";if(opts.encoding!=="utf8"&&opts.encoding!=="binary"){abort(`Invalid encoding type "${opts.encoding}"`)}var stream=FS.open(path,opts.flags);var stat=FS.stat(path);var length=stat.size;var buf=new Uint8Array(length);FS.read(stream,buf,0,length,0);if(opts.encoding==="utf8"){buf=UTF8ArrayToString(buf)}FS.close(stream);return buf},writeFile(path,data,opts={}){opts.flags=opts.flags??577;var stream=FS.open(path,opts.flags,opts.mode);data=FS_fileDataToTypedArray(data);FS.write(stream,data,0,data.byteLength,undefined,opts.canOwn);FS.close(stream)},cwd:()=>FS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(!randomLeft){randomFill(randomBuffer);randomLeft=randomBuffer.byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS}},init(input,output,error){FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;_fflush(0);for(var stream of FS.streams){if(stream){FS.close(stream)}}},findObject(path,dontResolveLastLink){var ret=FS.analyzePath(path,dontResolveLastLink);if(!ret.exists){return null}return ret.object},analyzePath(path,dontResolveLastLink){try{var lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});path=lookup.path}catch(e){}var ret={isRoot:false,exists:false,error:0,name:null,path:null,object:null,parentExists:false,parentPath:null,parentObject:null};try{var lookup=FS.lookupPath(path,{parent:true});ret.parentExists=true;ret.parentPath=lookup.path;ret.parentObject=lookup.node;ret.name=PATH.basename(path);lookup=FS.lookupPath(path,{follow:!dontResolveLastLink});ret.exists=true;ret.path=lookup.path;ret.object=lookup.node;ret.name=lookup.node.name;ret.isRoot=lookup.path==="/"}catch(e){ret.error=e.errno}return ret},createPath(parent,path,canRead,canWrite){parent=typeof parent=="string"?parent:FS.getPath(parent);var parts=path.split("/").reverse();while(parts.length){var part=parts.pop();if(!part)continue;var current=PATH.join2(parent,part);try{FS.mkdir(current)}catch(e){if(e.errno!=20)throw e}parent=current}return current},createFile(parent,name,properties,canRead,canWrite){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(canRead,canWrite);return FS.create(path,mode)},createDataFile(parent,name,data,canRead,canWrite,canOwn){var path=name;if(parent){parent=typeof parent=="string"?parent:FS.getPath(parent);path=name?PATH.join2(parent,name):parent}var mode=FS_getMode(canRead,canWrite);var node=FS.create(path,mode);if(data){data=FS_fileDataToTypedArray(data);FS.chmod(node,mode|146);var stream=FS.open(node,577);FS.write(stream,data,0,data.length,0,canOwn);FS.close(stream);FS.chmod(node,mode)}},createDevice(parent,name,input,output){var path=PATH.join2(typeof parent=="string"?parent:FS.getPath(parent),name);var mode=FS_getMode(!!input,!!output);FS.createDevice.major??=64;var dev=FS.makedev(FS.createDevice.major++,0);FS.registerDevice(dev,{open(stream){stream.seekable=false},close(stream){if(output?.buffer?.length){output(10)}},read(stream,buffer,offset,length,pos){var bytesRead=0;for(var i=0;ithis.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort(`Couldn't load ${url}. Status: ${xhr.status}`);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)abort(`invalid range (${from}, ${to}) or no bytes requested!`);if(to>datalength-1)abort(`only ${datalength} bytes available! programmer error!`);var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range",`bytes=${from}-${to}`);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))abort(`Couldn't load ${url}. Status: ${xhr.status}`);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText??"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")abort("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(globalThis.XMLHttpRequest){if(!ENVIRONMENT_IS_WORKER)abort("Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc");var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};for(const[key,fn]of Object.entries(node.stream_ops)){stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}}function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,(growMemViews(),HEAP8),ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var SOCKFS={callbacks:{},on(event,callback){SOCKFS.callbacks[event]=callback},emit(event,param){SOCKFS.callbacks[event]?.(param);var fd=event==="error"?param[0]:param;var flags={message:64|1,open:4,connection:64|1,close:1|16,error:8}[event];if(flags)FS.getStream(fd)?.node.notifyListeners(flags)},mount(mount){return FS.createNode(null,"/",16895,0)},createSocket(family,type,protocol){if(family!=2){throw new FS.ErrnoError(5)}var flags=2;type&=~526336;if(type!=1&&type!=2){throw new FS.ErrnoError(28)}var streaming=type==1;if(streaming&&protocol&&protocol!=6){throw new FS.ErrnoError(66)}var sock={family,type,protocol,server:null,error:null,peers:{},pending:[],recv_queue:[],sock_ops:SOCKFS.websocket_sock_ops};var name=SOCKFS.nextname();var node=FS.createNode(SOCKFS.root,name,49152,0);node.sock=sock;var stream=FS.createStream({path:name,node,flags,seekable:false,stream_ops:SOCKFS.stream_ops});sock.stream=stream;return sock},getSocket(fd){var stream=FS.getStream(fd);if(!stream||!FS.isSocket(stream.node.mode)){return null}return stream.node.sock},stream_ops:{getattr(stream){var node=stream.node;return{dev:1,ino:node.id,mode:49152|511,nlink:1,uid:0,gid:0,rdev:0,size:0,atime:new Date(0),mtime:new Date(0),ctime:new Date(0),blksize:4096,blocks:0}},poll(stream){var sock=stream.node.sock;return sock.sock_ops.poll(sock)},ioctl(stream,request,varargs){var sock=stream.node.sock;return sock.sock_ops.ioctl(sock,request,varargs)},read(stream,buffer,offset,length,position){var sock=stream.node.sock;var msg=sock.sock_ops.recvmsg(sock,length);if(!msg){return 0}buffer.set(msg.buffer,offset);return msg.buffer.length},write(stream,buffer,offset,length,position){var sock=stream.node.sock;return sock.sock_ops.sendmsg(sock,buffer,offset,length)},close(stream){var sock=stream.node.sock;sock.sock_ops.close(sock)}},nextname(){if(!SOCKFS.nextname.current){SOCKFS.nextname.current=0}return`socket[${SOCKFS.nextname.current++}]`},websocket_sock_ops:{createPeer(sock,addr,port){var ws;if(typeof addr=="object"){ws=addr;addr=null;port=null}if(ws){if(ws._socket){addr=ws._socket.remoteAddress;port=ws._socket.remotePort}else{var result=/ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);if(!result){throw new Error("WebSocket URL must be in the format ws(s)://address:port")}addr=result[1];port=parseInt(result[2],10)}}else{try{var url="ws://".replace("#","//");var subProtocols="binary";var opts=undefined;if(url==="ws://"||url==="wss://"){var parts=addr.split("/");url=url+parts[0]+":"+port+"/"+parts.slice(1).join("/")}if(subProtocols!=="null"){subProtocols=subProtocols.replace(/^ +| +$/g,"").split(/ *, */);opts=subProtocols}var WebSocketConstructor;{WebSocketConstructor=WebSocket}ws=new WebSocketConstructor(url,opts);ws.binaryType="arraybuffer"}catch(e){throw new FS.ErrnoError(23)}}var peer={addr,port,socket:ws,msg_send_queue:[]};SOCKFS.websocket_sock_ops.addPeer(sock,peer);SOCKFS.websocket_sock_ops.handlePeerEvents(sock,peer);if(sock.type===2&&typeof sock.sport!="undefined"){peer.msg_send_queue.push(new Uint8Array([255,255,255,255,"p".charCodeAt(0),"o".charCodeAt(0),"r".charCodeAt(0),"t".charCodeAt(0),(sock.sport&65280)>>8,sock.sport&255]))}return peer},getPeer(sock,addr,port){return sock.peers[addr+":"+port]},addPeer(sock,peer){sock.peers[peer.addr+":"+peer.port]=peer},removePeer(sock,peer){delete sock.peers[peer.addr+":"+peer.port]},handlePeerEvents(sock,peer){var first=true;function handleOpen(){sock.connecting=false;SOCKFS.emit("open",sock.stream.fd);try{var queued=peer.msg_send_queue.shift();while(queued){peer.socket.send(queued);queued=peer.msg_send_queue.shift()}}catch(e){peer.socket.close()}}function handleMessage(data){if(typeof data=="string"){var encoder=new TextEncoder;data=encoder.encode(data)}else{if(data.byteLength==0){return}data=new Uint8Array(data)}var wasfirst=first;first=false;if(wasfirst&&data.length===10&&data[0]===255&&data[1]===255&&data[2]===255&&data[3]===255&&data[4]==="p".charCodeAt(0)&&data[5]==="o".charCodeAt(0)&&data[6]==="r".charCodeAt(0)&&data[7]==="t".charCodeAt(0)){var newport=data[8]<<8|data[9];SOCKFS.websocket_sock_ops.removePeer(sock,peer);peer.port=newport;SOCKFS.websocket_sock_ops.addPeer(sock,peer);return}sock.recv_queue.push({addr:peer.addr,port:peer.port,data});SOCKFS.emit("message",sock.stream.fd)}peer.socket.onopen=handleOpen;peer.socket.onclose=()=>SOCKFS.emit("close",sock.stream.fd);peer.socket.onmessage=event=>handleMessage(event.data);peer.socket.onerror=error=>{sock.error=14;SOCKFS.emit("error",[sock.stream.fd,sock.error,"ECONNREFUSED: Connection refused"])}},poll(sock){if(sock.type===1&&sock.server){return sock.pending.length?64|1:0}var mask=0;var dest=sock.type===1?SOCKFS.websocket_sock_ops.getPeer(sock,sock.daddr,sock.dport):null;if(sock.recv_queue.length||!dest||dest&&dest.socket.readyState===dest.socket.CLOSING||dest&&dest.socket.readyState===dest.socket.CLOSED){mask|=64|1}if(!dest||dest&&dest.socket.readyState===dest.socket.OPEN){mask|=4}if(dest&&dest.socket.readyState===dest.socket.CLOSING||dest&&dest.socket.readyState===dest.socket.CLOSED){if(sock.connecting){mask|=4}else{mask|=16|8192}}return mask},ioctl(sock,request,arg){switch(request){case 21531:var bytes=0;if(sock.recv_queue.length){bytes=sock.recv_queue[0].data.length}(growMemViews(),HEAP32)[arg/4]=bytes;return 0;case 21537:var on=(growMemViews(),HEAP32)[arg/4];if(on){sock.stream.flags|=2048}else{sock.stream.flags&=~2048}return 0;default:return 28}},close(sock){if(sock.server){try{sock.server.close()}catch(e){}sock.server=null}for(var peer of Object.values(sock.peers)){try{peer.socket.close()}catch(e){}SOCKFS.websocket_sock_ops.removePeer(sock,peer)}return 0},bind(sock,addr,port){if(typeof sock.saddr!="undefined"||typeof sock.sport!="undefined"){throw new FS.ErrnoError(28)}sock.saddr=addr;sock.sport=port;if(sock.type===2){if(sock.server){sock.server.close();sock.server=null}try{sock.sock_ops.listen(sock,0)}catch(e){if(!(e.name==="ErrnoError"))throw e;if(e.errno!==138)throw e}}},connect(sock,addr,port){if(sock.server){throw new FS.ErrnoError(138)}if(typeof sock.daddr!="undefined"&&typeof sock.dport!="undefined"){var dest=SOCKFS.websocket_sock_ops.getPeer(sock,sock.daddr,sock.dport);if(dest){if(dest.socket.readyState===dest.socket.CONNECTING){throw new FS.ErrnoError(7)}else{throw new FS.ErrnoError(30)}}}var peer=SOCKFS.websocket_sock_ops.createPeer(sock,addr,port);sock.daddr=peer.addr;sock.dport=peer.port;sock.connecting=true},listen(sock,backlog){if(!ENVIRONMENT_IS_NODE){throw new FS.ErrnoError(138)}},accept(listensock){if(!listensock.server||!listensock.pending.length){throw new FS.ErrnoError(28)}var newsock=listensock.pending.shift();newsock.stream.flags=listensock.stream.flags;return newsock},getname(sock,peer){var addr,port;if(peer){if(sock.daddr===undefined||sock.dport===undefined){throw new FS.ErrnoError(53)}addr=sock.daddr;port=sock.dport}else{addr=sock.saddr||0;port=sock.sport||0}return{addr,port}},sendmsg(sock,buffer,offset,length,addr,port){if(sock.type===2){if(addr===undefined||port===undefined){addr=sock.daddr;port=sock.dport}if(addr===undefined||port===undefined){throw new FS.ErrnoError(17)}}else{addr=sock.daddr;port=sock.dport}var dest=SOCKFS.websocket_sock_ops.getPeer(sock,addr,port);if(sock.type===1){if(!dest||dest.socket.readyState===dest.socket.CLOSING||dest.socket.readyState===dest.socket.CLOSED){throw new FS.ErrnoError(53)}}if(ArrayBuffer.isView(buffer)){offset+=buffer.byteOffset;buffer=buffer.buffer}var data=buffer.slice(offset,offset+length);if(data instanceof SharedArrayBuffer){data=new Uint8Array(new Uint8Array(data)).buffer}if(!dest||dest.socket.readyState!==dest.socket.OPEN){if(sock.type===2){if(!dest||dest.socket.readyState===dest.socket.CLOSING||dest.socket.readyState===dest.socket.CLOSED){dest=SOCKFS.websocket_sock_ops.createPeer(sock,addr,port)}}dest.msg_send_queue.push(data);return length}try{dest.socket.send(data);return length}catch(e){throw new FS.ErrnoError(28)}},recvmsg(sock,length,flags){if(sock.type===1&&sock.server){throw new FS.ErrnoError(53)}var peek=flags&2;var queued=sock.recv_queue[0];if(!queued){if(sock.type===1){var dest=SOCKFS.websocket_sock_ops.getPeer(sock,sock.daddr,sock.dport);if(!dest){throw new FS.ErrnoError(53)}if(dest.socket.readyState===dest.socket.CLOSING||dest.socket.readyState===dest.socket.CLOSED){return null}throw new FS.ErrnoError(6)}throw new FS.ErrnoError(6)}var queuedLength=queued.data.byteLength||queued.data.length;var queuedOffset=queued.data.byteOffset||0;var queuedBuffer=queued.data.buffer||queued.data;var bytesRead=Math.min(length,queuedLength);var res={buffer:new Uint8Array(queuedBuffer,queuedOffset,bytesRead),addr:queued.addr,port:queued.port};if(peek)return res;sock.recv_queue.shift();if(sock.type===1&&bytesRead{var socket=SOCKFS.getSocket(fd);if(!socket)throw new FS.ErrnoError(8);return socket};var inetPton4=str=>{var b=str.split(".");for(var i=0;i<4;i++){var tmp=Number(b[i]);if(isNaN(tmp))return null;b[i]=tmp}return(b[0]|b[1]<<8|b[2]<<16|b[3]<<24)>>>0};var inetPton6=str=>{var words;var w,offset,z;var valid6regx=/^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i;var parts=[];if(!valid6regx.test(str)){return null}if(str==="::"){return[0,0,0,0,0,0,0,0]}if(str.startsWith("::")){str=str.replace("::","Z:")}else{str=str.replace("::",":Z:")}if(str.indexOf(".")>0){str=str.replace(new RegExp("[.]","g"),":");words=str.split(":");words[words.length-4]=Number(words[words.length-4])+Number(words[words.length-3])*256;words[words.length-3]=Number(words[words.length-2])+Number(words[words.length-1])*256;words=words.slice(0,words.length-2)}else{words=str.split(":")}offset=0;z=0;for(w=0;w(growMemViews(),HEAPU8).fill(0,ptr,ptr+size);var DNS={address_map:{id:1,addrs:{},names:{}},lookup_name(name){var res=inetPton4(name);if(res!==null){return name}res=inetPton6(name);if(res!==null){return name}var addr;if(DNS.address_map.addrs[name]){addr=DNS.address_map.addrs[name]}else{var id=DNS.address_map.id++;addr="172.29."+(id&255)+"."+(id&65280);DNS.address_map.names[addr]=name;DNS.address_map.addrs[name]=addr}return addr},lookup_addr(addr){if(DNS.address_map.names[addr]){return DNS.address_map.names[addr]}return null}};var HEAP16;var writeSockaddr=(sa,family,addr,port,addrlen)=>{switch(family){case 2:addr=inetPton4(DNS.lookup_name(addr));zeroMemory(sa,16);if(addrlen){(growMemViews(),HEAP32)[addrlen/4]=16}(growMemViews(),HEAP16)[sa/2]=family;(growMemViews(),HEAP32)[(sa+4)/4]=addr;(growMemViews(),HEAP16)[(sa+2)/2]=_htons(port);break;case 10:addr=inetPton6(DNS.lookup_name(addr));zeroMemory(sa,28);if(addrlen){(growMemViews(),HEAP32)[addrlen/4]=28}(growMemViews(),HEAP32)[sa/4]=family;(growMemViews(),HEAP32)[(sa+8)/4]=addr[0];(growMemViews(),HEAP32)[(sa+12)/4]=addr[1];(growMemViews(),HEAP32)[(sa+16)/4]=addr[2];(growMemViews(),HEAP32)[(sa+20)/4]=addr[3];(growMemViews(),HEAP16)[(sa+2)/2]=_htons(port);break;default:return 5}return 0};function ___syscall_accept4(fd,addr,len,flags,u1,u2){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(3,0,1,fd,addr,len,flags,u1,u2);addr=bigintToI53Checked(addr);len=bigintToI53Checked(len);try{var sock=getSocketFromFD(fd);var newsock=sock.sock_ops.accept(sock);if(addr){var errno=writeSockaddr(addr,newsock.family,newsock.daddr,newsock.dport,len)}return newsock.stream.fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var inetNtop4=addr=>(addr&255)+"."+(addr>>8&255)+"."+(addr>>16&255)+"."+(addr>>24&255);var inetNtop6=ints=>{var str="";var word=0;var longest=0;var lastzero=0;var zstart=0;var len=0;var i=0;var parts=[ints[0]&65535,ints[0]>>16,ints[1]&65535,ints[1]>>16,ints[2]&65535,ints[2]>>16,ints[3]&65535,ints[3]>>16];var hasipv4=true;var v4part="";for(i=0;i<5;i++){if(parts[i]){hasipv4=false;break}}if(hasipv4){v4part=inetNtop4(parts[6]|parts[7]<<16);if(parts[5]===-1){str="::ffff:";str+=v4part;return str}if(!parts[5]){str="::";if(v4part==="0.0.0.0")v4part="";if(v4part==="0.0.0.1")v4part="1";str+=v4part;return str}}for(word=0;word<8;word++){if(!parts[word]){if(word-lastzero>1){len=0}lastzero=word;len++}if(len>longest){longest=len;zstart=word-longest+1}}for(word=0;word<8;word++){if(longest>1){if(!parts[word]&&word>=zstart&&word{var family=(growMemViews(),HEAP16)[sa/2];var port=_ntohs((growMemViews(),HEAPU16)[(sa+2)/2]);var addr;switch(family){case 2:if(salen!==16){return{errno:28}}addr=(growMemViews(),HEAP32)[(sa+4)/4];addr=inetNtop4(addr);break;case 10:if(salen!==28){return{errno:28}}addr=[(growMemViews(),HEAP32)[(sa+8)/4],(growMemViews(),HEAP32)[(sa+12)/4],(growMemViews(),HEAP32)[(sa+16)/4],(growMemViews(),HEAP32)[(sa+20)/4]];addr=inetNtop6(addr);break;default:return{errno:5}}return{family,addr,port}};var getSocketAddress=(addrp,addrlen)=>{var info=readSockaddr(addrp,addrlen);if(info.errno)throw new FS.ErrnoError(info.errno);info.addr=DNS.lookup_addr(info.addr)||info.addr;return info};function ___syscall_bind(fd,addr,len,u1,u2,u3){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(4,0,1,fd,addr,len,u1,u2,u3);addr=bigintToI53Checked(addr);try{var sock=getSocketFromFD(fd);var info=getSocketAddress(addr,len);sock.sock_ops.bind(sock,info.addr,info.port);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_connect(fd,addr,len,u1,u2,u3){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(5,0,1,fd,addr,len,u1,u2,u3);addr=bigintToI53Checked(addr);try{var sock=getSocketFromFD(fd);var info=getSocketAddress(addr,len);sock.sock_ops.connect(sock,info.addr,info.port);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var syscallGetVarargP=()=>{var ret=Number((growMemViews(),HEAPU64)[SYSCALLS.varargs/8]);SYSCALLS.varargs+=8;return ret};var syscallGetVarargI=()=>{var ret=(growMemViews(),HEAP32)[+SYSCALLS.varargs/4];SYSCALLS.varargs+=4;return ret};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString((growMemViews(),HEAPU8),ptr,maxBytesToRead,ignoreNul):"";var HEAPU32;var SYSCALLS={currentUmask:18,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},writeStat(buf,stat){(growMemViews(),HEAPU32)[buf/4]=stat.dev;(growMemViews(),HEAPU32)[(buf+4)/4]=stat.mode;(growMemViews(),HEAPU64)[(buf+8)/8]=BigInt(stat.nlink);(growMemViews(),HEAPU32)[(buf+16)/4]=stat.uid;(growMemViews(),HEAPU32)[(buf+20)/4]=stat.gid;(growMemViews(),HEAPU32)[(buf+24)/4]=stat.rdev;(growMemViews(),HEAP64)[(buf+32)/8]=BigInt(stat.size);(growMemViews(),HEAP32)[(buf+40)/4]=4096;(growMemViews(),HEAP32)[(buf+44)/4]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();(growMemViews(),HEAP64)[(buf+48)/8]=BigInt(Math.floor(atime/1e3));(growMemViews(),HEAPU64)[(buf+56)/8]=BigInt(atime%1e3*1e3*1e3);(growMemViews(),HEAP64)[(buf+64)/8]=BigInt(Math.floor(mtime/1e3));(growMemViews(),HEAPU64)[(buf+72)/8]=BigInt(mtime%1e3*1e3*1e3);(growMemViews(),HEAP64)[(buf+80)/8]=BigInt(Math.floor(ctime/1e3));(growMemViews(),HEAPU64)[(buf+88)/8]=BigInt(ctime%1e3*1e3*1e3);(growMemViews(),HEAP64)[(buf+96)/8]=BigInt(stat.ino);return 0},writeStatFs(buf,stats){(growMemViews(),HEAPU32)[(buf+8)/4]=stats.bsize;(growMemViews(),HEAPU32)[(buf+72)/4]=stats.bsize;(growMemViews(),HEAP64)[(buf+16)/8]=BigInt(stats.blocks);(growMemViews(),HEAP64)[(buf+24)/8]=BigInt(stats.bfree);(growMemViews(),HEAP64)[(buf+32)/8]=BigInt(stats.bavail);(growMemViews(),HEAP64)[(buf+40)/8]=BigInt(stats.files);(growMemViews(),HEAP64)[(buf+48)/8]=BigInt(stats.ffree);(growMemViews(),HEAPU32)[(buf+56)/4]=stats.fsid;(growMemViews(),HEAPU32)[(buf+80)/4]=stats.flags;(growMemViews(),HEAPU32)[(buf+64)/4]=stats.namelen},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=(growMemViews(),HEAPU8).subarray(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_fcntl64(fd,cmd,varargs){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(6,0,1,fd,cmd,varargs);varargs=bigintToI53Checked(varargs);SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();var mask=289792;stream.flags=stream.flags&~mask|arg&mask;return 0}case 5:{var arg=syscallGetVarargP();var offset=0;(growMemViews(),HEAP16)[(arg+offset)/2]=2;return 0}case 6:case 7:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(7,0,1,fd,buf);buf=bigintToI53Checked(buf);try{return SYSCALLS.writeStat(buf,FS.fstat(fd))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ftruncate64(fd,length){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(8,0,1,fd,length);length=bigintToI53Checked(length);try{if(isNaN(length))return-22;FS.ftruncate(fd,length);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,(growMemViews(),HEAPU8),outPtr,maxBytesToWrite);function ___syscall_getcwd(buf,size){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(9,0,1,buf,size);buf=bigintToI53Checked(buf);size=bigintToI53Checked(size);try{if(!size)return-28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(size{var stream=FS.getStream(fd);if(!stream)return 32;var flags=stream.stream_ops?.poll?.(stream)??5;return flags&(events|8|16|32)};var doPollSync=(fds,nfds)=>{var count=0;for(var i=0,pollfd=fds;inew Promise(resolve=>{var regs=[];var timer;var done=false;function derive(){var count=0;for(var i=0,pollfd=fds;i0)timer=setTimeout(()=>finish(0),timeout)}});function ___syscall_poll(fds,nfds,timeout){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(19,0,2,fds,nfds,timeout);fds=bigintToI53Checked(fds);try{const isAsyncContext=PThread.currentProxiedOperationCallerThread;if(isAsyncContext){return doPollAsync(fds,nfds,timeout)}var count=doPollSync(fds,nfds);return count}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_recvfrom(fd,buf,len,flags,addr,alen){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(20,0,1,fd,buf,len,flags,addr,alen);buf=bigintToI53Checked(buf);len=bigintToI53Checked(len);addr=bigintToI53Checked(addr);alen=bigintToI53Checked(alen);try{var sock=getSocketFromFD(fd);var msg=sock.sock_ops.recvmsg(sock,len,flags);if(!msg)return 0;if(addr){var errno=writeSockaddr(addr,sock.family,msg.addr,msg.port,alen)}(growMemViews(),HEAPU8).set(msg.buffer,buf);return msg.buffer.byteLength}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_renameat(olddirfd,oldpath,newdirfd,newpath){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(21,0,1,olddirfd,oldpath,newdirfd,newpath);oldpath=bigintToI53Checked(oldpath);newpath=bigintToI53Checked(newpath);try{oldpath=SYSCALLS.getStr(oldpath);newpath=SYSCALLS.getStr(newpath);oldpath=SYSCALLS.calculateAt(olddirfd,oldpath);newpath=SYSCALLS.calculateAt(newdirfd,newpath);FS.rename(oldpath,newpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_rmdir(path){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(22,0,1,path);path=bigintToI53Checked(path);try{path=SYSCALLS.getStr(path);FS.rmdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_sendto(fd,buf,len,flags,addr,alen){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(23,0,1,fd,buf,len,flags,addr,alen);buf=bigintToI53Checked(buf);len=bigintToI53Checked(len);addr=bigintToI53Checked(addr);try{var sock=getSocketFromFD(fd);if(!addr){return FS.write(sock.stream,(growMemViews(),HEAP8),buf,len)}var dest=getSocketAddress(addr,alen);return sock.sock_ops.sendmsg(sock,(growMemViews(),HEAP8),buf,len,dest.addr,dest.port)}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_setsockopt(fd,level,optname,optval,optlen,unused){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(24,0,1,fd,level,optname,optval,optlen,unused);optval=bigintToI53Checked(optval);try{getSocketFromFD(fd);return-50}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_shutdown(fd,how,u1,u2,u3,u4){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(25,0,1,fd,how,u1,u2,u3,u4);try{var sock=getSocketFromFD(fd);return-52}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_socket(domain,type,protocol,u1,u2,u3){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(26,0,1,domain,type,protocol,u1,u2,u3);try{var sock=SOCKFS.createSocket(domain,type,protocol);return sock.stream.fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_stat64(path,buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(27,0,1,path,buf);path=bigintToI53Checked(path);buf=bigintToI53Checked(buf);try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_statfs64(path,size,buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(28,0,1,path,size,buf);path=bigintToI53Checked(path);size=bigintToI53Checked(size);buf=bigintToI53Checked(buf);try{SYSCALLS.writeStatFs(buf,FS.statfs(SYSCALLS.getStr(path)));return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(29,0,1,dirfd,path,flags);path=bigintToI53Checked(path);try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(!flags){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{return-28}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("");function __emscripten_init_main_thread_js(tb){tb=bigintToI53Checked(tb);var can_block=!ENVIRONMENT_IS_WEB;__emscripten_thread_init(tb,!ENVIRONMENT_IS_WORKER,1,can_block,1048576,false);PThread.threadInitTLS()}var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var maybeExit=()=>{if(runtimeExited){return}if(!keepRuntimeAlive()){try{if(ENVIRONMENT_IS_PTHREAD){if(_pthread_self())__emscripten_thread_exit(EXITSTATUS);return}_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(runtimeExited||ABORT){return}try{return func()}catch(e){handleException(e)}finally{maybeExit()}};function __emscripten_thread_mailbox_await(pthread_ptr){pthread_ptr=bigintToI53Checked(pthread_ptr);if(!waitAsyncPolyfilled){var wait=Atomics.waitAsync((growMemViews(),HEAP32),pthread_ptr/4,pthread_ptr);wait.value.then(checkMailbox);var waitingAsync=pthread_ptr+204;Atomics.store((growMemViews(),HEAP32),waitingAsync/4,1)}}var checkMailbox=()=>{var pthread_ptr=_pthread_self();if(!pthread_ptr)return;callUserCallback(()=>{__emscripten_thread_mailbox_await(pthread_ptr);__emscripten_check_mailbox()})};function __emscripten_notify_mailbox_postmessage(targetThread,currThreadId){targetThread=bigintToI53Checked(targetThread);currThreadId=bigintToI53Checked(currThreadId);if(targetThread==currThreadId){setTimeout(checkMailbox)}else if(ENVIRONMENT_IS_PTHREAD){postMessage({targetThread,cmd:4})}else{var worker=PThread.pthreads[targetThread];if(!worker){return}worker.postMessage({cmd:4})}}var proxiedJSCallArgs=[];function __emscripten_receive_on_main_thread_js(funcIndex,emAsmAddr,callingThread,bufSize,args,ctx,ctxArgs){emAsmAddr=bigintToI53Checked(emAsmAddr);callingThread=bigintToI53Checked(callingThread);args=bigintToI53Checked(args);ctx=bigintToI53Checked(ctx);ctxArgs=bigintToI53Checked(ctxArgs);proxiedJSCallArgs.length=0;var b=args/8;var end=(args+bufSize)/8;while(b__emscripten_run_js_on_main_thread_done(ctx,ctxArgs,rtn));return}if(typeof rtn=="bigint"){rtn=bigintToI53Checked(rtn)}return rtn}function __emscripten_system(command){command=bigintToI53Checked(command);if(!command)return 0;return-52}function __emscripten_thread_cleanup(thread){thread=bigintToI53Checked(thread);if(!ENVIRONMENT_IS_PTHREAD)cleanupThread(thread);else postMessage({cmd:6,thread})}function __emscripten_thread_set_strongref(thread){thread=bigintToI53Checked(thread)}var __emscripten_throw_longjmp=()=>{throw new EmscriptenSjLj};function __gmtime_js(time,tmPtr){time=bigintToI53Checked(time);tmPtr=bigintToI53Checked(tmPtr);var date=new Date(time*1e3);if(isNaN(date.getTime())){return 1}(growMemViews(),HEAP32)[tmPtr/4]=date.getUTCSeconds();(growMemViews(),HEAP32)[(tmPtr+4)/4]=date.getUTCMinutes();(growMemViews(),HEAP32)[(tmPtr+8)/4]=date.getUTCHours();(growMemViews(),HEAP32)[(tmPtr+12)/4]=date.getUTCDate();(growMemViews(),HEAP32)[(tmPtr+16)/4]=date.getUTCMonth();(growMemViews(),HEAP32)[(tmPtr+20)/4]=date.getUTCFullYear()-1900;(growMemViews(),HEAP32)[(tmPtr+24)/4]=date.getUTCDay();var start=Date.UTC(date.getUTCFullYear(),0,1,0,0,0,0);var yday=(date.getTime()-start)/(1e3*60*60*24)|0;(growMemViews(),HEAP32)[(tmPtr+28)/4]=yday;return 0}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time,tmPtr){time=bigintToI53Checked(time);tmPtr=bigintToI53Checked(tmPtr);var date=new Date(time*1e3);if(isNaN(date.getTime())){return 1}(growMemViews(),HEAP32)[tmPtr/4]=date.getSeconds();(growMemViews(),HEAP32)[(tmPtr+4)/4]=date.getMinutes();(growMemViews(),HEAP32)[(tmPtr+8)/4]=date.getHours();(growMemViews(),HEAP32)[(tmPtr+12)/4]=date.getDate();(growMemViews(),HEAP32)[(tmPtr+16)/4]=date.getMonth();(growMemViews(),HEAP32)[(tmPtr+20)/4]=date.getFullYear()-1900;(growMemViews(),HEAP32)[(tmPtr+24)/4]=date.getDay();var yday=ydayFromDate(date)|0;(growMemViews(),HEAP32)[(tmPtr+28)/4]=yday;(growMemViews(),HEAP64)[(tmPtr+40)/8]=BigInt(-(date.getTimezoneOffset()*60));var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;(growMemViews(),HEAP32)[(tmPtr+32)/4]=dst;return 0}var __mktime_js=function(tmPtr){tmPtr=bigintToI53Checked(tmPtr);var ret=(()=>{var date=new Date((growMemViews(),HEAP32)[(tmPtr+20)/4]+1900,(growMemViews(),HEAP32)[(tmPtr+16)/4],(growMemViews(),HEAP32)[(tmPtr+12)/4],(growMemViews(),HEAP32)[(tmPtr+8)/4],(growMemViews(),HEAP32)[(tmPtr+4)/4],(growMemViews(),HEAP32)[tmPtr/4],0);if(isNaN(date.getTime())){return-1}var dst=(growMemViews(),HEAP32)[(tmPtr+32)/4];var guessedOffset=date.getTimezoneOffset();var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dstOffset=Math.min(winterOffset,summerOffset);if(dst<0){dst=Number(summerOffset!=winterOffset&&dstOffset==guessedOffset)}else if(dst>0!=(dstOffset==guessedOffset)){var nonDstOffset=Math.max(winterOffset,summerOffset);var trueOffset=dst>0?dstOffset:nonDstOffset;date.setTime(date.getTime()+(trueOffset-guessedOffset)*6e4);if(isNaN(date.getTime())){return-1}}(growMemViews(),HEAP32)[(tmPtr+32)/4]=dst;(growMemViews(),HEAP32)[(tmPtr+24)/4]=date.getDay();var yday=ydayFromDate(date)|0;(growMemViews(),HEAP32)[(tmPtr+28)/4]=yday;(growMemViews(),HEAP32)[tmPtr/4]=date.getSeconds();(growMemViews(),HEAP32)[(tmPtr+4)/4]=date.getMinutes();(growMemViews(),HEAP32)[(tmPtr+8)/4]=date.getHours();(growMemViews(),HEAP32)[(tmPtr+12)/4]=date.getDate();(growMemViews(),HEAP32)[(tmPtr+16)/4]=date.getMonth();(growMemViews(),HEAP32)[(tmPtr+20)/4]=date.getYear();return date.getTime()/1e3})();return BigInt(ret)};var __tzset_js=function(timezone,daylight,std_name,dst_name){timezone=bigintToI53Checked(timezone);daylight=bigintToI53Checked(daylight);std_name=bigintToI53Checked(std_name);dst_name=bigintToI53Checked(dst_name);var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);(growMemViews(),HEAPU64)[timezone/8]=BigInt(stdTimezoneOffset*60);(growMemViews(),HEAP32)[daylight/4]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);if(summerOffsetperformance.timeOrigin+performance.now();var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);ptime=bigintToI53Checked(ptime);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);(growMemViews(),HEAP64)[ptime/8]=BigInt(nsec);return 0}var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{readEmAsmArgsArray.length=0;var ch;while(ch=(growMemViews(),HEAPU8)[sigPtr++]){var wide=ch!=105;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?Number((growMemViews(),HEAPU64)[buf/8]):ch==106?(growMemViews(),HEAP64)[buf/8]:ch==105?(growMemViews(),HEAP32)[buf/4]:(growMemViews(),HEAPF64)[buf/8]);buf+=wide?8:4}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);return ASM_CONSTS[code](...args)};function _emscripten_asm_const_int(code,sigPtr,argbuf){code=bigintToI53Checked(code);sigPtr=bigintToI53Checked(sigPtr);argbuf=bigintToI53Checked(argbuf);return runEmAsmFunction(code,sigPtr,argbuf)}var runMainThreadEmAsm=(emAsmAddr,sigPtr,argbuf,sync)=>{var args=readEmAsmArgs(sigPtr,argbuf);if(ENVIRONMENT_IS_PTHREAD){return proxyToMainThread(0,emAsmAddr,sync,...args)}return ASM_CONSTS[emAsmAddr](...args)};function _emscripten_asm_const_int_sync_on_main_thread(emAsmAddr,sigPtr,argbuf){emAsmAddr=bigintToI53Checked(emAsmAddr);sigPtr=bigintToI53Checked(sigPtr);argbuf=bigintToI53Checked(argbuf);return runMainThreadEmAsm(emAsmAddr,sigPtr,argbuf,1)}var _emscripten_check_blocking_allowed=()=>{};var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var _emscripten_exit_with_live_runtime=()=>{runtimeKeepalivePush();throw"unwind"};var getHeapMax=()=>17179869184;var _emscripten_get_heap_max=()=>BigInt(getHeapMax());var _emscripten_num_logical_cores=()=>navigator["hardwareConcurrency"];var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(BigInt(pages));updateMemoryViews();return 1}catch(e){}};function _emscripten_resize_heap(requestedSize){requestedSize=bigintToI53Checked(requestedSize);var oldSize=(growMemViews(),HEAPU8).length;if(requestedSize<=oldSize){return false}var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false}var convertFrameToPC=frame=>{var match;if(match=/\bwasm-function\[\d+\]:(0x[0-9a-f]+)/.exec(frame)){return+match[1]}else if(match=/:(\d+):\d+(?:\)|$)/.exec(frame)){return 2147483648|+match[1]}return 0};var UNWIND_CACHE={};var saveInUnwindCache=callstack=>{for(var line of callstack){var pc=convertFrameToPC(line);if(pc){UNWIND_CACHE[pc]=line}}};var jsStackTrace=()=>(new Error).stack.toString();var _emscripten_stack_snapshot=function(){var ret=(()=>{var callstack=jsStackTrace().split("\n");if(callstack[0]=="Error"){callstack.shift()}saveInUnwindCache(callstack);UNWIND_CACHE.last_addr=convertFrameToPC(callstack[3]);UNWIND_CACHE.last_stack=callstack;return UNWIND_CACHE.last_addr})();return BigInt(ret)};function _emscripten_stack_unwind_buffer(addr,buffer,count){addr=bigintToI53Checked(addr);buffer=bigintToI53Checked(buffer);var stack;if(UNWIND_CACHE.last_addr==addr){stack=UNWIND_CACHE.last_stack}else{stack=jsStackTrace().split("\n");if(stack[0]=="Error"){stack.shift()}saveInUnwindCache(stack)}var offset=3;while(stack[offset]&&convertFrameToPC(stack[offset])!=addr){++offset}for(var i=0;ithisProgram;var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(globalThis.navigator?.language??"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};function _environ_get(__environ,environ_buf){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(30,0,1,__environ,environ_buf);__environ=bigintToI53Checked(__environ);environ_buf=bigintToI53Checked(environ_buf);var bufSize=0;var envp=0;for(var string of getEnvStrings()){var ptr=environ_buf+bufSize;(growMemViews(),HEAPU64)[(__environ+envp)/8]=BigInt(ptr);bufSize+=stringToUTF8(string,ptr,Infinity)+1;envp+=8}return 0}function _environ_sizes_get(penviron_count,penviron_buf_size){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(31,0,1,penviron_count,penviron_buf_size);penviron_count=bigintToI53Checked(penviron_count);penviron_buf_size=bigintToI53Checked(penviron_buf_size);var strings=getEnvStrings();(growMemViews(),HEAPU64)[penviron_count/8]=BigInt(strings.length);var bufSize=0;for(var string of strings){bufSize+=lengthBytesUTF8(string)+1}(growMemViews(),HEAPU64)[penviron_buf_size/8]=BigInt(bufSize);return 0}function _fd_close(fd){if(ENVIRONMENT_IS_PTHREAD)return proxyToMainThread(32,0,1,fd);try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i0&&e instanceof FS.ErrnoError&&(e.errno==6||e.errno==6)){break}throw e}if(curr<0)return-1;ret+=curr;if(curr{if(iovcnt==1){return FS.write(stream,(growMemViews(),HEAP8),Number((growMemViews(),HEAPU64)[iov/8]),Number((growMemViews(),HEAPU64)[(iov+8)/8]),offset)}var total=0;for(var i=0,p=iov;i{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};PThread.init();FS.createPreloadedFile=FS_createPreloadedFile;FS.preloadFile=FS_preloadFile;FS.staticInit();{initMemory();if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["arguments"])programArgs=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];var preInit=Module["preInit"];if(preInit){if(typeof preInit=="function")Module["preInit"]=preInit=[preInit];while(preInit.length>0){preInit.shift()()}}}var proxiedFunctionTable=[_proc_exit,exitOnMainThread,pthreadCreateProxied,___syscall_accept4,___syscall_bind,___syscall_connect,___syscall_fcntl64,___syscall_fstat64,___syscall_ftruncate64,___syscall_getcwd,___syscall_getdents64,___syscall_getsockname,___syscall_getsockopt,___syscall_ioctl,___syscall_listen,___syscall_lstat64,___syscall_mkdirat,___syscall_newfstatat,___syscall_openat,___syscall_poll,___syscall_recvfrom,___syscall_renameat,___syscall_rmdir,___syscall_sendto,___syscall_setsockopt,___syscall_shutdown,___syscall_socket,___syscall_stat64,___syscall_statfs64,___syscall_unlinkat,_environ_get,_environ_sizes_get,_fd_close,_fd_pread,_fd_pwrite,_fd_read,_fd_seek,_fd_write];var ASM_CONSTS={7980558:($0,$1)=>{stringToUTF8(typeof navigator!=="undefined"&&navigator.language?navigator.language:"en-US",$0,$1)},7980673:$0=>typeof window!=="undefined"&&window.open(UTF8ToString($0),"_blank")?1:0,7980768:()=>{if(typeof location!=="undefined"&&location.reload)location.reload()}};function wasm_now_ms(){var o=globalThis.__wasmTimeOrigin;if(o===undefined)o=globalThis.__wasmTimeOrigin=performance.timeOrigin;return o+performance.now()}function wasm_hang_line_js(s){out(UTF8ToString(Number(s)))}function wasm_audio_publish_js(ring,capacity){if(typeof process!=="undefined"&&process.versions&&process.versions.node)return;postMessage({audio:{memory:wasmMemory,ring:Number(ring),capacity}})}function wasm_httpfs_manifest_js(buf,cap){if(typeof XMLHttpRequest==="undefined")return-1;let bytes=globalThis.__httpfsManifest;if(bytes===undefined){bytes=null;try{const x=new XMLHttpRequest;x.open("GET",self.location.origin+"/data/manifest.json",false);x.send();if(x.status===200)bytes=(new TextEncoder).encode(x.responseText)}catch(e){console.error("httpfs: manifest failed: "+e)}globalThis.__httpfsManifest=bytes}if(bytes===null)return-1;if(cap>bytes.length){(growMemViews(),HEAPU8).set(bytes,Number(buf));(growMemViews(),HEAPU8)[Number(buf)+bytes.length]=0;globalThis.__httpfsManifest=undefined}return bytes.length}function wasm_httpfs_io_start_js(table){if(ENVIRONMENT_IS_PTHREAD||!Module["ioWorker"]||Module["__ioStarted"])return;Module["__ioStarted"]=true;Module["ioWorker"].postMessage({memory:wasmMemory,table:Number(table)})}function wasm_userdata_page_js(){return typeof process!=="undefined"&&process.versions&&process.versions.node||ENVIRONMENT_IS_PTHREAD||!Module["ioWorker"]?0:1}function wasm_userdata_put_js(path,data,size,mtimeMs){Module["ioWorker"].postMessage({userdata:{path:UTF8ToString(Number(path)),data:(growMemViews(),HEAPU8).slice(Number(data),Number(data)+Number(size)),mtime:mtimeMs}})}function wasm_userdata_delete_js(path){Module["ioWorker"].postMessage({userdataDelete:UTF8ToString(Number(path))})}function wgpu_start_worker(ring,size,dbg){ring=Number(ring);size=Number(size);var msg={memory:wasmMemory,ring,size,dbg:Number(dbg),shaderUrl:Module["wgpuShaderUrl"]||"/shaders",shotEvery:Module["wgpuShotEvery"]||0};if(typeof process!=="undefined"&&process.versions&&process.versions.node){var wt=require("worker_threads");var path=require("path");var file=process.env.WGPU_WORKER||path.join(__dirname,"wgpu_worker.js");var w=new wt.Worker(file);w.unref();w.on("error",function(e){console.error("[wgpu] worker error: "+(e&&e.stack||e))});w.postMessage(msg)}else{var w=Module["wgpuWorker"]||new Worker(Module["wgpuWorkerUrl"]||"wgpu_worker.js");out("[wgpu] worker started from "+(ENVIRONMENT_IS_PTHREAD?"a pthread":"the runtime main thread")+", canvas "+(Module["canvas"]?Module["canvas"].constructor.name:"none"));var transfer=[];if(Module["canvas"]&&typeof OffscreenCanvas!=="undefined"&&Module["canvas"]instanceof OffscreenCanvas){msg.canvas=Module["canvas"];transfer.push(msg.canvas)}w.postMessage(msg,transfer)}}function wasm_input_publish_js(block){if(typeof process!=="undefined"&&process.versions&&process.versions.node)return;postMessage({input:{memory:wasmMemory,block:Number(block)}})}function wasm_has_page_js(){return typeof process!=="undefined"&&process.versions&&process.versions.node?0:1}function wasm_module_int_js(name,defaultValue){const key=UTF8ToString(Number(name));if(typeof Module!=="undefined"&&Module[key]!==undefined)return Module[key]|0;if(typeof process!=="undefined"&&process.env){const env=process.env[key.toUpperCase()];if(env!==undefined)return parseInt(env,10)|0}return defaultValue}function wasm_print_line_js(s){out(UTF8ToString(Number(s)))}var _main,_pthread_self,_fflush,_htons,_ntohs,__emscripten_tls_init,___funcs_on_exit,__emscripten_thread_init,___set_thread_state,__emscripten_thread_crashed,__emscripten_run_js_on_main_thread_done,__emscripten_run_js_on_main_thread,__emscripten_thread_free_data,__emscripten_thread_exit,__emscripten_check_mailbox,_setThrew,_emscripten_stack_set_limits,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,__indirect_function_table,wasmTable;function assignWasmExports(wasmExports){_main=Module["_main"]=wasmExports["__main_argc_argv"];_pthread_self=wasmExports["pthread_self"];_fflush=wasmExports["fflush"];_htons=wasmExports["htons"];_ntohs=wasmExports["ntohs"];__emscripten_tls_init=wasmExports["_emscripten_tls_init"];___funcs_on_exit=wasmExports["__funcs_on_exit"];__emscripten_thread_init=wasmExports["_emscripten_thread_init"];___set_thread_state=wasmExports["__set_thread_state"];__emscripten_thread_crashed=wasmExports["_emscripten_thread_crashed"];__emscripten_run_js_on_main_thread_done=wasmExports["_emscripten_run_js_on_main_thread_done"];__emscripten_run_js_on_main_thread=wasmExports["_emscripten_run_js_on_main_thread"];__emscripten_thread_free_data=wasmExports["_emscripten_thread_free_data"];__emscripten_thread_exit=wasmExports["_emscripten_thread_exit"];__emscripten_check_mailbox=wasmExports["_emscripten_check_mailbox"];_setThrew=wasmExports["setThrew"];_emscripten_stack_set_limits=wasmExports["emscripten_stack_set_limits"];__emscripten_stack_restore=wasmExports["_emscripten_stack_restore"];__emscripten_stack_alloc=wasmExports["_emscripten_stack_alloc"];_emscripten_stack_get_current=wasmExports["emscripten_stack_get_current"];__indirect_function_table=wasmTable=wasmExports["__indirect_function_table"]}var wasmImports;function assignWasmImports(){wasmImports={__pthread_create_js:___pthread_create_js,__syscall_accept4:___syscall_accept4,__syscall_bind:___syscall_bind,__syscall_connect:___syscall_connect,__syscall_fcntl64:___syscall_fcntl64,__syscall_fstat64:___syscall_fstat64,__syscall_ftruncate64:___syscall_ftruncate64,__syscall_getcwd:___syscall_getcwd,__syscall_getdents64:___syscall_getdents64,__syscall_getsockname:___syscall_getsockname,__syscall_getsockopt:___syscall_getsockopt,__syscall_ioctl:___syscall_ioctl,__syscall_listen:___syscall_listen,__syscall_lstat64:___syscall_lstat64,__syscall_mkdirat:___syscall_mkdirat,__syscall_newfstatat:___syscall_newfstatat,__syscall_openat:___syscall_openat,__syscall_poll:___syscall_poll,__syscall_recvfrom:___syscall_recvfrom,__syscall_renameat:___syscall_renameat,__syscall_rmdir:___syscall_rmdir,__syscall_sendto:___syscall_sendto,__syscall_setsockopt:___syscall_setsockopt,__syscall_shutdown:___syscall_shutdown,__syscall_socket:___syscall_socket,__syscall_stat64:___syscall_stat64,__syscall_statfs64:___syscall_statfs64,__syscall_unlinkat:___syscall_unlinkat,_abort_js:__abort_js,_emscripten_init_main_thread_js:__emscripten_init_main_thread_js,_emscripten_notify_mailbox_postmessage:__emscripten_notify_mailbox_postmessage,_emscripten_receive_on_main_thread_js:__emscripten_receive_on_main_thread_js,_emscripten_system:__emscripten_system,_emscripten_thread_cleanup:__emscripten_thread_cleanup,_emscripten_thread_mailbox_await:__emscripten_thread_mailbox_await,_emscripten_thread_set_strongref:__emscripten_thread_set_strongref,_emscripten_throw_longjmp:__emscripten_throw_longjmp,_gmtime_js:__gmtime_js,_localtime_js:__localtime_js,_mktime_js:__mktime_js,_tzset_js:__tzset_js,clock_time_get:_clock_time_get,emscripten_asm_const_int:_emscripten_asm_const_int,emscripten_asm_const_int_sync_on_main_thread:_emscripten_asm_const_int_sync_on_main_thread,emscripten_check_blocking_allowed:_emscripten_check_blocking_allowed,emscripten_date_now:_emscripten_date_now,emscripten_exit_with_live_runtime:_emscripten_exit_with_live_runtime,emscripten_get_heap_max:_emscripten_get_heap_max,emscripten_get_now:_emscripten_get_now,emscripten_num_logical_cores:_emscripten_num_logical_cores,emscripten_resize_heap:_emscripten_resize_heap,emscripten_stack_snapshot:_emscripten_stack_snapshot,emscripten_stack_unwind_buffer:_emscripten_stack_unwind_buffer,environ_get:_environ_get,environ_sizes_get:_environ_sizes_get,exit:_exit,fd_close:_fd_close,fd_pread:_fd_pread,fd_pwrite:_fd_pwrite,fd_read:_fd_read,fd_seek:_fd_seek,fd_write:_fd_write,invoke_iiijj,invoke_ij,invoke_iji,invoke_ijji,invoke_ijjiii,invoke_jj,invoke_jjiiijij,invoke_jjij,invoke_jjj,invoke_vj,invoke_vjii,invoke_vjij,invoke_vjj,invoke_vjjii,memory:wasmMemory,proc_exit:_proc_exit,wasm_audio_publish_js,wasm_hang_line_js,wasm_has_page_js,wasm_httpfs_io_start_js,wasm_httpfs_manifest_js,wasm_input_publish_js,wasm_module_int_js,wasm_now_ms,wasm_print_line_js,wasm_userdata_delete_js,wasm_userdata_page_js,wasm_userdata_put_js,wgpu_start_worker}}function invoke_vjj(index,a1,a2){var sp=stackSave();try{getWasmTableEntry(Number(index))(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_ij(index,a1){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_jj(index,a1){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0);return 0n}}function invoke_vj(index,a1){var sp=stackSave();try{getWasmTableEntry(Number(index))(a1)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_vjij(index,a1,a2,a3){var sp=stackSave();try{getWasmTableEntry(Number(index))(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_jjij(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0);return 0n}}function invoke_vjii(index,a1,a2,a3){var sp=stackSave();try{getWasmTableEntry(Number(index))(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_iji(index,a1,a2){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_jjj(index,a1,a2){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0);return 0n}}function invoke_vjjii(index,a1,a2,a3,a4){var sp=stackSave();try{getWasmTableEntry(Number(index))(a1,a2,a3,a4)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_jjiiijij(index,a1,a2,a3,a4,a5,a6,a7){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2,a3,a4,a5,a6,a7)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0);return 0n}}function invoke_iiijj(index,a1,a2,a3,a4){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2,a3,a4)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_ijji(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2,a3)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function invoke_ijjiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{return getWasmTableEntry(Number(index))(a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(!(e instanceof EmscriptenEH))throw e;_setThrew(1,0)}}function applySignatureConversions(wasmExports){wasmExports=Object.assign({},wasmExports);var makeWrapper___PP=f=>(a0,a1,a2)=>f(a0,BigInt(a1?a1:0),BigInt(a2?a2:0));var makeWrapper_p=f=>()=>Number(f());var makeWrapper__p=f=>a0=>f(BigInt(a0));var makeWrapper__p_____=f=>(a0,a1,a2,a3,a4,a5)=>f(BigInt(a0),a1,a2,a3,a4,a5);var makeWrapper__p___=f=>(a0,a1,a2,a3)=>f(BigInt(a0),a1,a2,a3);var makeWrapper__pp_=f=>(a0,a1,a2)=>f(BigInt(a0),BigInt(a1),a2);var makeWrapper___p_p_=f=>(a0,a1,a2,a3,a4)=>f(a0,BigInt(a1),a2,BigInt(a3),a4);var makeWrapper__p_=f=>(a0,a1)=>f(BigInt(a0),a1);var makeWrapper__pp=f=>(a0,a1)=>f(BigInt(a0),BigInt(a1));var makeWrapper_pp=f=>a0=>Number(f(BigInt(a0)));wasmExports["__main_argc_argv"]=makeWrapper___PP(wasmExports["__main_argc_argv"]);wasmExports["pthread_self"]=makeWrapper_p(wasmExports["pthread_self"]);wasmExports["fflush"]=makeWrapper__p(wasmExports["fflush"]);wasmExports["_emscripten_tls_init"]=makeWrapper_p(wasmExports["_emscripten_tls_init"]);wasmExports["_emscripten_thread_init"]=makeWrapper__p_____(wasmExports["_emscripten_thread_init"]);wasmExports["__set_thread_state"]=makeWrapper__p___(wasmExports["__set_thread_state"]);wasmExports["_emscripten_run_js_on_main_thread_done"]=makeWrapper__pp_(wasmExports["_emscripten_run_js_on_main_thread_done"]);wasmExports["_emscripten_run_js_on_main_thread"]=makeWrapper___p_p_(wasmExports["_emscripten_run_js_on_main_thread"]);wasmExports["_emscripten_thread_free_data"]=makeWrapper__p(wasmExports["_emscripten_thread_free_data"]);wasmExports["_emscripten_thread_exit"]=makeWrapper__p(wasmExports["_emscripten_thread_exit"]);wasmExports["setThrew"]=makeWrapper__p_(wasmExports["setThrew"]);wasmExports["emscripten_stack_set_limits"]=makeWrapper__pp(wasmExports["emscripten_stack_set_limits"]);wasmExports["_emscripten_stack_restore"]=makeWrapper__p(wasmExports["_emscripten_stack_restore"]);wasmExports["_emscripten_stack_alloc"]=makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);wasmExports["emscripten_stack_get_current"]=makeWrapper_p(wasmExports["emscripten_stack_get_current"]);return wasmExports}function callMain(args=[]){var entryFunction=_main;args.unshift(thisProgram);var argc=args.length;var argv=stackAlloc((argc+1)*8);var argv_ptr=argv;for(var arg of args){(growMemViews(),HEAPU64)[argv_ptr/8]=BigInt(stringToUTF8OnStack(arg));argv_ptr+=8}(growMemViews(),HEAPU64)[argv_ptr/8]=0n;try{var ret=entryFunction(argc,BigInt(argv));exitJS(ret,true);return ret}catch(e){return handleException(e)}}async function run(args=programArgs){if(ENVIRONMENT_IS_PTHREAD){initRuntime();return}preRun();if(runDependencies){await resolveRunDependencies()}var setStatus=Module["setStatus"];if(setStatus){setStatus("Running...");await new Promise(resolve=>setTimeout(resolve,1));setTimeout(setStatus,1,"")}if(ABORT)return;initRuntime();Module["onRuntimeInitialized"]?.();var noInitialRun=Module["noInitialRun"]||false;if(!noInitialRun)callMain(args);postRun()}var wasmExports;if(!ENVIRONMENT_IS_PTHREAD){createWasm().then(()=>run())} diff --git a/b/8b0b5899ed/io_worker.js b/b/8b0b5899ed/io_worker.js new file mode 100644 index 0000000000000000000000000000000000000000..b10bf001120db9b1e478ec7ea38173c5d932e074 --- /dev/null +++ b/b/8b0b5899ed/io_worker.js @@ -0,0 +1,644 @@ +// HTTP read worker + persistent block cache: serves every file read of the engine threads (platform/file/httpfs_wasm.cpp). +// +// Engine threads used to read with their own synchronous XMLHttpRequest, behind a service worker that cached the blocks. Each response is a fresh ArrayBuffer (plus the +// request's own copy of the body) that the browser frees only when that worker's GC runs, and an engine thread that is mostly inside wasm or blocked in Atomics.wait +// almost never does: the bytes read piled up as ~1.5 GB of renderer memory (reproduced with 30 blank workers reading 1.8 GB: 3.6 GB working set, whatever is done to +// the buffers afterwards), and the service worker added another ~0.9 GB of its own. +// This worker has an event loop and streams every response chunk by chunk straight into a persistent store in the Origin Private File System; reads are then served +// from the store into the shared wasm heap. No JavaScript buffers are involved, so nothing has to be garbage collected. +// +// Store: `store.bin` is append-only. A range fetch reserves room at the end (whole 256 KB blocks of the file), streams the body into it, and records where every block +// went in `journal.bin` (16-byte entries: file id, block, offset low, offset high) after the data has been flushed. The journal header carries the manifest version; +// another version (or a foreign magic) starts an empty store. Without OPFS (or when another tab has the store open: sync access handles are exclusive) blocks are +// only kept in a 48 MB memory cache. +// +// Protocol with the engine threads (all in the shared wasm heap, `table` = address of an Int32 table, see httpfs_wasm.cpp): +// header: [0] doorbell (incremented by every request or hint), [1] slot counter (each engine thread takes one slot on its first read), +// [2] word offset of the hint ring, [3] its entries, [4] hints claimed by the engine, [5] hints consumed here +// slot i (16 words at 16 + 16*i): [0] state 0 idle / 1 requested / 3 taken by this worker / 2 done, [1] file id, [2..3] offset, [4..5] destination address, [6] length, [7] result (bytes or -1) +// hint ring (4 words per entry): file id, offset low, offset high, length (written last; 0 = free): a read the engine has queued and will perform later, one at a time (the +// streamer's single reader thread); fetching it now, HINT_PAR at a time, turns ~3 reads/s (one round trip each) into as many as the link carries. See drainHints. +'use strict'; +let mem, HEAP32, HEAPU8, table; +let files = [], base = '', bc = null, pendingBytes = 0, lastPost = 0, noHints = false, dataQuery = ''; // noHints: ?nohints=1 (diagnostics), see drainHints; dataQuery: ?v= on every data URL +// Store block size 4 KB. The engine mounts ~1,200 archives at boot and reads only each one's table of contents (16 bytes, the entries, the names: median 3 KB, 4.9 MB for all +// of them, measured with ?trace=1); fetching 256 KB (first version) or 16 KB blocks plus a growing read-ahead (second) made the boot download 25x larger for those files. +// Read-ahead now only follows *large* sequential reads (streamed resources), see serve(). +const BS = 4096, MAX_RUN = 256, MAX_AHEAD = 512 * 1024, FIRST_AHEAD = 64 * 1024, AHEAD_MIN_READ = 65536; +const MBS = 262144; // block size of the memory-only fallback (no store) +let remoteLog = false; // ?log=1 on the page (loader.js passes it in the init message): this worker's diagnostics go to the dev server +function log(text) { if (remoteLog) fetch('/log', { method: 'POST', body: text }).catch(() => {}); } + +const pathIndex = new Map(); +const fileBytes = new Map(); // diagnostics: network bytes per file path, top of the list goes to the server log every 25 MB +let statTotal = 0, statNext = 25 * 1048576, statT0 = performance.now(); +function tally(f, n) { + fileBytes.set(f.path, (fileBytes.get(f.path) || 0) + n); + statTotal += n; + if (statTotal >= statNext) { + statNext += 25 * 1048576; + const top = [...fileBytes].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([p, b]) => p.split('/').slice(-2).join('/') + ' ' + (b / 1048576 | 0) + 'MB').join(' | '); + const ext = new Map(), sizes = [0, 0, 0, 0]; // bytes by extension; bytes by fetched amount per file: <1 MB, <8 MB, <32 MB, more + for (const [pth, b] of fileBytes) { + const e = (pth.match(/\.(\w+)$/) || [, '?'])[1]; ext.set(e, (ext.get(e) || 0) + b); + sizes[b < 1048576 ? 0 : b < 8388608 ? 1 : b < 33554432 ? 2 : 3] += b; + } + log('[io] by extension: ' + [...ext].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([e, b]) => e + ' ' + (b / 1048576 | 0) + 'MB').join(' ') + ' | by per-file bytes: <1MB ' + (sizes[0] / 1048576 | 0) + ' <8MB ' + (sizes[1] / 1048576 | 0) + ' <32MB ' + (sizes[2] / 1048576 | 0) + ' MB'); + const r = reqStats, mb = (b) => (b / 1048576).toFixed(0); + let wholeN = 0, wholeB = 0, partN = 0, partB = 0; const wholeBig = []; + for (const [pth, b] of fileBytes) { + const f = files[pathIndex.get(pth)]; + if (f.size > 262144 && b >= 0.9 * f.size) { wholeN++; wholeB += b; wholeBig.push([pth, b]); } else { partN++; partB += b; } + } + wholeBig.sort((a, b) => b[1] - a[1]); + log('[io] files read (almost) completely: ' + wholeN + ' = ' + (wholeB / 1048576 | 0) + ' MB; everything else: ' + partN + ' files = ' + (partB / 1048576 | 0) + ' MB; biggest whole reads: ' + wholeBig.slice(0, 12).map(([pth, b]) => pth.split('/').slice(-2).join('/') + ' ' + (b / 1048576 | 0)).join(' | ')); + log('[io] engine requests: ' + r.n + ' (' + mb(r.bytes) + ' MB asked) <=64K: ' + r.small[0] + ' (' + mb(r.small[1]) + ' MB), <=1M: ' + r.mid[0] + ' (' + mb(r.mid[1]) + ' MB), >1M: ' + r.big[0] + ' (' + mb(r.big[1]) + ' MB); starting in the first 1 MB of a file: ' + r.head[0] + ' (' + mb(r.head[1]) + ' MB)'); + log('[io] ' + ((performance.now() - statT0) / 1000 | 0) + 's ' + (statTotal / 1048576 | 0) + ' MB fetched, ' + fileBytes.size + ' files; top: ' + top); + } +} +const reqStats = { n: 0, bytes: 0, small: [0, 0], mid: [0, 0], big: [0, 0], head: [0, 0] }; // diagnostics: requests by size class; `head` = starting in the first 1 MB of a file +// ?log=1: every 5 s, how the network is used (how many fetches are in flight is the speed: a fetch costs a round trip) and how often and how long the engine waited for it +const netStat = { started: 0, active: 0, maxActive: 0, demand: 0, demandMiss: 0, demandWaitMs: 0, cold: 0, slowLogged: 0 }; // cold: reads that had to start their own fetch (nobody hinted them); the other misses joined a fetch in flight (hinted, but not finished yet) +function startNetStats() { + let last = { started: 0, demand: 0, demandMiss: 0, demandWaitMs: 0, bytes: 0, cold: 0 }, t = performance.now(); + setInterval(() => { + const now = performance.now(), s = (now - t) / 1000, mb = (statTotal - last.bytes) / 1048576; + const started = netStat.started - last.started, demand = netStat.demand - last.demand, miss = netStat.demandMiss - last.demandMiss, wait = netStat.demandWaitMs - last.demandWaitMs, cold = netStat.cold - last.cold; + t = now; last = { started: netStat.started, demand: netStat.demand, demandMiss: netStat.demandMiss, demandWaitMs: netStat.demandWaitMs, bytes: statTotal, cold: netStat.cold }; + if (!started && !demand) return; + log('[io] net ' + s.toFixed(0) + ' s: ' + mb.toFixed(1) + ' MB (' + (mb / s).toFixed(2) + ' MB/s), fetches started ' + started + ', in flight now ' + netStat.active + ' (most ' + netStat.maxActive + '), engine reads ' + demand + ', of which ' + miss + ' waited for the network (' + cold + ' not hinted; ' + (miss ? (wait / miss).toFixed(0) : 0) + ' ms each), hint queue ' + hintQueue.length + ', hints seen ' + hintsSeen + ' fetched ' + hintsFetched); + netStat.maxActive = netStat.active; + }, 5000); +} +let traceOn = false, traceBuf = [], traceN = 0; +function noteTrace(id, off, len) { // ?trace=1: every engine request (file index, offset, length), posted in batches: tools analyse them offline + if (traceN++ > 60000) return; + traceBuf.push(id + ',' + off + ',' + len); + if (traceBuf.length >= 2000) { log('[trace] ' + traceBuf.join(';')); traceBuf = []; } +} +function noteRequest(off, len) { + const r = reqStats; r.n++; r.bytes += len; + const c = len <= 65536 ? r.small : len <= 1048576 ? r.mid : r.big; c[0]++; c[1] += len; + if (off < 1048576) { r.head[0]++; r.head[1] += len; } +} +function report(n) { + pendingBytes += n; + const now = performance.now(); + if (now - lastPost > 400) { lastPost = now; bc.postMessage({ dl: pendingBytes }); pendingBytes = 0; } +} + +// ---- persistent store -------------------------------------------------------------------------------------------------------------------------------------- +let sh = null, jh = null, storeEnd = 0, journalEnd = 16; +const index = new Map(); // id * 1048576 + block -> offset in store.bin +const pendingJournal = []; +const inflight = new Map(); // same key -> Promise of the run fetching the block +const memCache = new Map(); // fallback without a store: key -> Uint8Array (LRU) +let memBytes = 0; +const blockLen = (f, block) => Math.min(BS, f.size - block * BS); +// The server's copy of a file is shorter than the manifest says (it changed after the manifest was made: serve.py warns at start): from now on the file is that long, so +// reads past its end come back short (end of file) instead of failing over and over (the engine retries a failed read forever: CFileMgr::ReadLine on loadingtime.dat). +function shrink(f, size) { + if (size >= f.size) return; + log('[io] ' + f.path + ' is ' + size + ' bytes on the server, not ' + f.size + ' as the manifest says: reading it as ' + size + ' bytes (regenerate the manifest)'); + f.size = size; +} +// Indexes the blocks a..b of a run of file f stored at `offset`, of which `got` of `fullBytes` bytes arrived (fewer: the file ends inside the run). +function indexRun(id, f, a, b, offset, got, fullBytes) { + const keep = (k) => { index.set(id * 1048576 + k, offset + (k - a) * BS); pendingJournal.push([id, k, offset + (k - a) * BS]); }; + if (got >= fullBytes) { for (let k = a; k <= b; k++) keep(k); return; } + shrink(f, a * BS + got); + const whole = Math.floor(got / BS); + for (let k = a; k < a + whole; k++) keep(k); + // The file's new last block, partly filled: this session only. The journal would bring it back next time under the manifest's longer size, and reads would run past its + // bytes into whatever follows in the store. + if (got % BS) index.set(id * 1048576 + a + whole, offset + whole * BS); +} + +async function openStore(version) { + try { + const root = await navigator.storage.getDirectory(); + const dir = await root.getDirectoryHandle('gamedata', { create: true }); + // A reload while the previous page's io worker is still shutting down finds the files locked (sync access handles are exclusive): wait for it to let go. + const openHandle = async (name) => { + for (let attempt = 0; ; attempt++) { + try { return await (await dir.getFileHandle(name, { create: true })).createSyncAccessHandle(); } + catch (e) { if (attempt >= 40 || e.name !== 'NoModificationAllowedError') throw e; await new Promise((r) => setTimeout(r, 250)); } // up to 10 s + } + }; + const s = await openHandle('store.bin'); + let j; + try { j = await openHandle('journal.bin'); } catch (e) { s.close(); throw e; } + const head = new DataView(new ArrayBuffer(16)); + let ok = false; + if (j.getSize() >= 16) { + j.read(new Uint8Array(head.buffer), { at: 0 }); + ok = head.getUint32(0, true) === 0x4a415449 && head.getFloat64(8, true) === version; + } + if (!ok) { + s.truncate(0); j.truncate(0); + head.setUint32(0, 0x4a415449, true); head.setFloat64(8, version, true); + j.write(new Uint8Array(head.buffer), { at: 0 }); + j.flush(); + } + storeEnd = s.getSize(); + const size = j.getSize(); + const n = Math.floor((size - 16) / 16); + const buf = new Uint8Array(n * 16); + if (n) j.read(buf, { at: 16 }); + const dv = new DataView(buf.buffer); + let good = 0; + for (let i = 0; i < n; i++) { + const id = dv.getUint32(i * 16, true), block = dv.getUint32(i * 16 + 4, true), off = dv.getUint32(i * 16 + 8, true) + dv.getUint32(i * 16 + 12, true) * 4294967296; + const f = files[id]; + if (f && off + blockLen(f, block) <= storeEnd) { index.set(id * 1048576 + block, off); good++; } + } + journalEnd = 16 + n * 16; + sh = s; jh = j; + log('[io] persistent store: ' + good + ' blocks (' + (good * BS / 1048576 | 0) + ' MB), store.bin ' + (storeEnd / 1048576 | 0) + ' MB'); + } catch (e) { + sh = jh = null; + log('[io] no persistent store (' + e.message + '): blocks are cached in memory only'); + } +} + +// ---- boot read set: recorded with ?record=1, replayed at page load ---------------------------------------------------------------------------------------- +// The engine reads (almost) the same ~600 MB of archive headers and start-up data on every boot. A run with ?record=1 logs the block ranges per file in order of first +// touch (POST /log, record_bootset.py extracts them); every later page load fetches that set right away, with several requests in flight, in parallel with the download +// and start-up of the engine instead of one blocking request at a time from its threads. +let recording = false; +const touched = new Map(); // path -> [[first, last], ...] +function recordTouch(id, a, b) { // byte range actually asked for by the engine (no read-ahead, independent of the block size) + const p = files[id].path; + let r = touched.get(p); + if (!r) { r = []; touched.set(p, r); if (touched.size === 1) setTimeout(dumpRecording, 75000); } + r.push([a, b]); +} +function dumpRecording() { + const out = []; + for (const [p, r] of touched) { + r.sort((x, y) => x[0] - y[0]); + const m = []; + for (const [a, b] of r) { const l = m[m.length - 1]; if (l && a <= l[1] + 4096) l[1] = Math.max(l[1], b); else m.push([a, b]); } + out.push([p, m]); + } + log('[bootset] ' + JSON.stringify(out)); +} + +// An overloaded host answers 503/500/429 (seen 2026-10-06: 10,000 visitors in a day, thousands of error responses, and the engine quits when a data file cannot be read): such an +// answer, or none, is retried up to 8 times with growing, jittered waits (~20 s in all). Only the start of a response is retried (nothing of its body has been used yet). +async function fetchRetry(url, init) { + for (let attempt = 0; ; attempt++) { + let res = null, err = null; + try { res = await fetch(url, init); } catch (e) { err = e; } + if (res && res.status < 500 && res.status !== 429) return res; + if (attempt >= 7) { if (res) return res; throw err; } + netStat.retries = (netStat.retries || 0) + 1; + await new Promise((r) => setTimeout(r, Math.min(5000, 300 * 2 ** attempt) * (0.5 + Math.random()))); + } +} +async function sha1Hex(s) { return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-1', new TextEncoder().encode(s))), (b) => b.toString(16).padStart(2, '0')).join(''); } +let dataVersion = ''; // the manifest's version (set when it is loaded): part of a cached batch's name +// One POST /data/batch answers a list of block runs with one streamed body: thousands of small archive pieces cost one round trip per batch instead of one each. +// The boot set's batches are the same for every visitor (`wanted` marks the files this visitor still needs; the rest of the batch is read and dropped), so the host keeps each one as a +// static file named after a hash of its request (host/index.php save_batch): it is asked for with a plain GET first, which Cloudflare caches, and only if that fails (not built yet, +// an old host, no DecompressionStream) does the POST build it. +function batchFetch(runsIn, compressed, wanted) { + const runs = runsIn.map((r) => { + const f = files[r.id], bytes = (r.b - r.a) * BS + blockLen(f, r.b), skip = !!wanted && !wanted.has(r.id), offset = skip ? 0 : storeEnd; + if (!skip) storeEnd += bytes; + return { id: r.id, a: r.a, b: r.b, f, bytes, offset, skip }; + }); + netStat.started++; if (++netStat.active > netStat.maxActive) netStat.maxActive = netStat.active; + const p = (async () => { + const body = JSON.stringify(runs.map((r) => [r.f.path, r.a * BS, r.a * BS + r.bytes - 1])); + let lens = runs.map((r) => r.bytes); + const consume = async (reader) => { + let ri = 0, inRun = 0; + while (ri < runs.length && lens[ri] === 0) ri++; + for (;;) { + const { done, value } = await reader.read(); + if (done) break; + report(value.length); + for (let pos = 0; pos < value.length && ri < runs.length;) { + const r = runs[ri], n = Math.min(value.length - pos, lens[ri] - inRun); + if (!r.skip) { sh.write(value.subarray(pos, pos + n), { at: r.offset + inRun }); tally(r.f, n); } + inRun += n; pos += n; + if (inRun === lens[ri]) { ri++; inRun = 0; while (ri < runs.length && lens[ri] === 0) ri++; } + } + } + if (ri !== runs.length) throw new Error('short batch answer: ' + ri + ' of ' + runs.length + ' runs'); + }; + let cached = false; + if (compressed && dataVersion && self.crypto && crypto.subtle && typeof DecompressionStream !== 'undefined') { + try { + const res = await fetch(base + 'batchc/' + await sha1Hex(dataVersion + ':' + body) + '.bin' + dataQuery, { priority: 'low' }); + if (res.ok && res.body) { await consume(res.body.pipeThrough(new DecompressionStream('gzip')).getReader()); cached = true; netStat.batchCached = (netStat.batchCached || 0) + 1; } + } catch (e) { /* not built yet or unusable: the POST below builds and sends it (blocks written so far are written again at the same places) */ } + } + if (!cached) { + const res = await fetchRetry(base + (compressed ? 'batch?gz=1' + (dataVersion ? '&c=1&v=' + encodeURIComponent(dataVersion) : '') : 'batch'), { method: 'POST', priority: 'low', body }); + if (!res.ok) throw new Error('HTTP ' + res.status + ' for a batch'); + // the length of each range as sent (a range is clamped at the end of the server's copy of the file); without the header, the lengths asked for + const sent = (res.headers.get('X-Run-Lengths') || '').split(',').map(Number); + lens = sent.length === runs.length && sent.every((n, i) => n >= 0 && n <= runs[i].bytes) ? sent : runs.map((r) => r.bytes); + await consume(res.body.getReader()); + } + runs.forEach((r, i) => { if (!r.skip) indexRun(r.id, r.f, r.a, r.b, r.offset, lens[i], r.bytes); }); + scheduleFlush(); + })(); + const done = () => { netStat.active--; for (const r of runs) if (!r.skip) for (let k = r.a; k <= r.b; k++) inflight.delete(r.id * 1048576 + k); }; + for (const r of runs) if (!r.skip) for (let k = r.a; k <= r.b; k++) inflight.set(r.id * 1048576 + k, p); + p.then(done, done); + return p; +} + +// Lanes: the host answers a Range request (Apache) at a few hundred KB/s per stream whatever the link is, and the speed grows with the number of streams (measured from here: +// 6 in flight 3.4 MB/s, 32 3.6, 64 7.1, 128 14.1 MB/s): the boot set (~580 MB) is fetched as ranges, RUN_LANES at a time. Compressible small files still go through the host's +// PHP (compressed batches), few at a time: PHP answers about 16 requests at once. +const RUN_LANES = 32, BATCH_LANES = 4, RUN_GAP = 64; // RUN_GAP: blocks; two ranges of a file closer than this are fetched as one (the bytes between are read next to them) +async function prefetch(name) { + let set; + try { const r = await fetchRetry(base + name, { cache: 'no-store' }); if (!r.ok) return; set = await r.json(); } catch (e) { return; } + // in boot order: compressible small files whole, in compressed batches; everything else as runs of at most MAX_RUN blocks (1 MB) + const runs = [], batches = []; + let cbatch = [], cbytes = 0; + const addRuns = (id, a, b) => { for (let k = a; k <= b; k += MAX_RUN) runs.push({ id, a: k, b: Math.min(b, k + MAX_RUN - 1) }); }; + for (const [path, ranges] of set) { + const id = pathIndex.get(path); + if (id === undefined) continue; + const f = files[id], lastBlock = Math.ceil(f.size / BS) - 1; + if (COMPRESSIBLE.test(f.path) && f.size <= WHOLE_MAX) { // small compressible files: whole files, several per request, compressed by the server + cbatch.push({ id, a: 0, b: lastBlock }); cbytes += f.size; + if (cbytes >= 4194304 || cbatch.length >= 300) { batches.push(cbatch); cbatch = []; cbytes = 0; } + continue; + } + let cur = null; + for (const [x, y] of ranges) { + const a = Math.floor(x / BS), b = Math.min(Math.floor(y / BS), lastBlock); + if (cur && a <= cur.b + RUN_GAP) cur.b = Math.max(cur.b, b); + else { if (cur) addRuns(id, cur.a, cur.b); cur = { a, b }; } + } + if (cur) addRuns(id, cur.a, cur.b); + } + if (cbatch.length) batches.push(cbatch); + const t0 = performance.now(); + log('[io] prefetching the boot set: ' + set.length + ' files, ' + runs.length + ' ranges, ' + batches.length + ' compressed batches'); + let nextRun = 0, nextBatch = 0; + const runLane = async () => { + while (nextRun < runs.length) { + const r = runs[nextRun++]; + try { await ensureBlocks(r.id, r.a, r.b, true); } catch (e) { log('[io] prefetch failed: ' + e.message); } // blocks already stored or on their way cost nothing + } + }; + const batchLane = async () => { + while (nextBatch < batches.length) { + const full = batches[nextBatch++], wanted = new Set(full.filter((it) => untouched(it.id, files[it.id])).map((it) => it.id)); // files the engine already fetched meanwhile are dropped from the answer, not from the request: the request is the same for everybody + try { if (wanted.size) await batchFetch(full, true, wanted); } catch (e) { log('[io] prefetch failed: ' + e.message); } + } + }; + await Promise.all([...Array.from({ length: RUN_LANES }, runLane), ...Array.from({ length: BATCH_LANES }, batchLane)]); + log('[io] boot set prefetched in ' + ((performance.now() - t0) / 1000 | 0) + ' s, ' + (statTotal / 1048576 | 0) + ' MB fetched so far; ' + (netStat.batchCached || 0) + ' of ' + batches.length + ' batches from the host\'s static copies, ' + (netStat.retries || 0) + ' retried requests'); +} + +let flushTimer = 0; +function writeJournal() { + if (!pendingJournal.length || !jh || !sh) return; + const n = pendingJournal.length; + const buf = new DataView(new ArrayBuffer(n * 16)); + pendingJournal.forEach((e, i) => { buf.setUint32(i * 16, e[0], true); buf.setUint32(i * 16 + 4, e[1], true); buf.setUint32(i * 16 + 8, e[2] % 4294967296, true); buf.setUint32(i * 16 + 12, Math.floor(e[2] / 4294967296), true); }); + pendingJournal.length = 0; + try { + sh.flush(); // the data first, then the entries that point at it + jh.write(new Uint8Array(buf.buffer), { at: journalEnd }); + journalEnd += n * 16; + jh.flush(); + } catch (e) { log('[io] journal write failed: ' + e.message); } +} +function scheduleFlush() { + if (flushTimer || !jh) return; + flushTimer = setTimeout(() => { flushTimer = 0; writeJournal(); }, 2000); +} + +// ---- fetching -------------------------------------------------------------------------------------------------------------------------------------------------- +// Streams bytes [start, end] of file f; onChunk(u8, positionInRange) receives the body as it arrives. `low`: speculative (boot set, read-ahead): the browser serves it after everything +// else on the connection (fetch priority), so that a read the engine is blocked on is not queued behind megabytes of it (measured: engine reads waited up to 6.6 s behind 32 prefetch streams). +async function fetchRange(f, start, end, onChunk, whole, low) { + netStat.started++; if (++netStat.active > netStat.maxActive) netStat.maxActive = netStat.active; + try { return await fetchRangeRaw(f, start, end, onChunk, whole, low); } finally { netStat.active--; } +} +async function fetchRangeRaw(f, start, end, onChunk, whole, low) { + const url = base + f.path.split('/').map(encodeURIComponent).join('/') + dataQuery; // ?v=: the same URL always has the same bytes, so the host (and Cloudflare, with a rule for /data/) may cache it for ever + // no-store: the host's own static serving of a range (Apache, host/data/.htaccess) sends no Cache-Control, and Chrome would keep every 206 in its HTTP cache next to this store + const init = { cache: 'no-store', priority: low ? 'low' : 'high' }; + if (!whole) init.headers = { Range: 'bytes=' + start + '-' + end }; // whole: the server sends a compressed copy, the browser decodes it + const res = await fetchRetry(url, init); + if (res.status !== 206 && res.status !== 200) throw new Error('HTTP ' + res.status + ' for ' + f.path); + let skip = res.status === 200 ? start : 0; // a server that ignores Range sends the whole file + const total = end - start + 1; + const reader = res.body.getReader(); + let pos = 0; + for (;;) { + const { done, value } = await reader.read(); + if (done) break; + report(value.length); tally(f, value.length); + let chunk = value; + if (skip) { + const drop = Math.min(skip, chunk.length); + skip -= drop; chunk = chunk.subarray(drop); + } + if (chunk.length > total - pos) chunk = chunk.subarray(0, total - pos); + if (chunk.length) { onChunk(chunk, pos); pos += chunk.length; } + if (pos >= total) { reader.cancel().catch(() => {}); break; } + } + return pos; +} + +// Makes sure blocks first..last of file id are in the store; returns when they are. +// Compressible small files (shader effects, metadata) are fetched whole, compressed by the server: the engine reads them completely anyway. +const COMPRESSIBLE = /\.(fxc|meta|xml|dat|ymt|txt|csv|gfx|json|sps|cfg)$/i, WHOLE_MAX = 8 * 1048576; +function untouched(id, f) { + if (!COMPRESSIBLE.test(f.path) || f.size > WHOLE_MAX) return false; + for (let b = 0, n = Math.ceil(f.size / BS); b < n; b++) if (index.has(id * 1048576 + b) || inflight.has(id * 1048576 + b)) return false; + return true; +} +const SLICE_BLOCKS = 32; // 128 KB: see startRun +async function ensureBlocks(id, first, last, low) { + const f = files[id], waits = []; + last = Math.min(last, Math.ceil(f.size / BS) - 1); // the file may have turned out shorter than the manifest says (shrink) + if (first > last) return; + let runStart = -1; + if (untouched(id, f)) { first = 0; last = Math.ceil(f.size / BS) - 1; } + const whole = first === 0 && last === Math.ceil(f.size / BS) - 1 && untouched(id, f); + const startRun = (a, b, wholeFile) => { + const offset = storeEnd, bytes = (b - a) * BS + blockLen(f, b); // a run is whole blocks of the file: only the last can be short + storeEnd += bytes; + const p = (async () => { + // A read the engine may be blocked on (not low) is cut into slices fetched side by side: one stream through the host moves ~0.15 MB/s after its round trip of ~0.6 s (a 512 KB + // read took 2-5 s, measured), so eight of them in parallel finish in about a second. Speculative runs (low) stay whole: their speed is the number in flight, not their latency. + const slice = wholeFile || low ? b - a + 1 : SLICE_BLOCKS, jobs = []; + for (let s = a; s <= b; s += slice) { + const e = Math.min(b, s + slice - 1), pos = (s - a) * BS, n = (e - s) * BS + blockLen(f, e); + jobs.push(fetchRange(f, s * BS, s * BS + n - 1, (chunk, at) => sh.write(chunk, { at: offset + pos + at }), wholeFile, low).then((g) => [g, n])); + } + let got = 0; + for (const [g, n] of await Promise.all(jobs)) { got += g; if (g < n) break; } // a short slice: the file ends there + indexRun(id, f, a, b, offset, got, bytes); + scheduleFlush(); + })(); + for (let k = a; k <= b; k++) inflight.set(id * 1048576 + k, p); + p.then(() => { for (let k = a; k <= b; k++) inflight.delete(id * 1048576 + k); }, () => { for (let k = a; k <= b; k++) inflight.delete(id * 1048576 + k); }); + waits.push(p); + }; + if (whole) { startRun(0, last, true); await Promise.all(waits); return; } + for (let b = first; b <= last + 1; b++) { + const need = b <= last && !index.has(id * 1048576 + b) && !inflight.has(id * 1048576 + b); + if (need && runStart < 0) runStart = b; + if (runStart >= 0 && (!need || b - runStart + 1 > MAX_RUN)) { + startRun(runStart, b - 1); + runStart = need ? b : -1; + } + if (b <= last && inflight.has(id * 1048576 + b)) waits.push(inflight.get(id * 1048576 + b)); + } + await Promise.all(waits); +} + +const seq = new Map(); // file id -> { end: offset after the last read, ahead: current read-ahead bytes } +let sharedReadFails = false; +// Copies [off, off + len) of file id from the store into the heap at dst. +function readFromStore(id, off, len, dst) { + let done = 0; + while (done < len) { + const pos = off + done, block = Math.floor(pos / BS); + let storeOff = index.get(id * 1048576 + block) + (pos - block * BS), n = Math.min(len - done, (block + 1) * BS - pos); + // merge the following blocks while they are contiguous in the store + for (let b = block + 1; done + n < len; b++) { + const nextOff = index.get(id * 1048576 + b); + if (nextOff === undefined || nextOff !== storeOff + n) break; + n += Math.min(len - done - n, BS); + } + let got; + if (!sharedReadFails) { + try { got = sh.read(HEAPU8.subarray(dst + done, dst + done + n), { at: storeOff }); } + catch (e) { sharedReadFails = true; log('[io] store read into the shared heap failed (' + e.message + '): going through a temporary buffer'); } + } + if (sharedReadFails) { + const tmp = new Uint8Array(n); + got = sh.read(tmp, { at: storeOff }); + HEAPU8.set(tmp, dst + done); + } + if (got !== n) throw new Error('store read returned ' + got + ' of ' + n); + done += n; + } +} + +// ---- without a store --------------------------------------------------------------------------------------------------------------------------------------- +async function getMemBlock(id, block) { + const key = id * 1048576 + block; + const hit = memCache.get(key); + if (hit) { memCache.delete(key); memCache.set(key, hit); return hit; } + let p = inflight.get(key); + if (!p) { + const f = files[id]; + p = (async () => { + let data = new Uint8Array(Math.min(MBS, f.size - block * MBS)); + let got = await fetchRange(f, block * MBS, block * MBS + data.length - 1, (chunk, at) => data.set(chunk, at)); + if (got < data.length) { shrink(f, block * MBS + got); data = data.subarray(0, got); } + memCache.set(key, data); memBytes += data.length; + while (memBytes > 48 * 1048576) { const old = memCache.keys().next().value; memBytes -= memCache.get(old).length; memCache.delete(old); } + return data; + })(); + inflight.set(key, p); + p.then(() => inflight.delete(key), () => inflight.delete(key)); + } + return p; +} + +async function readWithoutStore(id, off, len, dst) { + let done = 0; + while (done < len) { + const pos = off + done, block = Math.floor(pos / MBS); + const data = await getMemBlock(id, block); + const inBlock = pos - block * MBS, n = Math.min(len - done, data.length - inBlock); + if (n <= 0) break; + HEAPU8.set(data.subarray(inBlock, inBlock + n), dst + done); + done += n; + } + return done; +} + +// ---- requests --------------------------------------------------------------------------------------------------------------------------------------------------- +function views() { + if (HEAPU8.length !== mem.buffer.byteLength) { HEAP32 = new Int32Array(mem.buffer); HEAPU8 = new Uint8Array(mem.buffer); } +} + +async function serve(slot) { + views(); + const w = Math.floor(table / 4) + 16 + 16 * slot; // word index of the slot (no bit shift: the memory can grow past 4 GB) + const id = HEAP32[w + 1], off = (HEAP32[w + 2] >>> 0) + (HEAP32[w + 3] >>> 0) * 4294967296; + const dst = (HEAP32[w + 4] >>> 0) + (HEAP32[w + 5] >>> 0) * 4294967296; + let len = HEAP32[w + 6]; + let result = -1; + try { + const f = files[id]; + noteRequest(off, len); netStat.demand++; + if (traceOn) noteTrace(id, off, len); + if (off >= f.size) result = 0; + else { + if (off + len > f.size) len = f.size - off; + if (sh) { + // read-ahead: a read that continues the previous one of this file (a sequential scan) also fetches the next bytes, doubling up to MAX_AHEAD; anything else fetches only what it needs + const st = seq.get(id) || { end: -1, ahead: 0 }; + // radio and talk-radio streams (audio/sfx/RADIO_*.rpf) are read as ~33 KB blocks, one after another and each a network round trip, with nothing queued behind for the + // hints to use: a read that starts at or soon after the end of the previous one (blocks of one track) counts as sequential whatever its size + const radio = /\/RADIO_/i.test(f.path); + const sequential = radio ? (st.end >= 0 && off >= st.end && off - st.end <= 65536) : (off === st.end && len >= AHEAD_MIN_READ); + st.ahead = sequential ? Math.min(MAX_AHEAD, st.ahead ? st.ahead * 2 : FIRST_AHEAD) : 0; + st.end = off + len; + seq.set(id, st); + const lastByte = Math.min(f.size, off + len + st.ahead) - 1; + if (recording) recordTouch(id, off, off + len - 1); + // Only the requested blocks are waited for: the read-ahead is started but the engine's read completes as soon as its own bytes are in (it waited for the read-ahead + // download too). A request whose blocks are all stored is served synchronously, without the async block bookkeeping. + const first = Math.floor(off / BS), needLast = Math.floor((off + len - 1) / BS), aheadLast = Math.floor(lastByte / BS); + let need = null, cold = false; const waitStart = performance.now(); + for (let b = first; b <= needLast; b++) if (!index.has(id * 1048576 + b)) { cold = cold || !inflight.has(id * 1048576 + b); need = need || true; } + if (need) need = ensureBlocks(id, first, needLast); + if (aheadLast > needLast) ensureBlocks(id, needLast + 1, aheadLast, true).catch((e) => log('[io] read-ahead failed: ' + e.message)); + if (need) { + await need; views(); + const waited = performance.now() - waitStart; + netStat.demandMiss++; netStat.demandWaitMs += waited; if (cold) netStat.cold++; + if (waited > 1500 && netStat.slowLogged++ < 60) log('[io] slow read ' + (waited | 0) + ' ms (' + (cold ? 'not hinted' : 'hinted, not finished') + '): ' + f.path + ' at ' + off + ' for ' + len + ' bytes, in flight ' + netStat.active); + } + if (off + len > f.size) len = Math.max(0, f.size - off); // the file turned out shorter than the manifest says (shrink) + readFromStore(id, off, len, dst); + result = len; + } else result = await readWithoutStore(id, off, len, dst); + } + } catch (e) { + log('[io] read failed: ' + e.message); + } + views(); + Atomics.store(HEAP32, w + 7, result); + Atomics.store(HEAP32, w, 2); + Atomics.notify(HEAP32, w, 1); +} + +// Hints (read announcements from the engine, see the protocol above): queued here and fetched into the store; a demand read that arrives meanwhile joins the fetch in flight +// (ensureBlocks), one that arrives after finds its blocks stored. Hints for blocks already stored or on their way cost nothing. Two kinds: reads the engine has queued (normal) and +// look-ahead at objects it has requested but not queued yet (bit 30 of the length: strStreamingInfoManager::WasmAnnounceUpcoming); the first are fetched first, the second only while +// fewer than LOW_PAR are in flight and at low fetch priority, so that the reads the engine blocks on (the audio engine's included) are not queued behind them. +const HINT_PAR = 96, LOW_PAR = 48, HINT_QUEUE_MAX = 2000; // 96 in flight: a small read takes ~1.5 s whatever the link, so the speed is the number in flight (measured: 15 in flight = 1.3 MB/s) +const hintQueue = [], lowQueue = []; +let hintActive = 0, lowActive = 0, hintsSeen = 0, hintsFetched = 0; +function pumpHints() { + for (;;) { + const low = !hintQueue.length; + if (hintActive + lowActive >= HINT_PAR || (low && (!lowQueue.length || lowActive >= LOW_PAR))) return; + const [id, off, len] = (low ? lowQueue : hintQueue).shift(); + const f = files[id]; + if (!f || off >= f.size) continue; + const a = Math.floor(off / BS), b = Math.floor((Math.min(f.size, off + len) - 1) / BS); + let need = false; + for (let k = a; k <= b && !need; k++) need = !index.has(id * 1048576 + k) && !inflight.has(id * 1048576 + k); + if (!need) continue; + if (low) lowActive++; else hintActive++; + hintsFetched++; + ensureBlocks(id, a, b, low).catch(() => {}).finally(() => { if (low) lowActive--; else hintActive--; pumpHints(); }); + } +} +function drainHints(bell) { + const ring = Atomics.load(HEAP32, bell + 2), cap = Atomics.load(HEAP32, bell + 3); + if (!ring || !cap || !sh || noHints) return; // an engine without hints, no store to fetch into, or ?nohints=1 + const head = Atomics.load(HEAP32, bell + 4) >>> 0; + let tail = Atomics.load(HEAP32, bell + 5) >>> 0; + if (((head - tail) >>> 0) > cap) tail = (head - cap) >>> 0; // the engine lapped us: the oldest hints were overwritten + while (tail !== head) { + const e = bell + ring + 4 * (tail % cap); + const raw = Atomics.load(HEAP32, e + 3); + if (!raw) break; // claimed but not written yet: its writer rings the doorbell again when it is + (raw & 0x40000000 ? lowQueue : hintQueue).push([HEAP32[e], (HEAP32[e + 1] >>> 0) + (HEAP32[e + 2] >>> 0) * 4294967296, raw & 0x3fffffff]); + hintsSeen++; + Atomics.store(HEAP32, e + 3, 0); + tail = (tail + 1) >>> 0; + } + Atomics.store(HEAP32, bell + 5, tail); + if (hintQueue.length > HINT_QUEUE_MAX) hintQueue.splice(0, hintQueue.length - HINT_QUEUE_MAX); + if (lowQueue.length > HINT_QUEUE_MAX) lowQueue.splice(0, lowQueue.length - HINT_QUEUE_MAX); + pumpHints(); +} + +async function loop() { + const bell = Math.floor(table / 4); + for (;;) { + views(); + const seen = Atomics.load(HEAP32, bell); // read before the scan: a request posted during the scan changes the doorbell and the wait below returns at once + const n = Atomics.load(HEAP32, bell + 1); + for (let slot = 0; slot < n; slot++) + if (Atomics.compareExchange(HEAP32, bell + 16 + 16 * slot, 1, 3) === 1) + serve(slot); + drainHints(bell); + const r = Atomics.waitAsync(HEAP32, bell, seen); + if (r.async) await r.value; + } +} + +let ready = null; +async function init(m) { + base = m.base; bc = new BroadcastChannel('game-progress'); remoteLog = !!m.log; noHints = !!m.noHints; + const j = await (await fetchRetry(base + 'manifest.json', { cache: 'no-store' })).json(); + files = j.files.map((f) => ({ path: f[0], size: f[1] })); + dataQuery = j.version ? '?v=' + encodeURIComponent(j.version) : ''; dataVersion = j.version ? String(j.version) : ''; + files.forEach((f, i) => pathIndex.set(f.path, i)); + recording = !!m.record; traceOn = !!m.trace; + if (remoteLog) startNetStats(); + if (!m.noStore) await openStore(Number(String(j.version).replace(/\D/g, '')) || 0); + if (sh && m.bootset && !m.record) prefetch(m.bootset); +} + +// The page tells us when it is going away (pagehide): close the handles at once so the next load can take them. +new BroadcastChannel('game-io').onmessage = (ev) => { + if (ev.data !== 'close') return; + if (flushTimer) { clearTimeout(flushTimer); flushTimer = 0; } + writeJournal(); + try { if (sh) sh.close(); if (jh) jh.close(); } catch (e) {} + sh = jh = null; +}; + +// ---- the engine's per-user files (savegames, settings): platform/file/userdata_wasm.cpp posts {userdata: {path, data, mtime}} when a file under /userdata/Documents has settled and +// {userdataDelete: path} when one is gone; they are kept in IndexedDB "gta5-userdata" / store "files" (key: path, value: {data, mtime}) and put back into the engine's +// in-memory /userdata by loader.js before it starts. IndexedDB, not the OPFS store above: that one is exclusive to a single tab and is keyed to the game data's version. +let userdataDb = null; +const openUserdata = () => userdataDb || (userdataDb = new Promise((resolve, reject) => { + const r = indexedDB.open('gta5-userdata', 1); + r.onupgradeneeded = () => r.result.createObjectStore('files'); + r.onsuccess = () => resolve(r.result); + r.onerror = () => { userdataDb = null; reject(r.error); }; +})); +async function userdataWrite(path, record) { + try { + const db = await openUserdata(); + await new Promise((resolve, reject) => { + const t = db.transaction('files', 'readwrite'); + if (record) t.objectStore('files').put(record, path); else t.objectStore('files').delete(path); + t.oncomplete = resolve; + t.onerror = t.onabort = () => reject(t.error); + }); + log('[io] userdata ' + (record ? 'stored ' + path + ' (' + record.data.length + ' bytes)' : 'deleted ' + path)); + } catch (e) { + fetch('/log', { method: 'POST', body: '[io] userdata ' + path + ' NOT stored (the save will be lost when the tab closes): ' + e }).catch(() => {}); // whatever ?log=1 says: a lost save is worth a line + } +} + +self.onmessage = async (ev) => { + const m = ev.data; + if (m.userdata) { userdataWrite(m.userdata.path, { data: m.userdata.data, mtime: m.userdata.mtime }); return; } + if (m.userdataDelete) { userdataWrite(m.userdataDelete, null); return; } + if (m.init) { ready = init(m); return; } // sent by loader.js as soon as the page starts + if (!m.memory) return; + mem = m.memory; HEAP32 = new Int32Array(mem.buffer); HEAPU8 = new Uint8Array(mem.buffer); + table = m.table; + await ready; // the store is open and the manifest is loaded + loop(); +}; +self.postMessage({ loaded: true }); diff --git a/b/8b0b5899ed/loader.js b/b/8b0b5899ed/loader.js new file mode 100644 index 0000000000000000000000000000000000000000..99b75dda3e1215bc8d3f26a4c6b03a0a6cf44c7d --- /dev/null +++ b/b/8b0b5899ed/loader.js @@ -0,0 +1,146 @@ +// Worker that hosts the engine ("main runtime thread" of the Emscripten module). importScripts('game.js') runs the static constructors +// and main() here; the loop blocks this worker, which is fine (nothing else runs on it). game.js also runs in every pthread worker. +'use strict'; +let started = false; +self.onmessage = (ev) => { + if (started) return; + started = true; + const m = ev.data; + // ?cores=N (debug): pretend to be a machine with N logical cores; the engine sizes its worker pools from it + if (m.cores) Object.defineProperty(navigator, 'hardwareConcurrency', { value: m.cores }); + // The GPU worker must be up before the engine blocks this thread: Chrome fetches the script of a worker nested in a worker through + // the parent's event loop. It idles until the engine sends its start message (wgpu_backend.cpp: wgpu_start_worker). + const gq = new URLSearchParams(); // the GPU worker reads its options from its own URL + if (m.slots) gq.set('slots', m.slots); + if (m.syncPipelines) gq.set('syncpipelines', '1'); + if (m.remoteLog) gq.set('log', '1'); // ?log=1 on the page: its log lines go to the dev server (off by default) + if (m.lowMemory) gq.set('low', '1'); // the low-memory profile: its own pipeline seed (wgpu_worker.js loadRecipes) + if (m.noPack) gq.set('nopack', '1'); // ?nopack=1: shaders one by one instead of from the packs (diagnostics) + if (m.shotRt) gq.set('shotrt', '1'); // ?shotrt=1 (with ?shot=N): every render target of one frame after the world is shown goes to the dev server (diagnosis) + if (m.gpuLimits) gq.set('limits', m.gpuLimits); // ?limits=name:value,...: a smaller device (diagnosis of weaker GPUs) + const B = m.base || ''; // the page's URL prefix for everything it loads (index.html BASE): /b/ on the PHP host, empty otherwise + const gpu = new Worker(B + '/wgpu_worker.js' + (gq.toString() ? '?' + gq : '')); + const io = new Worker(B + '/io_worker.js'); + io.postMessage({ init: true, base: self.location.origin + '/data/', noStore: !!m.noStore, record: !!m.record, trace: !!m.trace, log: !!m.remoteLog, noHints: !!m.noHints, bootset: m.lowMemory ? 'bootset_low.json' : 'bootset.json' }); // starts the prefetch of the boot read set at once // HTTP reads of all engine threads (platform/file/httpfs_wasm.cpp); same reason to create it up front + let loaded = 0; + io.onmessage = (e) => { if (e.data.loaded && ++loaded === 2) start(); }; + gpu.onmessage = (e) => { + if (e.data.loaded && ++loaded === 2) start(); + }; + // An overloaded host answers 503/500/429 (2026-10-06): retried up to 8 times with growing, jittered waits (~20 s in all) instead of compiling an error page. + const fetchWasm = async () => { + for (let attempt = 0; ; attempt++) { + let res = null, err = null; + try { res = await fetch(B + '/game.wasm'); } catch (e) { err = e; } + if (res && res.ok) return res; + if (attempt >= 7) { if (res) throw new Error('HTTP ' + res.status + ' for game.wasm'); throw err; } + bc0.postMessage({ label: 'The server is busy, retrying (' + (attempt + 1) + ')' }); + await new Promise((r) => setTimeout(r, Math.min(5000, 300 * 2 ** attempt) * (0.5 + Math.random()))); + } + }; + const bc0 = new BroadcastChannel('game-progress'); + const start = () => { + const bc = new BroadcastChannel('game-progress'); + self.Module = { + // Download game.wasm ourselves to report progress (0-20 %); emscripten hands the compiled module on to the pthread workers. + instantiateWasm: (imports, done) => { + // Streaming compilation: the module compiles while it downloads (no compile wait after the download, no 2 x 63 MB buffer copy, and Chrome can cache the + // compiled code of a fetched response for the next visit). Progress is counted on a clone of the response. Any failure falls back to download-then-compile. + const buffered = async () => { + const res = await fetchWasm(); + const total = +(res.headers.get('X-Uncompressed-Length') || res.headers.get('Content-Length')) || 0; + const reader = res.body.getReader(), chunks = []; + let got = 0; + for (;;) { + const { done: end, value } = await reader.read(); + if (end) break; + chunks.push(value); + got += value.length; + bc.postMessage({ pct: total ? 20 * got / total : 0, label: 'Downloading the engine (' + (got / 1048576 | 0) + ' MB)' }); + } + const bytes = new Uint8Array(got); + let o = 0; + for (const c of chunks) { bytes.set(c, o); o += c.length; } + bc.postMessage({ pct: 20, label: 'Compiling the engine' }); + return WebAssembly.instantiate(bytes, imports); + }; + const streaming = async () => { + const res = await fetchWasm(); + const total = +(res.headers.get('X-Uncompressed-Length') || res.headers.get('Content-Length')) || 0; // the body is decoded while it is read: count decoded bytes + const counter = res.clone().body.getReader(); + (async () => { + let got = 0; + for (;;) { + const { done: end, value } = await counter.read(); + if (end) break; + got += value.length; + bc.postMessage({ pct: total ? 20 * got / total : 0, label: 'Downloading and compiling the engine (' + (got / 1048576 | 0) + ' MB)' }); + } + bc.postMessage({ pct: 20, label: 'Compiling the engine' }); + })().catch(() => {}); + return WebAssembly.instantiateStreaming(res, imports); + }; + (async () => { + let r; + try { r = await streaming(); } + catch (e) { console.warn('streaming instantiation failed (' + e + '): downloading first'); r = await buffered(); } + bc.postMessage({ pct: 22, label: 'Starting the engine' }); + done(r.instance, r.module); + })().catch((e) => { bc.postMessage({ error: 'engine download failed: ' + e }); }); + return {}; + }, + canvas: m.canvas, + arguments: m.args, + wgpuWorker: gpu, + ioWorker: io, + fullConsole: !!m.fullConsole, // ?console=1: every engine line in the browser console (default: errors, warnings, the port's lines) + remoteLog: !!m.remoteLog, // ?log=1: every engine line to the dev server's log (prejs.js; default: none) + wgpuShaderUrl: B + '/shaders', + wgpuShotEvery: m.shotEvery, + keepThreads: m.keepThreads|0, // bit mask of engine thread groups that are NOT skipped (1 replay, 2 net, 4 bink), see ipc_wasm.cpp + mainScriptUrlOrBlob: B + '/game.js' + ((m.fullConsole || m.remoteLog) ? '?' + [m.fullConsole ? 'console=1' : '', m.remoteLog ? 'log=1' : ''].filter(Boolean).join('&') : ''), // pthreads read both from it, and take game.wasm's folder from it + locateFile: (p) => B + '/' + p, + onExit: (code) => { console.error('EXIT ' + code); self.__log('EXIT ' + code); self.__logFlush(); if (code) self.__crash('exit', 'EXIT ' + code); }, + onAbort: (what) => { console.error('ABORT ' + what); self.__log('ABORT ' + what); self.__logFlush(); self.__crash('abort', 'ABORT ' + what); }, + // Savegames and settings kept in IndexedDB by io_worker.js (platform/file/userdata_wasm.cpp sends them): put them back into the in-memory /userdata before the engine looks at it. The run + // dependency holds main() until they are in (or 8 s, so a broken IndexedDB cannot keep the game from starting). Only /userdata/ paths are accepted. + preRun: [() => { + if (typeof FS === 'undefined' || typeof addRunDependency !== 'function' || typeof indexedDB === 'undefined') return; + addRunDependency('userdata'); + let finished = false; + const finish = (note) => { if (finished) return; finished = true; self.__log('[loader] userdata: ' + note); self.__logFlush(); removeRunDependency('userdata'); }; + setTimeout(() => finish('timed out'), 8000); + try { + const r = indexedDB.open('gta5-userdata', 1); + r.onupgradeneeded = () => r.result.createObjectStore('files'); + r.onerror = () => finish('IndexedDB unavailable: ' + r.error); + r.onsuccess = () => { + let n = 0, bytes = 0; + try { + const req = r.result.transaction('files', 'readonly').objectStore('files').openCursor(); + req.onerror = () => finish('read failed: ' + req.error); + req.onsuccess = () => { + const c = req.result; + if (!c) { finish('restored ' + n + ' file(s), ' + bytes + ' bytes'); return; } + const path = String(c.key); + try { + if (path.startsWith('/userdata/') && c.value && c.value.data) { + FS.mkdirTree(path.slice(0, path.lastIndexOf('/'))); + FS.writeFile(path, c.value.data); + FS.utime(path, c.value.mtime, c.value.mtime); + n++; bytes += c.value.data.length; + } + } catch (e) { self.__log('[loader] userdata: ' + path + ' not restored: ' + e); } + c.continue(); + }; + } catch (e) { finish('read failed: ' + e); } + }; + } catch (e) { finish('failed: ' + e); } + }], + }; + // __log/__logFlush come from prejs.js, which only exists once game.js is loaded: note the start line in the console. + console.log('loader: starting engine: ' + m.args.join(' ') + ' (cores ' + m.cores + ')'); + importScripts(B + '/game.js'); + }; + gpu.onerror = (e) => console.error('gpu worker failed to load: ' + e.message); +}; diff --git a/b/8b0b5899ed/shaders/00241e5e1825408e.consts.json b/b/8b0b5899ed/shaders/00241e5e1825408e.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..6640b07fb5c6e23280838b4a36761521d33f22d6 --- /dev/null +++ b/b/8b0b5899ed/shaders/00241e5e1825408e.consts.json @@ -0,0 +1 @@ +[4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/00241e5e1825408e.wgsl b/b/8b0b5899ed/shaders/00241e5e1825408e.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..ec45811e0c15341bca4827873b6ec496b44d1401 --- /dev/null +++ b/b/8b0b5899ed/shaders/00241e5e1825408e.wgsl @@ -0,0 +1,95 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +struct cb73_struct { + tint_symbol : array, 73u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb73_struct; + +@group(1u) @binding(17u) var s1 : sampler; + +@group(1u) @binding(26u) var s10 : sampler; + +@group(1u) @binding(33u) var t1 : texture_2d; + +@group(1u) @binding(42u) var t10 : texture_2d; + +var o0 : vec4; + +struct tint_symbol_2 { + tint_symbol_1 : array, 1u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_2; + +fn main_inner(v1 : vec4) { + r0 = vec4(0.0f, 0.0f, 0.0f, bitcast(v.tint_symbol_1[0i].x)); + loop { + r1.x = bitcast(select(0u, 4294967295u, (1i < bitcast(r0.w)))); + if ((bitcast(r1.x) != 0u)) { + break; + } + r1.y = f32(bitcast(r0.w)); + let v_1 = r0; + r2 = vec4(v_1.xyz, r2.w); + r1.z = bitcast(v.tint_symbol_1[0i].x); + loop { + r1.w = bitcast(select(0u, 4294967295u, (1i < bitcast(r1.z)))); + if ((bitcast(r1.w) != 0u)) { + break; + } + r1.x = f32(bitcast(r1.z)); + let v_2 = fma(cb5_5.tint_symbol[72u].xy, r1.xy, v1.xy); + r1 = vec4(v_2.x, r1.yz, v_2.y); + r3 = textureSample(t10, s10, r1.xwxx.xy); + let v_3 = fma(r3.xyz, vec3(0.11111111193895339966f), r2.xyz); + r2 = vec4(v_3.xyz, r2.w); + r1.z = bitcast((bitcast(r1.z) + 1i)); + } + let v_4 = r2; + r0 = vec4(v_4.xyz, r0.w); + r0.w = bitcast((bitcast(r0.w) + 1i)); + } + r1 = textureSample(t1, s1, vec2()); + let v_5 = (r0.xyz * r1.xxx); + r1 = vec4(v_5.xyz, r1.w); + let v_6 = (r1.xyz * cb5_5.tint_symbol[8u].www); + r1 = vec4(v_6.xyz, r1.w); + r0.w = dot(r1.xyz, vec3(0.3333333134651184082f)); + r0.w = max(r0.w, 0.00000000099999997172f); + let v_7 = -(cb5_5.tint_symbol[7u].xxxx); + r1.x = (r0.w + v_7.x); + r1.x = clamp(((r1.xxxx * cb5_5.tint_symbol[7u].zzzz)).x, 0.0f, 1.0f); + r1.x = (r0.w * r1.x); + let v_8 = bitcast>(select(vec3(), vec3(4294967295u), !((r0.xyz == r0.xyz)))); + r1 = vec4(r1.x, v_8.xyz); + let v_9 = bitcast>((bitcast>(r0.xyz) & vec3(2147483647u))); + r2 = vec4(v_9.xyz, r2.w); + let v_10 = bitcast>(select(vec3(), vec3(4294967295u), (bitcast>(r2.xyz) == vec3(2139095040i)))); + r2 = vec4(v_10.xyz, r2.w); + let v_11 = bitcast>((bitcast>(r1.yzw) | bitcast>(r2.xyz))); + r1 = vec4(r1.x, v_11.xyz); + let v_12 = max(r0.xyz, vec3()); + r0 = vec4(v_12.xyz, r0.w); + r0.w = (r1.x / r0.w); + let v_13 = (r0.www * r0.xyz); + r0 = vec4(v_13.xyz, r0.w); + let v_14 = bitcast>(r1.yzw); + let v_15 = select(r0.xyz, vec3(1000.0f, 0.0f, 1000.0f), (v_14 != vec3())); + o0 = vec4(v_15.xyz, o0.w); + o0.w = 0.0f; +} + +@fragment +fn main(@location(1u) v1 : vec4) -> @location(0u) vec4 { + main_inner(v1); + return o0; +} diff --git a/b/8b0b5899ed/shaders/0030c87264713865.wgsl b/b/8b0b5899ed/shaders/0030c87264713865.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..394ae82da1205fa5fb87fa00c8232023066ae7b0 --- /dev/null +++ b/b/8b0b5899ed/shaders/0030c87264713865.wgsl @@ -0,0 +1,89 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb46_struct { + tint_symbol : array, 46u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb46_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(10u) var cb10_10 : cb23_struct; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(34u) var t2 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4) { + r0.x = v2.w; + r0.y = v3.w; + r0 = textureSample(t2, s2, r0.xyxx.xy); + r0.w = (r0.w * v1.w); + r0.w = (r0.w * cb10_10.tint_symbol_1[22u].x); + r0.w = (r0.w * cb10_10.tint_symbol_1[22u].w); + r1.x = bitcast(select(0u, 4294967295u, (r0.w < cb10_10.tint_symbol_1[22u].y))); + v((bitcast(r1.x) != 0u)); + r1.x = dot(v2.xyz, v2.xyz); + r1.x = inverseSqrt(r1.x); + let v_1 = (r1.xxx * v2.xyz); + r1 = vec4(v_1.xyz, r1.w); + let v_2 = (r0.xyz * v1.xyz); + r0 = vec4(v_2.xyz, r0.w); + let v_3 = -(r0.xyzx); + let v_4 = fma(r0.xyz, v4.xyz, v_3.xyz); + r2 = vec4(v_4.xyz, r2.w); + let v_5 = fma(v4.www, r2.xyz, r0.xyz); + o0 = vec4(v_5.xyz, o0.w); + let v_6 = fma(r1.xyz, vec3(0.5f), vec3(0.5f)); + o1 = vec4(v_6.xyz, o1.w); + r0.x = (v5.x + cb3_3.tint_symbol[45u].w); + r0.x = (r0.x * 0.5f); + r0.y = 0.0f; + let v_7 = sqrt(r0.xy); + o3 = vec4(v_7.xy, o3.zw); + o0.w = r0.w; + o1.w = 1.0f; + o2 = vec4(0.0f, 0.0f, 0.98000001907348632812f, 1.0f); + o3.z = 0.0f; + o3.w = (cb10_10.tint_symbol_1[22u].z * 0.49607843160629272461f); +} + +fn v(v_8 : bool) { + if (v_8) { + discard; + return; + } +} + +struct tint_symbol_2 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4) -> tint_symbol_2 { + main_inner(v1, v2, v3, v4, v5); + return tint_symbol_2(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/0035f4d295d61e54.wgsl b/b/8b0b5899ed/shaders/0035f4d295d61e54.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..6b7778e7ecb45a8b952dbaaf61e7a8247be393db --- /dev/null +++ b/b/8b0b5899ed/shaders/0035f4d295d61e54.wgsl @@ -0,0 +1,188 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +struct cb765_struct { + tint_symbol : array, 765u>, +} + +@group(0u) @binding(4u) var cb4_4 : cb765_struct; + +struct cb16_struct { + tint_symbol_1 : array, 16u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb17_struct { + tint_symbol_2 : array, 17u>, +} + +@group(0u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb18_struct { + tint_symbol_3 : array, 18u>, +} + +@group(0u) @binding(13u) var cb13_13 : cb18_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(0u) @binding(8u) var cb8_8 : cb2_struct; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +var o6 : vec4; + +var o7 : vec4; + +fn main_inner(v0 : vec3, v1 : vec4, v2 : vec4, v3 : vec2, v4 : vec3, v5 : vec4, v6 : vec4, v7 : vec4) { + r0.x = (v7.y * 6.28318500518798828125f); + let v = (cb13_13.tint_symbol_3[1u].zzw * cb8_8.tint_symbol_4[1u].zzw); + r0 = vec4(r0.x, v.xyz); + let v_1 = fma(cb2_2.tint_symbol_2[16u].xxx, r0.yzw, r0.xxx); + r0 = vec4(v_1.xyz, r0.w); + let v_2 = sin(r0.xyzx.xyz); + r0 = vec4(v_2.xyz, r0.w); + let v_3 = (v7.xxz * cb8_8.tint_symbol_4[1u].xxy); + r1 = vec4(v_3.xyz, r1.w); + let v_4 = (r1.xyz * cb13_13.tint_symbol_3[1u].xxy); + r1 = vec4(v_4.xyz, r1.w); + r2 = (v2 * vec4(255.001953125f)); + let v_5 = r2; + let v_6 = max(v_5, vec4(-2147483648.0f)); + r2 = bitcast>(select(select(vec4(v_6), vec4(2147483647i), (v_6 >= vec4(2147483648.0f))), vec4(), !((v_5 == v_5)))); + r2 = bitcast>((bitcast>(r2) * vec4(3i))); + r3 = (v1.yyyy * cb4_4.tint_symbol[bitcast(r2.y)]); + r3 = fma(cb4_4.tint_symbol[bitcast(r2.x)], v1.xxxx, r3); + r3 = fma(cb4_4.tint_symbol[bitcast(r2.z)], v1.zzzz, r3); + r3 = fma(cb4_4.tint_symbol[bitcast(r2.w)], v1.wwww, r3); + r4 = vec4(v0.xyz, r4.w); + r4.w = 1.0f; + r5.x = dot(r3, r4); + r6 = (v1.yyyy * cb4_4.tint_symbol[bitcast((bitcast(r2.y) + 1i))]); + r6 = fma(cb4_4.tint_symbol[bitcast((bitcast(r2.x) + 1i))], v1.xxxx, r6); + r6 = fma(cb4_4.tint_symbol[bitcast((bitcast(r2.z) + 1i))], v1.zzzz, r6); + r6 = fma(cb4_4.tint_symbol[bitcast((bitcast(r2.w) + 1i))], v1.wwww, r6); + r5.y = dot(r6, r4); + r7 = (v1.yyyy * cb4_4.tint_symbol[bitcast((bitcast(r2.y) + 2i))]); + r7 = fma(cb4_4.tint_symbol[bitcast((bitcast(r2.x) + 2i))], v1.xxxx, r7); + r7 = fma(cb4_4.tint_symbol[bitcast((bitcast(r2.z) + 2i))], v1.zzzz, r7); + r2 = fma(cb4_4.tint_symbol[bitcast((bitcast(r2.w) + 2i))], v1.wwww, r7); + r5.z = dot(r2, r4); + let v_7 = fma(r0.xyz, r1.xyz, r5.xyz); + r0 = vec4(v_7.xyz, r0.w); + let v_8 = (r5.yyy * cb1_1.tint_symbol_1[1u].xyz); + r1 = vec4(v_8.xyz, r1.w); + let v_9 = fma(r5.xxx, cb1_1.tint_symbol_1[0u].xyz, r1.xyz); + r1 = vec4(v_9.xyz, r1.w); + let v_10 = fma(r5.zzz, cb1_1.tint_symbol_1[2u].xyz, r1.xyz); + r1 = vec4(v_10.xyz, r1.w); + let v_11 = (r1.xyz + cb1_1.tint_symbol_1[3u].xyz); + r1 = vec4(v_11.xyz, r1.w); + o4 = (((-(r1.xyzx)).xyz + cb1_1.tint_symbol_1[15u].xyz)).xyzx; + r1 = (r0.yyyy * cb1_1.tint_symbol_1[9u]); + r1 = fma(r0.xxxx, cb1_1.tint_symbol_1[8u], r1); + r0 = fma(r0.zzzz, cb1_1.tint_symbol_1[10u], r1); + o0 = (r0 + cb1_1.tint_symbol_1[11u]); + r0.x = bitcast(select(0u, 4294967295u, (cb13_13.tint_symbol_3[0u].w < 0.0f))); + r0.x = select(v0.z, 0.0f, (bitcast(r0.x) != 0u)); + let v_12 = -(cb13_13.tint_symbol_3[0u].xyxx); + let v_13 = (r0.xx + v_12.xy); + r0 = vec4(v_13.xy, r0.zw); + let v_14 = clamp(((r0.xyxx / cb13_13.tint_symbol_3[17u].wwww)).xy, vec2(), vec2(1.0f)); + r0 = vec4(v_14.xy, r0.zw); + r0.z = ((-(cb13_13.tint_symbol_3[0u].zzzz)).z + cb13_13.tint_symbol_3[0u].w); + r0.x = fma(r0.x, r0.z, cb13_13.tint_symbol_3[0u].z); + r0.y = ((-(r0.yyyy)).y + 1.0f); + r0.x = (r0.y * r0.x); + r0.y = (v7.w * cb13_13.tint_symbol_3[2u].w); + let v_15 = abs(r0.xxxx); + o1.z = max(r0.y, v_15.z); + o1 = vec3(v3.xy, o1.xyz.z).xyzx; + r0.x = dot(r6.xyz, v4); + r0.y = dot(r6.xyz, v5.xyz); + let v_16 = (r0.yyy * cb1_1.tint_symbol_1[1u].xyz); + r0 = vec4(r0.x, v_16.xyz); + let v_17 = (r0.xxx * cb1_1.tint_symbol_1[1u].xyz); + r1 = vec4(v_17.xyz, r1.w); + r0.x = dot(r3.xyz, v4); + r1.w = dot(r3.xyz, v5.xyz); + let v_18 = fma(r1.www, cb1_1.tint_symbol_1[0u].xyz, r0.yzw); + r0 = vec4(r0.x, v_18.xyz); + let v_19 = fma(r0.xxx, cb1_1.tint_symbol_1[0u].xyz, r1.xyz); + r1 = vec4(v_19.xyz, r1.w); + r0.x = dot(r2.xyz, v4); + r1.w = dot(r2.xyz, v5.xyz); + let v_20 = fma(r1.www, cb1_1.tint_symbol_1[2u].xyz, r0.yzw); + r0 = vec4(r0.x, v_20.xyz); + let v_21 = fma(r0.xxx, cb1_1.tint_symbol_1[2u].xyz, r1.xyz); + r1 = vec4(v_21.xyz, r1.w); + o2 = r1.xyz.xyzx; + o3 = vec4(v6.xyz, o3.w); + o3.w = 1.0f; + o5 = r0.yzw.xyzx; + let v_22 = (r0.wyz * r1.yzx); + r2 = vec4(v_22.xyz, r2.w); + let v_23 = -(r2.xyzx); + let v_24 = fma(r0.zwy, r1.zxy, v_23.xyz); + r0 = vec4(v_24.xyz, r0.w); + o6 = ((r0.xyz * v5.www)).xyzx; + o7.y = fma((-(v6.yyyy)).y, 25.5f, 1.0f); + r0 = vec4(((v6.yy + vec2(0.52941179275512695312f, -0.03921568766236305237f))).xy, r0.zw); + r0.z = (r0.x * r0.x); + o7.z = (r0.x * r0.z); + r0.x = (r0.y * cb2_2.tint_symbol_2[16u].w); + o7.x = (r0.x * 0.96078431606292724609f); +} + +struct tint_symbol_5 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, + @location(6u) + o6 : vec4, + @location(7u) + o7 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec2, @location(4u) v4 : vec3, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @location(7u) v7 : vec4) -> tint_symbol_5 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v7); + return tint_symbol_5(o0, o1, o2, o3, o4, o5, o6, o7); +} diff --git a/b/8b0b5899ed/shaders/00395a471b59502d.consts.json b/b/8b0b5899ed/shaders/00395a471b59502d.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/00395a471b59502d.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/00395a471b59502d.wgsl b/b/8b0b5899ed/shaders/00395a471b59502d.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..016f0c44e4d6dc9743f2b9f247bc4ab6eb642ff2 --- /dev/null +++ b/b/8b0b5899ed/shaders/00395a471b59502d.wgsl @@ -0,0 +1,810 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb18_struct { + tint_symbol_1 : array, 18u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb18_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb1_struct { + tint_symbol_3 : array, 1u>, +} + +@group(1u) @binding(11u) var cb11_11 : cb1_struct; + +struct cb15_struct { + tint_symbol_4 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v8 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_6 { + tint_symbol_5 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_6; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v6 : vec4) { + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t0, s0, v0.xy.xyxx.xy); + let v_1 = (r0.xyz * cb11_11.tint_symbol_3[0u].xyz); + r0 = vec4(v_1.xyz, r0.w); + r0 = (r0 * v6.xxxw); + let v_2 = (v6.xx * cb2_2.tint_symbol_1[15u].zy); + r1 = vec4(v_2.xy, r1.zw); + r1.z = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).z, 0.0f, 1.0f); + r1.y = (r1.z * r1.y); + let v_3 = (r0.xyz * r0.xyz); + r0 = vec4(v_3.xyz, r0.w); + let v_4 = -(v2.xyzx); + let v_5 = (v_4.xyz + cb1_1.tint_symbol[15u].xyz); + r2 = vec4(v_5.xyz, r2.w); + r1.z = dot(r2.xyz, cb1_1.tint_symbol[14u].xyz); + let v_6 = (v2.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r2 = vec4(v_6.xyz, r2.w); + let v_7 = (r2.yyy * cb6_6.tint_symbol_4[1u].xyz); + r3 = vec4(v_7.xyz, r3.w); + let v_8 = fma(r2.xxx, cb6_6.tint_symbol_4[0u].xyz, r3.xyz); + r3 = vec4(v_8.xyz, r3.w); + let v_9 = fma(r2.zzz, cb6_6.tint_symbol_4[2u].xyz, r3.xyz); + r3 = vec4(v_9.xyz, r3.w); + let v_10 = fma(r3.xyz, cb6_6.tint_symbol_4[4u].xyz, cb6_6.tint_symbol_4[8u].xyz); + r4 = vec4(v_10.xyz, r4.w); + let v_11 = &(x0[0u]); + let v_12 = r4; + *(v_11) = vec4(v_12.xyz, (*(v_11)).w); + let v_13 = fma(r3.xyz, cb6_6.tint_symbol_4[5u].xyz, cb6_6.tint_symbol_4[9u].xyz); + r5 = vec4(v_13.xyz, r5.w); + let v_14 = &(x0[1u]); + let v_15 = r5; + *(v_14) = vec4(v_15.xyz, (*(v_14)).w); + let v_16 = fma(r3.xyz, cb6_6.tint_symbol_4[6u].xyz, cb6_6.tint_symbol_4[10u].xyz); + r6 = vec4(v_16.xyz, r6.w); + let v_17 = &(x0[2u]); + let v_18 = r6; + *(v_17) = vec4(v_18.xyz, (*(v_17)).w); + let v_19 = fma(r3.xyz, cb6_6.tint_symbol_4[7u].xyz, cb6_6.tint_symbol_4[11u].xyz); + r3 = vec4(v_19.xyz, r3.w); + let v_20 = &(x0[3u]); + let v_21 = r3; + *(v_20) = vec4(v_21.xyz, (*(v_20)).w); + let v_22 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_23 = r7; + r7 = vec4(v_23.x, v_22.x, v_23.z, v_22.y); + r1.w = fma((-(cb6_6.tint_symbol_4[14u].zzzz)).w, 1.5f, 1.0f); + r1.w = (r1.w * 0.5f); + let v_24 = abs(r6.yyyy); + r2.w = max(v_24.w, abs(r6.xxxx).w); + r2.w = bitcast(select(0u, 4294967295u, (r2.w < r1.w))); + let v_25 = (bitcast(r2.w) != 0u); + let v_26 = bitcast(v.tint_symbol_5[0i].x); + r2.w = select(bitcast(v.tint_symbol_5[1i].x), v_26, v_25); + let v_27 = abs(r5.yyyy); + r3.z = max(v_27.z, abs(r5.xxxx).z); + r3.z = bitcast(select(0u, 4294967295u, (r3.z < r1.w))); + let v_28 = bitcast(r3.z); + r2.w = select(r2.w, bitcast(v.tint_symbol_5[2i].x), (v_28 != 0u)); + let v_29 = abs(r4.yyyy); + r3.z = max(v_29.z, abs(r4.xxxx).z); + r1.w = bitcast(select(0u, 4294967295u, (r3.z < r1.w))); + let v_30 = bitcast(r1.w); + r1.w = select(r2.w, 0.0f, (v_30 != 0u)); + let v_31 = x0[bitcast(r1.w)]; + r4 = vec4(v_31.xyz, r4.w); + r1.w = f32(bitcast(r1.w)); + r2.w = (r1.w + 0.5f); + r2.w = (r2.w * 0.25f); + r5 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r1.wwww))); + r5 = bitcast>((bitcast>(r5) & vec4(1065353216u))); + r1.w = dot(r5, cb6_6.tint_symbol_4[12u]); + r3.z = dot(r5, cb6_6.tint_symbol_4[13u]); + r5.x = (r4.x + 0.5f); + r5.y = fma(r4.y, 0.25f, r2.w); + r2.w = bitcast(select(0u, 4294967295u, !((r1.w == 0.0f)))); + r1.w = ((-(r1.wwww)).w + r4.z); + let v_32 = dpdx(r5.xyy); + r6 = vec4(v_32.xy, r6.z, v_32.z); + r6.z = dpdx(r1.w); + let v_33 = dpdy(r5.yxy); + r8 = vec4(v_33.xyz, r8.w); + r8.w = dpdy(r1.w); + let v_34 = (r6.yw * r8.yw); + r4 = vec4(v_34.xy, r4.zw); + let v_35 = -(r4.xyxx); + let v_36 = fma(r6.xz, r8.xz, v_35.xy); + r9 = vec4(v_36.xy, r9.zw); + r3.w = (1.0f / r9.x); + r4.x = (r6.z * r8.y); + let v_37 = -(r4.xxxx); + r9.z = fma(r6.x, r8.w, v_37.z); + let v_38 = (r3.ww * r9.yz); + r4 = vec4(v_38.xy, r4.zw); + let v_39 = max(r4.xy, vec2()); + r4 = vec4(v_39.xy, r4.zw); + let v_40 = min(r4.xy, vec2(0.5f)); + r4 = vec4(v_40.xy, r4.zw); + r1.w = fma((-(r3.zzzz)).w, r4.x, r1.w); + r1.w = fma((-(r3.zzzz)).w, r4.y, r1.w); + let v_41 = bitcast(r2.w); + let v_42 = r1.w; + r7.z = select(r4.z, v_42, (v_41 != 0u)); + r5.z = 0.0f; + let v_43 = (r5.xyz + r7.ywz); + r4 = vec4(v_43.xyz, r4.w); + let v_44 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r7 = vec4(v_44.xy, r7.zw); + let v_45 = (r5.xyz + r7.xyz); + r6 = vec4(v_45.xyz, r6.w); + let v_46 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r7 = vec4(v_46.xy, r7.zw); + let v_47 = (r5.xyz + r7.xyz); + r8 = vec4(v_47.xyz, r8.w); + let v_48 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r7 = vec4(v_48.xy, r7.zw); + let v_49 = (r5.xyz + r7.xyz); + r9 = vec4(v_49.xyz, r9.w); + let v_50 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r7 = vec4(v_50.xy, r7.zw); + let v_51 = (r5.xyz + r7.xyz); + r10 = vec4(v_51.xyz, r10.w); + let v_52 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r7 = vec4(v_52.xy, r7.zw); + let v_53 = (r5.xyz + r7.xyz); + r11 = vec4(v_53.xyz, r11.w); + let v_54 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r7 = vec4(v_54.xy, r7.zw); + let v_55 = (r5.xyz + r7.xyz); + r12 = vec4(v_55.xyz, r12.w); + let v_56 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r7 = vec4(v_56.xy, r7.zw); + let v_57 = (r5.xyz + r7.xyz); + r13 = vec4(v_57.xyz, r13.w); + let v_58 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r7 = vec4(v_58.xy, r7.zw); + let v_59 = (r5.xyz + r7.xyz); + r14 = vec4(v_59.xyz, r14.w); + let v_60 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r7 = vec4(v_60.xy, r7.zw); + let v_61 = (r5.xyz + r7.xyz); + r15 = vec4(v_61.xyz, r15.w); + let v_62 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r7 = vec4(v_62.xy, r7.zw); + let v_63 = (r5.xyz + r7.xyz); + r16 = vec4(v_63.xyz, r16.w); + let v_64 = (cb6_6.tint_symbol_4[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r7 = vec4(v_64.xy, r7.zw); + let v_65 = (r5.xyz + r7.xyz); + r17 = vec4(v_65.xyz, r17.w); + let v_66 = (cb6_6.tint_symbol_4[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r7 = vec4(v_66.xy, r7.zw); + let v_67 = (r5.xyz + r7.xyz); + r18 = vec4(v_67.xyz, r18.w); + let v_68 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r7 = vec4(v_68.xy, r7.zw); + let v_69 = (r5.xyz + r7.xyz); + r19 = vec4(v_69.xyz, r19.w); + let v_70 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r7 = vec4(v_70.xy, r7.zw); + let v_71 = (r5.xyz + r7.xyz); + r20 = vec4(v_71.xyz, r20.w); + let v_72 = (cb6_6.tint_symbol_4[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r7 = vec4(v_72.xy, r7.zw); + let v_73 = (r5.xyz + r7.xyz); + r5 = vec4(v_73.xyz, r5.w); + let v_74 = r4.xyxx; + r4.x = textureSampleCompareLevel(t15, s15, v_74.xy, r4.z); + let v_75 = r6.xyxx; + r4.y = textureSampleCompareLevel(t15, s15, v_75.xy, r6.z); + let v_76 = r8.xyxx; + r4.z = textureSampleCompareLevel(t15, s15, v_76.xy, r8.z); + let v_77 = r9.xyxx; + r4.w = textureSampleCompareLevel(t15, s15, v_77.xy, r9.z); + let v_78 = r10.xyxx; + r6.x = textureSampleCompareLevel(t15, s15, v_78.xy, r10.z); + let v_79 = r11.xyxx; + r6.y = textureSampleCompareLevel(t15, s15, v_79.xy, r11.z); + let v_80 = r12.xyxx; + r6.z = textureSampleCompareLevel(t15, s15, v_80.xy, r12.z); + let v_81 = r13.xyxx; + r6.w = textureSampleCompareLevel(t15, s15, v_81.xy, r13.z); + let v_82 = r14.xyxx; + r7.x = textureSampleCompareLevel(t15, s15, v_82.xy, r14.z); + let v_83 = r15.xyxx; + r7.y = textureSampleCompareLevel(t15, s15, v_83.xy, r15.z); + let v_84 = r16.xyxx; + r7.z = textureSampleCompareLevel(t15, s15, v_84.xy, r16.z); + let v_85 = r17.xyxx; + r7.w = textureSampleCompareLevel(t15, s15, v_85.xy, r17.z); + let v_86 = r18.xyxx; + r8.x = textureSampleCompareLevel(t15, s15, v_86.xy, r18.z); + let v_87 = r19.xyxx; + r8.y = textureSampleCompareLevel(t15, s15, v_87.xy, r19.z); + let v_88 = r20.xyxx; + r8.z = textureSampleCompareLevel(t15, s15, v_88.xy, r20.z); + let v_89 = r5.xyxx; + r8.w = textureSampleCompareLevel(t15, s15, v_89.xy, r5.z); + r4 = (r4 + r6); + r4 = (r7 + r4); + r4 = (r8 + r4); + r1.w = dot(r4, vec4(1.0f)); + r1.z = clamp(fma(r1.zzzz, cb6_6.tint_symbol_4[0u].wwww, cb6_6.tint_symbol_4[1u].wwww).z, 0.0f, 1.0f); + let v_90 = abs(r3.yyyy); + r2.w = max(v_90.w, abs(r3.xxxx).w); + r2.w = clamp(fma(r2.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = (r2.w * r1.z); + r1.z = fma(r1.w, 0.0625f, r1.z); + let v_91 = (r1.xyz * r1.xyz); + r1 = vec4(v_91.xyz, r1.w); + r1.z = min(r1.z, 1.0f); + r1.w = clamp(fma(v2.zzzz, cb6_6.tint_symbol_4[3u].xxxx, cb6_6.tint_symbol_4[3u].yyyy).w, 0.0f, 1.0f); + r1.w = sqrt(r1.w); + r1.w = (r1.w * cb6_6.tint_symbol_4[3u].z); + let v_92 = -(r1.zzzz); + r1.z = fma(r1.w, v_92.z, r1.z); + let v_93 = dot(v1.xyz, (-(cb3_3.tint_symbol_2[0u].xyzx)).xyz); + r1.w = clamp(vec4(v_93, v_93, v_93, v_93).w, 0.0f, 1.0f); + let v_94 = (r0.xyz * r1.www); + r3 = vec4(v_94.xyz, r3.w); + let v_95 = (r3.xyz * cb3_3.tint_symbol_2[1u].xyz); + r3 = vec4(v_95.xyz, r3.w); + r1.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r1.w) != 0u)) { + r4 = vec4(vec3(), r4.w); + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_96 = (v_4.xyz + cb3_3.tint_symbol_2[3u].xyz); + r4 = vec4(v_96.xyz, r4.w); + let v_97 = (v2.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r5 = vec4(v_97.xyz, r5.w); + r3.w = dot(r5.xyz, cb3_3.tint_symbol_2[11u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[19u].w); + let v_98 = fma(cb3_3.tint_symbol_2[11u].xyz, r3.www, cb3_3.tint_symbol_2[3u].xyz); + r5 = vec4(v_98.xyz, r5.w); + let v_99 = (r5.xyz + v_4.xyz); + r5 = vec4(v_99.xyz, r5.w); + let v_100 = bitcast>(r2.www); + let v_101 = r4.xyz; + let v_102 = select(r5.xyz, v_101, (v_100 != vec3())); + r4 = vec4(v_102.xyz, r4.w); + r2.w = dot(r4.xyz, r4.xyz); + let v_103 = (r4.xyz + vec3(0.00000099999999747524f)); + r4 = vec4(v_103.xyz, r4.w); + r3.w = dot(r4.xyz, r4.xyz); + r3.w = inverseSqrt(r3.w); + let v_104 = (r3.www * r4.xyz); + r4 = vec4(v_104.xyz, r4.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[11u].w); + r2.w = (r2.w / r3.w); + let v_105 = -(cb3_3.tint_symbol_2[11u].xyzx); + r3.w = dot(r4.xyz, v_105.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_106 = dot(r4.xyz, v1.xyz); + r4.x = clamp(vec4(v_106, v_106, v_106, v_106).x, 0.0f, 1.0f); + r3.w = (r3.w * r4.x); + r2.w = (r2.w * r3.w); + let v_107 = (r2.www * cb3_3.tint_symbol_2[19u].xyz); + r4 = vec4(v_107.xyz, r4.w); + let v_108 = (r0.xyz * r4.xyz); + r4 = vec4(v_108.xyz, r4.w); + } + r2.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r2.w) != 0u)) { + r3.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r2.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + let v_109 = bitcast(r3.w); + let v_110 = r2.w; + r1.w = select(r1.w, v_110, (v_109 != 0u)); + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_111 = (v_4.xyz + cb3_3.tint_symbol_2[4u].xyz); + r5 = vec4(v_111.xyz, r5.w); + let v_112 = (v2.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r6 = vec4(v_112.xyz, r6.w); + r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[12u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[20u].w); + let v_113 = fma(cb3_3.tint_symbol_2[12u].xyz, r3.www, cb3_3.tint_symbol_2[4u].xyz); + r6 = vec4(v_113.xyz, r6.w); + let v_114 = (r6.xyz + v_4.xyz); + r6 = vec4(v_114.xyz, r6.w); + let v_115 = bitcast>(r2.www); + let v_116 = r5.xyz; + let v_117 = select(r6.xyz, v_116, (v_115 != vec3())); + r5 = vec4(v_117.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + let v_118 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_118.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_119 = (r3.www * r5.xyz); + r5 = vec4(v_119.xyz, r5.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[12u].w); + r2.w = (r2.w / r3.w); + let v_120 = -(cb3_3.tint_symbol_2[12u].xyzx); + r3.w = dot(r5.xyz, v_120.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_121 = dot(r5.xyz, v1.xyz); + r4.w = clamp(vec4(v_121, v_121, v_121, v_121).w, 0.0f, 1.0f); + r3.w = (r3.w * r4.w); + r2.w = (r2.w * r3.w); + let v_122 = (r2.www * cb3_3.tint_symbol_2[20u].xyz); + r5 = vec4(v_122.xyz, r5.w); + let v_123 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_123.xyz, r4.w); + } + } else { + r1.w = bitcast(v.tint_symbol_5[3i].x); + } + if ((bitcast(r1.w) != 0u)) { + r1.w = bitcast(v.tint_symbol_5[3i].x); + } else { + r2.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_124 = (v_4.xyz + cb3_3.tint_symbol_2[5u].xyz); + r5 = vec4(v_124.xyz, r5.w); + let v_125 = (v2.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r6 = vec4(v_125.xyz, r6.w); + r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[13u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[21u].w); + let v_126 = fma(cb3_3.tint_symbol_2[13u].xyz, r3.www, cb3_3.tint_symbol_2[5u].xyz); + r6 = vec4(v_126.xyz, r6.w); + let v_127 = (r6.xyz + v_4.xyz); + r6 = vec4(v_127.xyz, r6.w); + let v_128 = bitcast>(r2.www); + let v_129 = r5.xyz; + let v_130 = select(r6.xyz, v_129, (v_128 != vec3())); + r5 = vec4(v_130.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + let v_131 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_131.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_132 = (r3.www * r5.xyz); + r5 = vec4(v_132.xyz, r5.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[13u].w); + r2.w = (r2.w / r3.w); + let v_133 = -(cb3_3.tint_symbol_2[13u].xyzx); + r3.w = dot(r5.xyz, v_133.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_134 = dot(r5.xyz, v1.xyz); + r4.w = clamp(vec4(v_134, v_134, v_134, v_134).w, 0.0f, 1.0f); + r3.w = (r3.w * r4.w); + r2.w = (r2.w * r3.w); + let v_135 = (r2.www * cb3_3.tint_symbol_2[21u].xyz); + r5 = vec4(v_135.xyz, r5.w); + let v_136 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_136.xyz, r4.w); + } + } + if ((bitcast(r1.w) != 0u)) { + r1.w = bitcast(v.tint_symbol_5[3i].x); + } else { + r2.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_137 = (v_4.xyz + cb3_3.tint_symbol_2[6u].xyz); + r5 = vec4(v_137.xyz, r5.w); + let v_138 = (v2.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r6 = vec4(v_138.xyz, r6.w); + r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[14u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[22u].w); + let v_139 = fma(cb3_3.tint_symbol_2[14u].xyz, r3.www, cb3_3.tint_symbol_2[6u].xyz); + r6 = vec4(v_139.xyz, r6.w); + let v_140 = (r6.xyz + v_4.xyz); + r6 = vec4(v_140.xyz, r6.w); + let v_141 = bitcast>(r2.www); + let v_142 = r5.xyz; + let v_143 = select(r6.xyz, v_142, (v_141 != vec3())); + r5 = vec4(v_143.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + let v_144 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_144.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_145 = (r3.www * r5.xyz); + r5 = vec4(v_145.xyz, r5.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[14u].w); + r2.w = (r2.w / r3.w); + let v_146 = -(cb3_3.tint_symbol_2[14u].xyzx); + r3.w = dot(r5.xyz, v_146.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_147 = dot(r5.xyz, v1.xyz); + r4.w = clamp(vec4(v_147, v_147, v_147, v_147).w, 0.0f, 1.0f); + r3.w = (r3.w * r4.w); + r2.w = (r2.w * r3.w); + let v_148 = (r2.www * cb3_3.tint_symbol_2[22u].xyz); + r5 = vec4(v_148.xyz, r5.w); + let v_149 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_149.xyz, r4.w); + } + } + if ((bitcast(r1.w) != 0u)) { + r1.w = bitcast(v.tint_symbol_5[3i].x); + } else { + r2.w = bitcast(select(0u, 4294967295u, (4i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f))); + let v_150 = (v_4.xyz + cb3_3.tint_symbol_2[7u].xyz); + r5 = vec4(v_150.xyz, r5.w); + let v_151 = (v2.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz); + r6 = vec4(v_151.xyz, r6.w); + r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[15u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[23u].w); + let v_152 = fma(cb3_3.tint_symbol_2[15u].xyz, r3.www, cb3_3.tint_symbol_2[7u].xyz); + r6 = vec4(v_152.xyz, r6.w); + let v_153 = (r6.xyz + v_4.xyz); + r6 = vec4(v_153.xyz, r6.w); + let v_154 = bitcast>(r2.www); + let v_155 = r5.xyz; + let v_156 = select(r6.xyz, v_155, (v_154 != vec3())); + r5 = vec4(v_156.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + let v_157 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_157.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_158 = (r3.www * r5.xyz); + r5 = vec4(v_158.xyz, r5.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[7u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[15u].w); + r2.w = (r2.w / r3.w); + let v_159 = -(cb3_3.tint_symbol_2[15u].xyzx); + r3.w = dot(r5.xyz, v_159.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f); + let v_160 = dot(r5.xyz, v1.xyz); + r4.w = clamp(vec4(v_160, v_160, v_160, v_160).w, 0.0f, 1.0f); + r3.w = (r3.w * r4.w); + r2.w = (r2.w * r3.w); + let v_161 = (r2.www * cb3_3.tint_symbol_2[23u].xyz); + r5 = vec4(v_161.xyz, r5.w); + let v_162 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_162.xyz, r4.w); + } + } + if ((bitcast(r1.w) != 0u)) { + r1.w = bitcast(v.tint_symbol_5[3i].x); + } else { + r2.w = bitcast(select(0u, 4294967295u, (5i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f))); + let v_163 = (v_4.xyz + cb3_3.tint_symbol_2[8u].xyz); + r5 = vec4(v_163.xyz, r5.w); + let v_164 = (v2.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz); + r6 = vec4(v_164.xyz, r6.w); + r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[16u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[24u].w); + let v_165 = fma(cb3_3.tint_symbol_2[16u].xyz, r3.www, cb3_3.tint_symbol_2[8u].xyz); + r6 = vec4(v_165.xyz, r6.w); + let v_166 = (r6.xyz + v_4.xyz); + r6 = vec4(v_166.xyz, r6.w); + let v_167 = bitcast>(r2.www); + let v_168 = r5.xyz; + let v_169 = select(r6.xyz, v_168, (v_167 != vec3())); + r5 = vec4(v_169.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + let v_170 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_170.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_171 = (r3.www * r5.xyz); + r5 = vec4(v_171.xyz, r5.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[8u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[16u].w); + r2.w = (r2.w / r3.w); + let v_172 = -(cb3_3.tint_symbol_2[16u].xyzx); + r3.w = dot(r5.xyz, v_172.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f); + let v_173 = dot(r5.xyz, v1.xyz); + r4.w = clamp(vec4(v_173, v_173, v_173, v_173).w, 0.0f, 1.0f); + r3.w = (r3.w * r4.w); + r2.w = (r2.w * r3.w); + let v_174 = (r2.www * cb3_3.tint_symbol_2[24u].xyz); + r5 = vec4(v_174.xyz, r5.w); + let v_175 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_175.xyz, r4.w); + } + } + if ((bitcast(r1.w) != 0u)) { + r1.w = bitcast(v.tint_symbol_5[3i].x); + } else { + r2.w = bitcast(select(0u, 4294967295u, (6i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f))); + let v_176 = (v_4.xyz + cb3_3.tint_symbol_2[9u].xyz); + r5 = vec4(v_176.xyz, r5.w); + let v_177 = (v2.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz); + r6 = vec4(v_177.xyz, r6.w); + r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[17u].xyz); + r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f); + r3.w = (r3.w * cb3_3.tint_symbol_2[25u].w); + let v_178 = fma(cb3_3.tint_symbol_2[17u].xyz, r3.www, cb3_3.tint_symbol_2[9u].xyz); + r6 = vec4(v_178.xyz, r6.w); + let v_179 = (r6.xyz + v_4.xyz); + r6 = vec4(v_179.xyz, r6.w); + let v_180 = bitcast>(r2.www); + let v_181 = r5.xyz; + let v_182 = select(r6.xyz, v_181, (v_180 != vec3())); + r5 = vec4(v_182.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + let v_183 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_183.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_184 = (r3.www * r5.xyz); + r5 = vec4(v_184.xyz, r5.w); + r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[9u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r3.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f); + r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[17u].w); + r2.w = (r2.w / r3.w); + let v_185 = -(cb3_3.tint_symbol_2[17u].xyzx); + r3.w = dot(r5.xyz, v_185.xyz); + r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f); + let v_186 = dot(r5.xyz, v1.xyz); + r4.w = clamp(vec4(v_186, v_186, v_186, v_186).w, 0.0f, 1.0f); + r3.w = (r3.w * r4.w); + r2.w = (r2.w * r3.w); + let v_187 = (r2.www * cb3_3.tint_symbol_2[25u].xyz); + r5 = vec4(v_187.xyz, r5.w); + let v_188 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_188.xyz, r4.w); + } + } + if ((bitcast(r1.w) != 0u)) { + } else { + r2.w = bitcast(select(0u, 4294967295u, (7i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.w))); + if ((bitcast(r1.w) != 0u)) { + } else { + r1.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f))); + let v_189 = (v_4.xyz + cb3_3.tint_symbol_2[10u].xyz); + r5 = vec4(v_189.xyz, r5.w); + let v_190 = (v2.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz); + r6 = vec4(v_190.xyz, r6.w); + r2.w = dot(r6.xyz, cb3_3.tint_symbol_2[18u].xyz); + r2.w = clamp(((r2.wwww / cb3_3.tint_symbol_2[26u].wwww)).w, 0.0f, 1.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[26u].w); + let v_191 = fma(cb3_3.tint_symbol_2[18u].xyz, r2.www, cb3_3.tint_symbol_2[10u].xyz); + r6 = vec4(v_191.xyz, r6.w); + let v_192 = (r6.xyz + v_4.xyz); + r6 = vec4(v_192.xyz, r6.w); + let v_193 = bitcast>(r1.www); + let v_194 = r5.xyz; + let v_195 = select(r6.xyz, v_194, (v_193 != vec3())); + r5 = vec4(v_195.xyz, r5.w); + r1.w = dot(r5.xyz, r5.xyz); + let v_196 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_196.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + r2.w = inverseSqrt(r2.w); + let v_197 = (r2.www * r5.xyz); + r5 = vec4(v_197.xyz, r5.w); + r1.w = clamp(fma(-(r1.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r2.w = ((-(cb3_3.tint_symbol_2[18u].wwww)).w + 1.0f); + r2.w = fma(r2.w, r1.w, cb3_3.tint_symbol_2[18u].w); + r1.w = (r1.w / r2.w); + let v_198 = -(cb3_3.tint_symbol_2[18u].xyzx); + r2.w = dot(r5.xyz, v_198.xyz); + r2.w = clamp(fma(r2.wwww, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).w, 0.0f, 1.0f); + let v_199 = dot(r5.xyz, v1.xyz); + r3.w = clamp(vec4(v_199, v_199, v_199, v_199).w, 0.0f, 1.0f); + r2.w = (r2.w * r3.w); + r1.w = (r1.w * r2.w); + let v_200 = (r1.www * cb3_3.tint_symbol_2[26u].xyz); + r5 = vec4(v_200.xyz, r5.w); + let v_201 = fma(r5.xyz, r0.xyz, r4.xyz); + r4 = vec4(v_201.xyz, r4.w); + } + } + let v_202 = fma(r3.xyz, r1.zzz, r4.xyz); + r3 = vec4(v_202.xyz, r3.w); + r1.z = (v1.z + cb3_3.tint_symbol_2[43u].w); + r1.z = (r1.z * cb3_3.tint_symbol_2[44u].w); + r1.z = max(r1.z, 0.0f); + let v_203 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.zzz, cb3_3.tint_symbol_2[48u].xyz); + r4 = vec4(v_203.xyz, r4.w); + r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_204 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.zzz, cb3_3.tint_symbol_2[46u].xyz); + r5 = vec4(v_204.xyz, r5.w); + let v_205 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz); + r5 = vec4(v_205.xyz, r5.w); + let v_206 = fma(r4.xyz, r1.www, r5.xyz); + r4 = vec4(v_206.xyz, r4.w); + let v_207 = (r1.yyy * r4.xyz); + r4 = vec4(v_207.xyz, r4.w); + let v_208 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.zzz, cb3_3.tint_symbol_2[44u].xyz); + r1 = vec4(r1.x, v_208.xyz); + r5.x = cb3_3.tint_symbol_2[46u].w; + r5.y = cb3_3.tint_symbol_2[47u].w; + r5.z = cb3_3.tint_symbol_2[48u].w; + let v_209 = dot(r5.xyz, v1.xyz); + r2.w = clamp(vec4(v_209, v_209, v_209, v_209).w, 0.0f, 1.0f); + let v_210 = fma(cb3_3.tint_symbol_2[49u].xyz, r2.www, r1.yzw); + r1 = vec4(r1.x, v_210.xyz); + let v_211 = fma(r1.yzw, r1.xxx, r4.xyz); + r1 = vec4(v_211.xyz, r1.w); + let v_212 = fma(r1.xyz, r0.xyz, r3.xyz); + r0 = vec4(v_212.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + r0.w = dot(r2.xyz, r2.xyz); + r1.x = sqrt(r0.w); + let v_213 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_213.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r2.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_214 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_214 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_215 = (r0.www * r2.xyz); + r2 = vec4(v_215.xyz, r2.w); + let v_216 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_216, v_216, v_216, v_216).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_217 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_217, v_217, v_217, v_217).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_218 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_218.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_219 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_219.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_220 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_220.xyz, r2.w); + let v_221 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_221.xyz, r2.w); + let v_222 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_222.xyz, r3.w); + let v_223 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_223.xyz, r2.w); + let v_224 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_225 = (r2.xyz + v_224.xyz); + r2 = vec4(v_225.xyz, r2.w); + let v_226 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_226.xyz, r2.w); + r3.x = ((-(r2.xxxx)).x + cb3_3.tint_symbol_2[55u].w); + r3.y = ((-(r2.yyyy)).y + cb3_3.tint_symbol_2[56u].w); + r3.z = ((-(r2.zzzz)).z + cb3_3.tint_symbol_2[57u].w); + let v_227 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_227.xy, r1.z, v_227.z); + let v_228 = ((-(r0.xyxz)).xyw + r1.xyw); + r1 = vec4(v_228.xy, r1.z, v_228.z); + let v_229 = fma(r1.zzz, r1.xyw, r0.xyz); + r0 = vec4(v_229.xyz, r0.w); + let v_230 = (r0.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_230.xyz, o0.w); +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(6u) v6 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v6); + return o0; +} diff --git a/b/8b0b5899ed/shaders/003e341f763296f0.wgsl b/b/8b0b5899ed/shaders/003e341f763296f0.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..f07ccdd876ab1b701612c4eb984efd50a969900f --- /dev/null +++ b/b/8b0b5899ed/shaders/003e341f763296f0.wgsl @@ -0,0 +1,106 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb17_struct { + tint_symbol_1 : array, 17u>, +} + +@group(0u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb50_struct { + tint_symbol_2 : array, 50u>, +} + +@group(0u) @binding(3u) var cb3_3 : cb50_struct; + +struct cb1_struct { + tint_symbol_3 : array, 1u>, +} + +@group(0u) @binding(13u) var cb13_13 : cb1_struct; + +@group(0u) @binding(18u) var s2 : sampler; + +@group(0u) @binding(34u) var t2 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +fn main_inner(v0 : vec3, v1 : vec4, v2 : vec2, v6 : vec3) { + r0 = (v0.yyyy * cb1_1.tint_symbol[9u]); + r0 = fma(v0.xxxx, cb1_1.tint_symbol[8u], r0); + r0 = fma(v0.zzzz, cb1_1.tint_symbol[10u], r0); + o0 = (r0 + cb1_1.tint_symbol[11u]); + let v = (v0.yyy * cb1_1.tint_symbol[1u].xyz); + r0 = vec4(v.xyz, r0.w); + let v_1 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz); + r0 = vec4(v_1.xyz, r0.w); + let v_2 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz); + r0 = vec4(v_2.xyz, r0.w); + let v_3 = (r0.xyz + cb1_1.tint_symbol[3u].xyz); + r0 = vec4(v_3.xyz, r0.w); + let v_4 = ((-(r0.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r1 = vec4(v_4.xyz, r1.w); + o5 = r0.xyz.xyzx; + r0.x = dot(r1.xyz, r1.xyz); + r0.x = (r0.x * 0.00000399999998990097f); + r0.x = min(r0.x, 1.0f); + r0.y = ((-(r0.xxxx)).y + 1.0f); + let v_5 = -(cb2_2.tint_symbol_1[16u].zzzz); + let v_6 = clamp(((r0.xyxx + v_5)).xy, vec2(), vec2(1.0f)); + r0 = vec4(v_6.xy, r0.zw); + r0.z = (cb3_3.tint_symbol_2[49u].w + -1.0f); + let v_7 = fma(r0.xy, r0.zz, vec2(1.0f)); + r0 = vec4(v_7.xy, r0.zw); + let v_8 = clamp(((r0.xyxx * v1.xyxx)).xy, vec2(), vec2(1.0f)); + o1 = vec4(v_8.xy, o1.zw); + o1 = vec4(o1.xy, v1.zw); + r0.x = v1.z; + r0.y = cb13_13.tint_symbol_3[0u].x; + o2 = textureSampleLevel(t2, s2, r0.xyxx.xy, 0.0f); + o3 = v2.xyxy; + let v_9 = (v6.yyy * cb1_1.tint_symbol[1u].xyz); + r0 = vec4(v_9.xyz, r0.w); + let v_10 = fma(v6.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz); + r0 = vec4(v_10.xyz, r0.w); + o4 = fma(v6.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz).xyzx; +} + +struct tint_symbol_4 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(2u) v2 : vec2, @location(6u) v6 : vec3) -> tint_symbol_4 { + main_inner(v0, v1, v2, v6); + return tint_symbol_4(o0, o1, o2, o3, o4, o5); +} diff --git a/b/8b0b5899ed/shaders/00434aea0a2de164.wgsl b/b/8b0b5899ed/shaders/00434aea0a2de164.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..a7401632e40ccd70f2485de9371e4804665ee00e --- /dev/null +++ b/b/8b0b5899ed/shaders/00434aea0a2de164.wgsl @@ -0,0 +1,189 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +struct cb17_struct { + tint_symbol : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb46_struct { + tint_symbol_1 : array, 46u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb46_struct; + +struct cb5_struct { + tint_symbol_2 : array, 5u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb5_struct; + +struct cb3_struct { + tint_symbol_3 : array, 3u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb3_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(36u) var t4 : texture_2d; + +var icb0 : array, 4u> = array, 4u>(vec4(1.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 1.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 1.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 1.0f)); + +var v0 : vec4; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4) { + var v_1 : vec4 = v; + v_1.w = (1.0f / v.w); + v0 = v_1; + let v_2 = max(v0.xy, vec2()); + let v_3 = bitcast>(select(vec2(v_2), vec2(4294967295u), (v_2 >= vec2(4294967296.0f)))); + r0 = vec4(v_3.xy, r0.zw); + let v_4 = bitcast>((bitcast>(r0.xy) & vec2(1u))); + r0 = vec4(v_4.xy, r0.zw); + r0.y = bitcast((bitcast(r0.y) << 1u)); + r0.x = bitcast((bitcast(r0.x) + bitcast(r0.y))); + r0.x = dot(cb2_2.tint_symbol[0u], icb0[bitcast(r0.x)]); + r0.x = bitcast(select(0u, 4294967295u, (r0.x < 1.0f))); + v_5((bitcast(r0.x) != 0u)); + r0 = textureSample(t0, s0, v3.xy.xyxx.xy); + r1.x = (r0.w * cb2_2.tint_symbol[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_2[4u].x >= r1.x))); + v_5((bitcast(r1.x) != 0u)); + r1 = textureSample(t3, s3, v3.xy.xyxx.xy); + let v_6 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_6.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_3[1u].w, 0.00100000004749745131f); + let v_7 = (r1.ww * r1.xy); + r1 = vec4(v_7.xy, r1.zw); + let v_8 = (r1.yyy * v6.xyz); + r2 = vec4(v_8.xyz, r2.w); + let v_9 = fma(r1.xxx, v5.xyz, r2.xyz); + r1 = vec4(v_9.xy, r1.z, v_9.z); + let v_10 = fma(r1.zzz, v4.xyz, r1.xyw); + r1 = vec4(v_10.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_11 = (r1.www * r1.xyz); + r2 = vec4(v_11.xyz, r2.w); + r3 = textureSample(t4, s4, v3.xy.xyxx.xy); + let v_12 = (r3.xy * r3.xy); + r3 = vec4(v_12.xy, r3.zw); + r1.x = dot(r3.xyz, cb12_12.tint_symbol_3[1u].xyz); + r3.x = (r1.x * cb12_12.tint_symbol_3[0u].z); + r1.y = (r3.w * cb12_12.tint_symbol_3[0u].y); + let v_13 = (r0.xyz * v2.xyz); + r0 = vec4(v_13.xyz, r0.w); + r0.w = (r0.w * v1.w); + let v_14 = (v1.xy * cb2_2.tint_symbol[15u].zy); + let v_15 = r4; + r4 = vec4(v_15.x, v_14.xy, v_15.w); + o0.w = (r0.w * cb2_2.tint_symbol[15u].x); + let v_16 = fma(r2.xyz, vec3(0.5f), vec3(0.5f)); + r2 = vec4(v_16.xyz, r2.w); + let v_17 = (r2.xyz * vec3(256.0f)); + r5 = vec4(v_17.xyz, r5.w); + let v_18 = floor(r5.xyz); + r5 = vec4(v_18.xyz, r5.w); + let v_19 = -(r5.xyzx); + let v_20 = fma(r2.xyz, vec3(256.0f), v_19.xyz); + r2 = vec4(v_20.xyz, r2.w); + let v_21 = (r2.xyz * vec3(8.0f, 8.0f, 4.0f)); + r2 = vec4(v_21.xyz, r2.w); + let v_22 = floor(r2.xyz); + r2 = vec4(v_22.xyz, r2.w); + r0.w = dot(r2.xyz, vec3(32.0f, 4.0f, 1.0f)); + o1.w = (r0.w * 0.0039215688593685627f); + let v_23 = (r5.xyz * vec3(0.00390625f)); + o1 = vec4(v_23.xyz, o1.w); + r3.y = (r1.y * 0.001953125f); + r4.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w); + let v_24 = (r4.xz * vec2(0.5f)); + r2 = vec4(v_24.xy, r2.zw); + let v_25 = sqrt(r2.xy); + o3 = vec4(v_25.xy, o3.zw); + r0.w = fma(r1.z, r1.w, -0.34999999403953552246f); + r0.w = clamp(((r0.wwww * vec4(1.53846156597137451172f))).w, 0.0f, 1.0f); + r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z); + r1.y = ((-(cb2_2.tint_symbol[16u].zzzz)).y + 1.0f); + r0.w = (r0.w * r1.y); + r0.w = (r4.y * r0.w); + r1.y = fma((-(r3.xxxx)).y, 0.5f, 1.0f); + r1.y = (r0.w * r1.y); + r0.w = (r0.w * cb12_12.tint_symbol_3[2u].x); + r1.y = fma(r1.y, -0.5f, 1.0f); + let v_26 = (r0.xyz * r1.yyy); + o0 = vec4(v_26.xyz, o0.w); + r0.x = clamp(fma(r1.xxxx, cb12_12.tint_symbol_3[0u].zzzz, vec4(0.40000000596046447754f)).x, 0.0f, 1.0f); + let v_27 = (r0.xx * vec2(0.5f, 0.48828125f)); + r0 = vec4(v_27.xy, r0.zw); + r3.z = cb12_12.tint_symbol_3[0u].x; + r0.z = 0.97000002861022949219f; + let v_28 = -(r3.xyzx); + let v_29 = (r0.xyz + v_28.xyz); + r0 = vec4(v_29.xyz, r0.w); + let v_30 = max(r0.xyz, vec3()); + r0 = vec4(v_30.xyz, r0.w); + let v_31 = fma(r0.xyz, r0.www, r3.xyz); + r0 = vec4(v_31.xyz, r0.w); + let v_32 = sqrt(r0.xy); + o2 = vec4(v_32.xy, o2.zw); + o2.z = r0.z; + o2.w = 1.0f; + o3 = vec4(o3.xy, vec2(0.0f, 1.00188386440277099609f)); +} + +fn v_5(v_33 : bool) { + if (v_33) { + discard; + return; + } +} + +struct tint_symbol_4 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@builtin(position) v_34 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4) -> tint_symbol_4 { + main_inner(v_34, v1, v2, v3, v4, v5, v6); + return tint_symbol_4(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/0061ed6188dc3969.wgsl b/b/8b0b5899ed/shaders/0061ed6188dc3969.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..1b28b4e91f7999e194a2c6edb3edf99649d52652 --- /dev/null +++ b/b/8b0b5899ed/shaders/0061ed6188dc3969.wgsl @@ -0,0 +1,26 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(35u) var t3 : texture_cube; + +var o0 : vec4; + +fn main_inner(v1 : vec4) { + r0.x = dot(v1.xy, v1.xy); + r0.x = (r0.x + -1.0f); + r0.z = (r0.x * v1.z); + r0 = vec4(((v1.xy * vec2(-2.0f))).xy, r0.zw); + r0 = textureSampleLevel(t3, s3, r0.xyzx.xyz, 0.0f); + let v = r0; + o0 = vec4(v.xyz, o0.w); + o0.w = 1.0f; +} + +@fragment +fn main(@location(1u) v1 : vec4) -> @location(0u) vec4 { + main_inner(v1); + return o0; +} diff --git a/b/8b0b5899ed/shaders/006957a1aede62d1.wgsl b/b/8b0b5899ed/shaders/006957a1aede62d1.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..c30c9a259f0ae269f3d18162bbb57951620d9768 --- /dev/null +++ b/b/8b0b5899ed/shaders/006957a1aede62d1.wgsl @@ -0,0 +1,497 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb15_struct { + tint_symbol_1 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +struct cb46_struct { + tint_symbol_2 : array, 46u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb46_struct; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(36u) var t4 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v0 : vec4; + +var o0 : vec4; + +fn main_inner(v : vec4, v1 : vec4, v2 : vec4) { + var v_1 : vec4 = v; + v_1.w = (1.0f / v.w); + v0 = v_1; + r0 = textureSample(t4, s4, v1.xyxx.xy); + r0.x = ((-(r0.xxxx)).x + cb5_5.tint_symbol_2[0u].w); + r0.x = (r0.x + 1.0f); + r0.x = (cb5_5.tint_symbol_2[0u].z / r0.x); + let v_2 = (r0.xxx * v2.xyz); + r0 = vec4(r0.x, v_2.xyz); + r1.x = dot(r0.yzw, r0.yzw); + r1.x = sqrt(r1.x); + r1.y = dot(v1.xy, vec2(25.9796009063720703125f, 156.46600341796875f)); + r1.y = sin(r1.yyyy.y); + r1.y = (r1.y * 43758.546875f); + r1.y = fract(r1.y); + r1.y = fma(r1.y, 2.0f, -1.0f); + r1.y = (r1.y * 0.5f); + r2.x = (r1.x * cb5_5.tint_symbol_2[45u].y); + r1.x = clamp(fma(r1.xxxx, cb5_5.tint_symbol_2[45u].zzzz, cb5_5.tint_symbol_2[45u].wwww).x, 0.0f, 1.0f); + r1.x = (r1.y * r1.x); + let v_3 = (v0.xy * vec2(0.3333333432674407959f)); + let v_4 = r1; + r1 = vec4(v_4.x, v_3.xy, v_4.w); + let v_5 = -(r1.yyzy); + let v_6 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz >= v_5.yz))); + let v_7 = r2; + r2 = vec4(v_7.x, v_6.xy, v_7.w); + let v_8 = fract(abs(r1.yyzy).yz); + let v_9 = r1; + r1 = vec4(v_9.x, v_8.xy, v_9.w); + let v_10 = -(r1.yyzy); + let v_11 = bitcast>(r2.yz); + let v_12 = select(v_10.yz, r1.yz, (v_11 != vec2())); + let v_13 = r1; + r1 = vec4(v_13.x, v_12.xy, v_13.w); + let v_14 = (r1.yz * vec2(3.0f, 9.0f)); + let v_15 = r1; + r1 = vec4(v_15.x, v_14.xy, v_15.w); + r1.y = (r1.z + r1.y); + let v_16 = (r0.yzw * vec3(0.11111111193895339966f)); + r0 = vec4(r0.x, v_16.xyz); + let v_17 = (r1.yyy * r0.yzw); + r1 = vec4(r1.x, v_17.xyz); + let v_18 = fma(r1.yzw, vec3(0.11111111193895339966f), cb1_1.tint_symbol[15u].xyz); + r1 = vec4(r1.x, v_18.xyz); + let v_19 = fma(r1.xxx, r0.yzw, r1.yzw); + r1 = vec4(v_19.xyz, r1.w); + r1.w = fma((-(cb6_6.tint_symbol_1[14u].zzzz)).w, 1.5f, 1.0f); + r1.w = (r1.w * 0.5f); + let v_20 = -(cb1_1.tint_symbol[15u].xyzx); + let v_21 = (r1.xyz + v_20.xyz); + r1 = vec4(v_21.xyz, r1.w); + let v_22 = (r1.yyy * cb6_6.tint_symbol_1[1u].xyz); + r2 = vec4(r2.x, v_22.xyz); + let v_23 = fma(r1.xxx, cb6_6.tint_symbol_1[0u].xyz, r2.yzw); + r2 = vec4(r2.x, v_23.xyz); + let v_24 = fma(r1.zzz, cb6_6.tint_symbol_1[2u].xyz, r2.yzw); + r1 = vec4(v_24.xyz, r1.w); + let v_25 = (r0.zzz * cb6_6.tint_symbol_1[1u].xyz); + r2 = vec4(r2.x, v_25.xyz); + let v_26 = fma(r0.yyy, cb6_6.tint_symbol_1[0u].xyz, r2.yzw); + r2 = vec4(r2.x, v_26.xyz); + let v_27 = fma(r0.www, cb6_6.tint_symbol_1[2u].xyz, r2.yzw); + r0 = vec4(r0.x, v_27.xyz); + let v_28 = fma(r1.xyz, cb6_6.tint_symbol_1[4u].xyz, cb6_6.tint_symbol_1[8u].xyz); + r3 = vec4(v_28.xyz, r3.w); + let v_29 = fma(r1.xyz, cb6_6.tint_symbol_1[5u].xyz, cb6_6.tint_symbol_1[9u].xyz); + r4 = vec4(v_29.xyz, r4.w); + let v_30 = fma(r1.xyz, cb6_6.tint_symbol_1[6u].xyz, cb6_6.tint_symbol_1[10u].xyz); + r5 = vec4(v_30.xyz, r5.w); + let v_31 = fma(r1.xyz, cb6_6.tint_symbol_1[7u].xyz, cb6_6.tint_symbol_1[11u].xyz); + r6 = vec4(v_31.xyz, r6.w); + let v_32 = abs(r3.yyyy); + r1.x = max(v_32.x, abs(r3.xxxx).x); + let v_33 = abs(r4.yyyy); + r1.y = max(v_33.y, abs(r4.xxxx).y); + let v_34 = abs(r5.yyyy); + r1.z = max(v_34.z, abs(r5.xxxx).z); + let v_35 = bitcast>(select(vec3(), vec3(4294967295u), (r1.xyz < r1.www))); + r1 = vec4(v_35.xyz, r1.w); + let v_36 = abs(r6.yyyy); + r2.y = max(v_36.y, abs(r6.xxxx).y); + r2.y = bitcast(select(0u, 4294967295u, (r2.y < r1.w))); + r6.w = 0.875f; + let v_37 = bitcast>(r2.yyyy); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_37 != vec4())); + r5.w = 0.625f; + let v_38 = bitcast>(r1.zzzz); + let v_39 = r5; + r7 = select(r7, v_39, (v_38 != vec4())); + r4.w = 0.375f; + let v_40 = bitcast>(r1.yyyy); + let v_41 = r4; + r7 = select(r7, v_41, (v_40 != vec4())); + r3.w = 0.125f; + let v_42 = bitcast>(r1.xxxx); + let v_43 = r3; + r7 = select(r7, v_43, (v_42 != vec4())); + r1.x = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.x) != 0u)) { + r1.x = (r7.x + 0.5f); + r1.y = fma(r7.y, 0.25f, r7.w); + let v_44 = r1.xyxx; + r1.x = textureSampleCompareLevel(t15, s15, v_44.xy, r7.z); + } else { + r1.x = 1.0f; + } + let v_45 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_45.xyz, r3.w); + let v_46 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_46.xyz, r4.w); + let v_47 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_47.xyz, r5.w); + let v_48 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_48.xyz, r6.w); + let v_49 = abs(r3.yyyy); + r1.y = max(v_49.y, abs(r3.xxxx).y); + let v_50 = abs(r4.yyyy); + r1.z = max(v_50.z, abs(r4.xxxx).z); + let v_51 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz < r1.ww))); + let v_52 = r1; + r1 = vec4(v_52.x, v_51.xy, v_52.w); + let v_53 = abs(r5.yyyy); + r2.y = max(v_53.y, abs(r5.xxxx).y); + let v_54 = abs(r6.yyyy); + r2.z = max(v_54.z, abs(r6.xxxx).z); + let v_55 = bitcast>(select(vec2(), vec2(4294967295u), (r2.yz < r1.ww))); + let v_56 = r2; + r2 = vec4(v_56.x, v_55.xy, v_56.w); + r6.w = 0.875f; + let v_57 = bitcast>(r2.zzzz); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_57 != vec4())); + r5.w = 0.625f; + let v_58 = bitcast>(r2.yyyy); + let v_59 = r5; + r7 = select(r7, v_59, (v_58 != vec4())); + r4.w = 0.375f; + let v_60 = bitcast>(r1.zzzz); + let v_61 = r4; + r7 = select(r7, v_61, (v_60 != vec4())); + r3.w = 0.125f; + let v_62 = bitcast>(r1.yyyy); + let v_63 = r3; + r7 = select(r7, v_63, (v_62 != vec4())); + r1.y = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.y) != 0u)) { + r8.x = (r7.x + 0.5f); + r8.y = fma(r7.y, 0.25f, r7.w); + let v_64 = r8.xyxx; + r1.y = textureSampleCompareLevel(t15, s15, v_64.xy, r7.z); + } else { + r1.y = 1.0f; + } + r1.x = (r1.y + r1.x); + let v_65 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_65.xyz, r3.w); + let v_66 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_66.xyz, r4.w); + let v_67 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_67.xyz, r5.w); + let v_68 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_68.xyz, r6.w); + let v_69 = abs(r3.yyyy); + r1.y = max(v_69.y, abs(r3.xxxx).y); + let v_70 = abs(r4.yyyy); + r1.z = max(v_70.z, abs(r4.xxxx).z); + let v_71 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz < r1.ww))); + let v_72 = r1; + r1 = vec4(v_72.x, v_71.xy, v_72.w); + let v_73 = abs(r5.yyyy); + r2.y = max(v_73.y, abs(r5.xxxx).y); + let v_74 = abs(r6.yyyy); + r2.z = max(v_74.z, abs(r6.xxxx).z); + let v_75 = bitcast>(select(vec2(), vec2(4294967295u), (r2.yz < r1.ww))); + let v_76 = r2; + r2 = vec4(v_76.x, v_75.xy, v_76.w); + r6.w = 0.875f; + let v_77 = bitcast>(r2.zzzz); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_77 != vec4())); + r5.w = 0.625f; + let v_78 = bitcast>(r2.yyyy); + let v_79 = r5; + r7 = select(r7, v_79, (v_78 != vec4())); + r4.w = 0.375f; + let v_80 = bitcast>(r1.zzzz); + let v_81 = r4; + r7 = select(r7, v_81, (v_80 != vec4())); + r3.w = 0.125f; + let v_82 = bitcast>(r1.yyyy); + let v_83 = r3; + r7 = select(r7, v_83, (v_82 != vec4())); + r1.y = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.y) != 0u)) { + r8.x = (r7.x + 0.5f); + r8.y = fma(r7.y, 0.25f, r7.w); + let v_84 = r8.xyxx; + r1.y = textureSampleCompareLevel(t15, s15, v_84.xy, r7.z); + } else { + r1.y = 1.0f; + } + r1.x = (r1.y + r1.x); + let v_85 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_85.xyz, r3.w); + let v_86 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_86.xyz, r4.w); + let v_87 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_87.xyz, r5.w); + let v_88 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_88.xyz, r6.w); + let v_89 = abs(r3.yyyy); + r1.y = max(v_89.y, abs(r3.xxxx).y); + let v_90 = abs(r4.yyyy); + r1.z = max(v_90.z, abs(r4.xxxx).z); + let v_91 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz < r1.ww))); + let v_92 = r1; + r1 = vec4(v_92.x, v_91.xy, v_92.w); + let v_93 = abs(r5.yyyy); + r2.y = max(v_93.y, abs(r5.xxxx).y); + let v_94 = abs(r6.yyyy); + r2.z = max(v_94.z, abs(r6.xxxx).z); + let v_95 = bitcast>(select(vec2(), vec2(4294967295u), (r2.yz < r1.ww))); + let v_96 = r2; + r2 = vec4(v_96.x, v_95.xy, v_96.w); + r6.w = 0.875f; + let v_97 = bitcast>(r2.zzzz); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_97 != vec4())); + r5.w = 0.625f; + let v_98 = bitcast>(r2.yyyy); + let v_99 = r5; + r7 = select(r7, v_99, (v_98 != vec4())); + r4.w = 0.375f; + let v_100 = bitcast>(r1.zzzz); + let v_101 = r4; + r7 = select(r7, v_101, (v_100 != vec4())); + r3.w = 0.125f; + let v_102 = bitcast>(r1.yyyy); + let v_103 = r3; + r7 = select(r7, v_103, (v_102 != vec4())); + r1.y = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.y) != 0u)) { + r8.x = (r7.x + 0.5f); + r8.y = fma(r7.y, 0.25f, r7.w); + let v_104 = r8.xyxx; + r1.y = textureSampleCompareLevel(t15, s15, v_104.xy, r7.z); + } else { + r1.y = 1.0f; + } + r1.x = (r1.y + r1.x); + let v_105 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_105.xyz, r3.w); + let v_106 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_106.xyz, r4.w); + let v_107 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_107.xyz, r5.w); + let v_108 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_108.xyz, r6.w); + let v_109 = abs(r3.yyyy); + r1.y = max(v_109.y, abs(r3.xxxx).y); + let v_110 = abs(r4.yyyy); + r1.z = max(v_110.z, abs(r4.xxxx).z); + let v_111 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz < r1.ww))); + let v_112 = r1; + r1 = vec4(v_112.x, v_111.xy, v_112.w); + let v_113 = abs(r5.yyyy); + r2.y = max(v_113.y, abs(r5.xxxx).y); + let v_114 = abs(r6.yyyy); + r2.z = max(v_114.z, abs(r6.xxxx).z); + let v_115 = bitcast>(select(vec2(), vec2(4294967295u), (r2.yz < r1.ww))); + let v_116 = r2; + r2 = vec4(v_116.x, v_115.xy, v_116.w); + r6.w = 0.875f; + let v_117 = bitcast>(r2.zzzz); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_117 != vec4())); + r5.w = 0.625f; + let v_118 = bitcast>(r2.yyyy); + let v_119 = r5; + r7 = select(r7, v_119, (v_118 != vec4())); + r4.w = 0.375f; + let v_120 = bitcast>(r1.zzzz); + let v_121 = r4; + r7 = select(r7, v_121, (v_120 != vec4())); + r3.w = 0.125f; + let v_122 = bitcast>(r1.yyyy); + let v_123 = r3; + r7 = select(r7, v_123, (v_122 != vec4())); + r1.y = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.y) != 0u)) { + r8.x = (r7.x + 0.5f); + r8.y = fma(r7.y, 0.25f, r7.w); + let v_124 = r8.xyxx; + r1.y = textureSampleCompareLevel(t15, s15, v_124.xy, r7.z); + } else { + r1.y = 1.0f; + } + r1.x = (r1.y + r1.x); + let v_125 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_125.xyz, r3.w); + let v_126 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_126.xyz, r4.w); + let v_127 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_127.xyz, r5.w); + let v_128 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_128.xyz, r6.w); + let v_129 = abs(r3.yyyy); + r1.y = max(v_129.y, abs(r3.xxxx).y); + let v_130 = abs(r4.yyyy); + r1.z = max(v_130.z, abs(r4.xxxx).z); + let v_131 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz < r1.ww))); + let v_132 = r1; + r1 = vec4(v_132.x, v_131.xy, v_132.w); + let v_133 = abs(r5.yyyy); + r2.y = max(v_133.y, abs(r5.xxxx).y); + let v_134 = abs(r6.yyyy); + r2.z = max(v_134.z, abs(r6.xxxx).z); + let v_135 = bitcast>(select(vec2(), vec2(4294967295u), (r2.yz < r1.ww))); + let v_136 = r2; + r2 = vec4(v_136.x, v_135.xy, v_136.w); + r6.w = 0.875f; + let v_137 = bitcast>(r2.zzzz); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_137 != vec4())); + r5.w = 0.625f; + let v_138 = bitcast>(r2.yyyy); + let v_139 = r5; + r7 = select(r7, v_139, (v_138 != vec4())); + r4.w = 0.375f; + let v_140 = bitcast>(r1.zzzz); + let v_141 = r4; + r7 = select(r7, v_141, (v_140 != vec4())); + r3.w = 0.125f; + let v_142 = bitcast>(r1.yyyy); + let v_143 = r3; + r7 = select(r7, v_143, (v_142 != vec4())); + r1.y = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.y) != 0u)) { + r8.x = (r7.x + 0.5f); + r8.y = fma(r7.y, 0.25f, r7.w); + let v_144 = r8.xyxx; + r1.y = textureSampleCompareLevel(t15, s15, v_144.xy, r7.z); + } else { + r1.y = 1.0f; + } + r1.x = (r1.y + r1.x); + let v_145 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_145.xyz, r3.w); + let v_146 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_146.xyz, r4.w); + let v_147 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_147.xyz, r5.w); + let v_148 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_148.xyz, r6.w); + let v_149 = abs(r3.yyyy); + r1.y = max(v_149.y, abs(r3.xxxx).y); + let v_150 = abs(r4.yyyy); + r1.z = max(v_150.z, abs(r4.xxxx).z); + let v_151 = bitcast>(select(vec2(), vec2(4294967295u), (r1.yz < r1.ww))); + let v_152 = r1; + r1 = vec4(v_152.x, v_151.xy, v_152.w); + let v_153 = abs(r5.yyyy); + r2.y = max(v_153.y, abs(r5.xxxx).y); + let v_154 = abs(r6.yyyy); + r2.z = max(v_154.z, abs(r6.xxxx).z); + let v_155 = bitcast>(select(vec2(), vec2(4294967295u), (r2.yz < r1.ww))); + let v_156 = r2; + r2 = vec4(v_156.x, v_155.xy, v_156.w); + r6.w = 0.875f; + let v_157 = bitcast>(r2.zzzz); + r7 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_157 != vec4())); + r5.w = 0.625f; + let v_158 = bitcast>(r2.yyyy); + let v_159 = r5; + r7 = select(r7, v_159, (v_158 != vec4())); + r4.w = 0.375f; + let v_160 = bitcast>(r1.zzzz); + let v_161 = r4; + r7 = select(r7, v_161, (v_160 != vec4())); + r3.w = 0.125f; + let v_162 = bitcast>(r1.yyyy); + let v_163 = r3; + r7 = select(r7, v_163, (v_162 != vec4())); + r1.y = bitcast(select(0u, 4294967295u, !((r7.w == 5.0f)))); + if ((bitcast(r1.y) != 0u)) { + r8.x = (r7.x + 0.5f); + r8.y = fma(r7.y, 0.25f, r7.w); + let v_164 = r8.xyxx; + r1.y = textureSampleCompareLevel(t15, s15, v_164.xy, r7.z); + } else { + r1.y = 1.0f; + } + r1.x = (r1.y + r1.x); + let v_165 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz); + r3 = vec4(v_165.xyz, r3.w); + let v_166 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz); + r4 = vec4(v_166.xyz, r4.w); + let v_167 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz); + r5 = vec4(v_167.xyz, r5.w); + let v_168 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz); + r6 = vec4(v_168.xyz, r6.w); + let v_169 = abs(r3.yyyy); + r0.y = max(v_169.y, abs(r3.xxxx).y); + let v_170 = abs(r4.yyyy); + r0.z = max(v_170.z, abs(r4.xxxx).z); + let v_171 = abs(r5.yyyy); + r0.w = max(v_171.w, abs(r5.xxxx).w); + let v_172 = bitcast>(select(vec3(), vec3(4294967295u), (r0.yzw < r1.www))); + r0 = vec4(r0.x, v_172.xyz); + let v_173 = abs(r6.yyyy); + r1.y = max(v_173.y, abs(r6.xxxx).y); + r1.y = bitcast(select(0u, 4294967295u, (r1.y < r1.w))); + r6.w = 0.875f; + let v_174 = bitcast>(r1.yyyy); + r6 = select(vec4(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_174 != vec4())); + r5.w = 0.625f; + let v_175 = bitcast>(r0.wwww); + let v_176 = r5; + r5 = select(r6, v_176, (v_175 != vec4())); + r4.w = 0.375f; + let v_177 = bitcast>(r0.zzzz); + let v_178 = r4; + r4 = select(r5, v_178, (v_177 != vec4())); + r3.w = 0.125f; + let v_179 = bitcast>(r0.yyyy); + let v_180 = r3; + r3 = select(r4, v_180, (v_179 != vec4())); + r0.y = bitcast(select(0u, 4294967295u, !((r3.w == 5.0f)))); + if ((bitcast(r0.y) != 0u)) { + r4.x = (r3.x + 0.5f); + r4.y = fma(r3.y, 0.25f, r3.w); + let v_181 = r4.xyxx; + r0.y = textureSampleCompareLevel(t15, s15, v_181.xy, r3.z); + } else { + r0.y = 1.0f; + } + r0.y = (r0.y + r1.x); + r0.y = (r0.y * 0.125f); + r2.x = clamp(r2.xxxx.x, 0.0f, 1.0f); + r0.z = ((-(r2.xxxx)).z + 1.0f); + o0.x = fma(r0.z, r0.y, r2.x); + o0 = vec4(o0.xy, vec2()); + o0.y = r0.x; +} + +@fragment +fn main(@builtin(position) v_182 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4) -> @location(0u) vec4 { + main_inner(v_182, v1, v2); + return o0; +} diff --git a/b/8b0b5899ed/shaders/006bd653d319ed4e.wgsl b/b/8b0b5899ed/shaders/006bd653d319ed4e.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..9777fff170771b95cb57844ef6b533d6d3c03faf --- /dev/null +++ b/b/8b0b5899ed/shaders/006bd653d319ed4e.wgsl @@ -0,0 +1,53 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +struct cb25_struct { + tint_symbol : array, 25u>, +} + +@group(0u) @binding(5u) var cb5_5 : cb25_struct; + +@group(0u) @binding(16u) var s0 : sampler; + +@group(0u) @binding(32u) var t0 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +fn main_inner(v0 : vec4, v1 : vec4) { + r0 = textureSampleLevel(t0, s0, v1.zwzz.xy, 0.0f); + r0.x = bitcast(select(0u, 4294967295u, (r0.x >= cb5_5.tint_symbol[24u].x))); + r0.y = bitcast(select(0u, 4294967295u, (r0.z >= 0.0f))); + r0.x = bitcast((bitcast(r0.y) & bitcast(r0.x))); + r0.x = bitcast((bitcast(r0.x) & 1065353216u)); + r1.x = fma(v1.x, v0.z, v0.x); + r1.y = fma((-(v1.yyyy)).y, v0.w, v0.y); + let v = (r1.xy + vec2(-0.5f, 0.5f)); + let v_1 = r0; + r0 = vec4(v_1.x, v.xy, v_1.w); + let v_2 = (r0.yz + r0.yz); + r1 = vec4(v_2.xy, r1.zw); + let v_3 = fma(r1.xy, vec2(1.0f, -1.0f), vec2(1.0f)); + let v_4 = r0; + r0 = vec4(v_4.x, v_3.xy, v_4.w); + o1 = ((r0.yz * vec2(0.5f))).xyxy; + r1 = vec4(r1.xy, vec2(0.0f, 1.0f)); + o0 = (r0.xxxx * r1); +} + +struct tint_symbol_1 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4) -> tint_symbol_1 { + main_inner(v0, v1); + return tint_symbol_1(o0, o1); +} diff --git a/b/8b0b5899ed/shaders/007089a30fcd7fd8.consts.json b/b/8b0b5899ed/shaders/007089a30fcd7fd8.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..9c27df027d15db715744502f6c2271644a23c98e --- /dev/null +++ b/b/8b0b5899ed/shaders/007089a30fcd7fd8.consts.json @@ -0,0 +1 @@ +[2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/007089a30fcd7fd8.wgsl b/b/8b0b5899ed/shaders/007089a30fcd7fd8.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..0122255dd1cf0704b21a264669e82a6e75b22f23 --- /dev/null +++ b/b/8b0b5899ed/shaders/007089a30fcd7fd8.wgsl @@ -0,0 +1,230 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +struct cb19_struct { + tint_symbol : array, 19u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb19_struct; + +struct cb15_struct { + tint_symbol_1 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +struct cb2_struct { + tint_symbol_2 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb6_struct { + tint_symbol_3 : array, 6u>, +} + +@group(1u) @binding(11u) var cb11_11 : cb6_struct; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(21u) var s5 : sampler; + +@group(1u) @binding(22u) var s6 : sampler; + +@group(1u) @binding(30u) var s14 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(37u) var t5 : texture_2d; + +@group(1u) @binding(38u) var t6 : texture_2d; + +@group(1u) @binding(46u) var t14 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var o0 : vec4; + +var x0 : array, 4u>; + +struct tint_symbol_5 { + tint_symbol_4 : array, 3u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_5; + +fn main_inner(v1 : vec4, v3 : vec4) { + let v_1 = fma(v1.xy, vec2(2.0f), vec2(-1.0f)); + r0 = vec4(v_1.xy, r0.zw); + let v_2 = fma(r0.xy, vec2(1.0f, -1.0f), cb11_11.tint_symbol_3[4u].xy); + r0 = vec4(v_2.xy, r0.zw); + r0.x = (r0.x * cb11_11.tint_symbol_3[0u].w); + r0.y = (r0.y * cb11_11.tint_symbol_3[1u].w); + let v_3 = (r0.yyy * cb11_11.tint_symbol_3[1u].xyz); + r0 = vec4(r0.x, v_3.xyz); + let v_4 = fma(r0.xxx, cb11_11.tint_symbol_3[0u].xyz, r0.yzw); + r0 = vec4(v_4.xyz, r0.w); + let v_5 = -(cb11_11.tint_symbol_3[2u].xyzx); + let v_6 = (r0.xyz + v_5.xyz); + r0 = vec4(v_6.xyz, r0.w); + r1 = textureSample(t3, s3, v1.xy.xyxx.xy); + r0.w = (cb11_11.tint_symbol_3[3u].w + 1.0f); + r0.w = ((-(r1.xxxx)).w + r0.w); + r0.w = (cb11_11.tint_symbol_3[2u].w / r0.w); + let v_7 = fma(r0.xyz, r0.www, cb11_11.tint_symbol_3[3u].xyz); + r0 = vec4(v_7.xyz, r0.w); + let v_8 = (r0.www * v3.xyz); + r1 = vec4(v_8.xyz, r1.w); + let v_9 = (v1.xy * cb2_2.tint_symbol[18u].xy); + r2 = vec4(v_9.xy, r2.zw); + let v_10 = (r2.xy * vec2(0.015625f)); + r2 = vec4(v_10.xy, r2.zw); + r2 = textureSample(t14, s14, r2.xyxx.xy); + r1.w = (r2.z * cb12_12.tint_symbol_2[0u].w); + let v_11 = fma(r1.xyz, cb6_6.tint_symbol_1[4u].xyz, cb6_6.tint_symbol_1[8u].xyz); + r2 = vec4(v_11.xyz, r2.w); + let v_12 = &(x0[0u]); + let v_13 = r2; + *(v_12) = vec4(v_13.xyz, (*(v_12)).w); + let v_14 = fma(r1.xyz, cb6_6.tint_symbol_1[5u].xyz, cb6_6.tint_symbol_1[9u].xyz); + r3 = vec4(v_14.xyz, r3.w); + let v_15 = &(x0[1u]); + let v_16 = r3; + *(v_15) = vec4(v_16.xyz, (*(v_15)).w); + let v_17 = fma(r1.xyz, cb6_6.tint_symbol_1[6u].xyz, cb6_6.tint_symbol_1[10u].xyz); + r4 = vec4(v_17.xyz, r4.w); + let v_18 = &(x0[2u]); + let v_19 = r4; + *(v_18) = vec4(v_19.xyz, (*(v_18)).w); + let v_20 = fma(r1.xyz, cb6_6.tint_symbol_1[7u].xyz, cb6_6.tint_symbol_1[11u].xyz); + r1 = vec4(v_20.xyz, r1.w); + let v_21 = &(x0[3u]); + let v_22 = r1; + *(v_21) = vec4(v_22.xyz, (*(v_21)).w); + r1.z = fma((-(cb6_6.tint_symbol_1[14u].zzzz)).z, 1.5f, 1.0f); + let v_23 = -(r1.wwww); + r1.z = fma(r1.z, 0.5f, v_23.z); + let v_24 = abs(r4.yyyy); + r1.w = max(v_24.w, abs(r4.xxxx).w); + r1.w = bitcast(select(0u, 4294967295u, (r1.w < r1.z))); + let v_25 = (bitcast(r1.w) != 0u); + let v_26 = bitcast(v.tint_symbol_4[0i].x); + r1.w = select(bitcast(v.tint_symbol_4[1i].x), v_26, v_25); + let v_27 = abs(r3.yyyy); + r2.z = max(v_27.z, abs(r3.xxxx).z); + r2.z = bitcast(select(0u, 4294967295u, (r2.z < r1.z))); + let v_28 = bitcast(r2.z); + r1.w = select(r1.w, bitcast(v.tint_symbol_4[2i].x), (v_28 != 0u)); + let v_29 = abs(r2.yyyy); + r2.x = max(v_29.x, abs(r2.xxxx).x); + r1.z = bitcast(select(0u, 4294967295u, (r2.x < r1.z))); + let v_30 = bitcast(r1.z); + r1.z = select(r1.w, 0.0f, (v_30 != 0u)); + let v_31 = x0[bitcast(r1.z)]; + r2 = vec4(v_31.xyz, r2.w); + r1.z = f32(bitcast(r1.z)); + r1.w = (r1.z + 0.5f); + r1.w = (r1.w * 0.25f); + r3 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r1.zzzz))); + r3 = bitcast>((bitcast>(r3) & vec4(1065353216u))); + r1.z = dot(r3, cb6_6.tint_symbol_1[12u]); + r2.w = dot(r3, cb6_6.tint_symbol_1[13u]); + r3.x = (r2.x + 0.5f); + r3.y = fma(r2.y, 0.25f, r1.w); + r1.w = bitcast(select(0u, 4294967295u, !((r1.z == 0.0f)))); + r1.z = ((-(r1.zzzz)).z + r2.z); + let v_32 = dpdx(r3.xyy); + r4 = vec4(v_32.xy, r4.z, v_32.z); + r4.z = dpdx(r1.z); + let v_33 = dpdy(r3.yxy); + r5 = vec4(v_33.xyz, r5.w); + r5.w = dpdy(r1.z); + let v_34 = (r4.yw * r5.yw); + r2 = vec4(v_34.xy, r2.zw); + let v_35 = -(r2.xyxx); + let v_36 = fma(r4.xz, r5.xz, v_35.xy); + r6 = vec4(v_36.xy, r6.zw); + r2.x = (1.0f / r6.x); + r2.y = (r4.z * r5.y); + let v_37 = -(r2.yyyy); + r6.z = fma(r4.x, r5.w, v_37.z); + let v_38 = (r2.xx * r6.yz); + r2 = vec4(v_38.xy, r2.zw); + let v_39 = max(r2.xy, vec2()); + r2 = vec4(v_39.xy, r2.zw); + let v_40 = min(r2.xy, vec2(0.5f)); + r2 = vec4(v_40.xy, r2.zw); + r1.z = fma((-(r2.wwww)).z, r2.x, r1.z); + r1.z = fma((-(r2.wwww)).z, r2.y, r1.z); + let v_41 = bitcast(r1.w); + let v_42 = r1.z; + r1.z = select(r2.z, v_42, (v_41 != 0u)); + r2.x = (r3.x + cb6_6.tint_symbol_1[14u].z); + r2.y = fma(cb6_6.tint_symbol_1[14u].w, 0.25f, r3.y); + let v_43 = r2.xyxx; + r2.x = textureSampleCompareLevel(t15, s15, v_43.xy, r1.z); + r1.z = bitcast(select(0u, 4294967295u, !((cb12_12.tint_symbol_2[1u].x == 0.0f)))); + if ((bitcast(r1.z) != 0u)) { + r3 = textureSample(t2, s2, r3.xyxx.xy); + r2.y = ((-(r3.wwww)).y + 1.0f); + } else { + r2.y = 1.0f; + } + r0.w = clamp(fma(r0.wwww, cb6_6.tint_symbol_1[0u].wwww, cb6_6.tint_symbol_1[1u].wwww).w, 0.0f, 1.0f); + let v_44 = abs(r1.yyyy); + r1.x = max(v_44.x, abs(r1.xxxx).x); + r1.x = clamp(fma(r1.xxxx, vec4(15.0f), vec4(-6.30000019073486328125f)).x, 0.0f, 1.0f); + r0.w = ((-(r0.wwww)).w + 1.0f); + let v_45 = fma(r0.ww, r1.xx, r2.xy); + r1 = vec4(v_45.xy, r1.zw); + let v_46 = (r1.xy * r1.xy); + r1 = vec4(v_46.xy, r1.zw); + let v_47 = min(r1.xy, vec2(1.0f)); + let v_48 = r1; + r1 = vec4(v_48.x, v_47.xy, v_48.w); + r0.w = bitcast(select(0u, 4294967295u, !((0.0f == cb12_12.tint_symbol_2[1u].y)))); + r1.w = (r1.z * r1.y); + let v_49 = bitcast(r0.w); + let v_50 = r1.w; + r1.x = select(r1.y, v_50, (v_49 != 0u)); + r2.x = (-(cb11_11.tint_symbol_3[5u].wwww)).x; + let v_51 = r2; + r2 = vec4(v_51.x, 0.0f, v_51.z, 0.5f); + let v_52 = fma(r0.xy, vec2(0.00028571428265422583f), r2.xy); + r0 = vec4(v_52.xy, r0.zw); + r3 = textureSample(t5, s5, r0.xyxx.xy); + r2.z = r3.y; + r2 = textureSample(t6, s6, r2.zwzz.xy); + r0.x = clamp(fma(r0.zzzz, cb6_6.tint_symbol_1[3u].xxxx, cb6_6.tint_symbol_1[3u].yyyy).x, 0.0f, 1.0f); + r0.x = sqrt(r0.x); + r0.x = fma((-(r0.xxxx)).x, cb6_6.tint_symbol_1[3u].z, 1.0f); + r0.x = (r0.x * r2.x); + let v_53 = (r0.xx * r1.xz); + r0 = vec4(v_53.xy, r0.zw); + o0 = min(r0.yyyy, r0.xxxx); +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(3u) v3 : vec4) -> @location(0u) vec4 { + main_inner(v1, v3); + return o0; +} diff --git a/b/8b0b5899ed/shaders/00716d7357599de4.wgsl b/b/8b0b5899ed/shaders/00716d7357599de4.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..07ac5549c0edda1238555146854d812c51dfa4e6 --- /dev/null +++ b/b/8b0b5899ed/shaders/00716d7357599de4.wgsl @@ -0,0 +1,100 @@ +enable clip_distances; +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb12_struct { + tint_symbol : array, 12u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb12_struct; + +struct cb1_struct { + tint_symbol_1 : array, 1u>, +} + +@group(0u) @binding(0u) var cb0_0 : cb1_struct; + +struct cb44_struct { + tint_symbol_2 : array, 44u>, +} + +@group(0u) @binding(3u) var cb3_3 : cb44_struct; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : array; + +var v : vec4; + +var x0 : array, 1u>; + +fn main_inner(v0 : vec3) { + o0 = ((v0 + cb1_1.tint_symbol[3u].xyz)).xyzx; + r0 = (v0.yyyy * cb1_1.tint_symbol[9u]); + r0 = fma(v0.xxxx, cb1_1.tint_symbol[8u], r0); + r0 = fma(v0.zzzz, cb1_1.tint_symbol[10u], r0); + r0 = (r0 + cb1_1.tint_symbol[11u]); + r1 = (cb3_3.tint_symbol_2[1u] + cb3_3.tint_symbol_2[43u]); + r1.x = dot(r1, vec4(1.0f)); + r1.x = bitcast(select(0u, 4294967295u, (r1.x < 0.0f))); + if ((bitcast(r1.x) != 0u)) { + r1.x = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[43u].x >= -1.0f))); + if ((bitcast(r1.x) != 0u)) { + o1 = vec4(0.0f, 0.0f, 0.0f, 1.0f); + } else { + r1.x = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[43u].x == -2.0f))); + if ((bitcast(r1.x) != 0u)) { + o1 = vec4(0.0f, 0.0f, 0.0f, 1.0f); + } else { + r1 = bitcast>(select(vec4(), vec4(4294967295u), (cb3_3.tint_symbol_2[43u].xxxx == vec4(-3.0f, -4.0f, -5.0f, -9.0f)))); + r2.x = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[43u].x == -10.0f))); + r1.w = bitcast((bitcast(r1.w) | bitcast(r2.x))); + r2 = select(vec4(0.0f, 0.0f, 0.0f, 1.0f), vec4(), (bitcast>(r1.wwww) != vec4())); + r1.y = bitcast((bitcast(r1.y) | bitcast(r1.z))); + let v_1 = bitcast>(r1.yyyy); + r2 = select(r2, vec4(0.5f, 0.5f, 0.5f, 1.0f), (v_1 != vec4())); + let v_2 = bitcast>(r1.xxxx); + o1 = select(r2, vec4(0.0f, 0.0f, 0.0f, 1.0f), (v_2 != vec4())); + } + } + } else { + o1 = vec4(); + } + x0[0u].x = dot(r0, cb0_0.tint_symbol_1[0u]); + o2 = r0; + let v_3 = &(x0[0u]); + *(v_3) = vec4((*(v_3)).x, vec3()); + o3[0u] = x0[0u].x; + o3[1u] = x0[0u].y; + o3[2u] = x0[0u].z; + o3[3u] = x0[0u].w; + v = vec4(o3[0u], o3[1u], o3[2u], o3[3u]); +} + +struct tint_symbol_4 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @builtin(position) + o2 : vec4, + @builtin(clip_distances) + o3 : array, + @location(15u) + tint_symbol_3 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3) -> tint_symbol_4 { + main_inner(v0); + return tint_symbol_4(o0, o1, o2, o3, v); +} diff --git a/b/8b0b5899ed/shaders/007db7c8f96e98aa.wgsl b/b/8b0b5899ed/shaders/007db7c8f96e98aa.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..f13ab541f48528cf7d434c761c1f7511fee6d832 --- /dev/null +++ b/b/8b0b5899ed/shaders/007db7c8f96e98aa.wgsl @@ -0,0 +1,333 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +struct cb17_struct { + tint_symbol : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb46_struct { + tint_symbol_1 : array, 46u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb46_struct; + +struct cb4_struct { + tint_symbol_2 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb2_struct { + tint_symbol_3 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4) { + let v = clamp(v2.zw, vec2(), vec2(1.0f)); + r0 = vec4(v.xy, r0.zw); + let v_1 = bitcast>(select(vec2(), vec2(4294967295u), (cb2_2.tint_symbol[2u].xy == vec2(1.0f)))); + r1 = vec4(v_1.xy, r1.zw); + if ((bitcast(r1.x) != 0u)) { + r2 = vec4(v2.xy, r2.zw); + let v_2 = r1; + r1 = vec4(v2.x, v_2.y, v2.y, v_2.w); + } else { + r1.z = ((-(r0.xxxx)).z + 1.0f); + r1.w = ((-(v2.wwww)).w + 1.0f); + r1.w = max(r1.w, 0.10000000149011611938f); + r1.w = min(r1.w, 1.0f); + r2.x = dot(v5.xyz, v4.xyz); + r2.y = dot(v6.xyz, v4.xyz); + r2.z = dot(v3.xyz, v4.xyz); + r2.w = dot(r2.xyz, r2.xyz); + r2.w = inverseSqrt(r2.w); + let v_3 = (r2.www * r2.xyz); + r2 = vec4(v_3.xyz, r2.w); + r1.w = max(r1.w, r2.z); + r2.z = dot(v4.xyz, v4.xyz); + r2.z = inverseSqrt(r2.z); + let v_4 = (r2.zzz * v4.xyz); + r3 = vec4(v_4.xyz, r3.w); + r2.z = dot(v3.xyz, v3.xyz); + r2.z = inverseSqrt(r2.z); + let v_5 = (r2.zzz * v3.xyz); + r4 = vec4(v_5.xyz, r4.w); + r2.z = dot(r3.xyz, r4.xyz); + r2.w = ((-(cb2_2.tint_symbol[3u].wwww)).w + cb2_2.tint_symbol[3u].z); + r2.w = fma(abs(r2.zzzz).w, r2.w, cb2_2.tint_symbol[3u].w); + r1.z = (r1.z * cb2_2.tint_symbol[1u].x); + r3.x = clamp(((r2.wwww + vec4(-1.0f))).x, 0.0f, 1.0f); + r1.z = (r1.z * r3.x); + r2.z = (abs(r2.zzzz).z * 4.0f); + r2.z = min(r2.z, 1.0f); + r1.z = (r1.z * r2.z); + let v_6 = ((-(r2.xyxx)).xy / r1.ww); + r3 = vec4(v_6.xy, r3.zw); + let v_7 = (r3.xy * cb12_12.tint_symbol_3[1u].xx); + r3 = vec4(v_7.xy, r3.zw); + let v_8 = (r1.zz * r3.xy); + r3 = vec4(v_8.xy, r3.zw); + let v_9 = (r2.xy / r1.ww); + r2 = vec4(v_9.xy, r2.zw); + let v_10 = (r2.xy * cb12_12.tint_symbol_3[1u].yy); + r2 = vec4(v_10.xy, r2.zw); + let v_11 = (r1.zz * r2.xy); + r1 = vec4(r1.xy, v_11.xy); + let v_12 = r2.w; + let v_13 = max(v_12, -2147483648.0f); + r2.x = bitcast(select(select(i32(v_13), 2147483647i, (v_13 >= 2147483648.0f)), 0i, !((v_12 == v_12)))); + r2.y = bitcast(select(0u, 4294967295u, (bitcast(r2.x) == 0i))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r2.y))); + if ((bitcast(r1.x) != 0u)) { + r1.x = 0.0f; + } else { + r1.x = trunc(r2.w); + r1.x = (1.0f / r1.x); + let v_14 = dpdx(v2.xy); + let v_15 = r2; + r2 = vec4(v_15.x, v_14.xy, v_15.w); + let v_16 = dpdy(v2.xy); + r3 = vec4(r3.xy, v_16.xy); + r4 = textureSampleGrad(t2, s2, v2.xyxx.xy, r2.yz, r3.zw); + r2.w = (r4.x + 0.00000099999999747524f); + let v_17 = r1; + r4 = vec4(v_17.zw, r4.zw); + r4 = vec4(r4.xy, vec2(1.0f)); + let v_18 = r2; + r5 = vec4(v_18.ww, r5.zw); + r5.z = 0.0f; + loop { + r5.w = bitcast(select(0u, 4294967295u, (bitcast(r5.z) >= bitcast(r2.x)))); + if ((bitcast(r5.w) != 0u)) { + break; + } + r5.w = bitcast(select(0u, 4294967295u, (r5.x < r4.z))); + if ((bitcast(r5.w) != 0u)) { + r5.w = ((-(r1.xxxx)).w + r4.z); + let v_19 = fma(r3.xy, r1.xx, r4.xy); + r4 = vec4(v_19.xy, r4.zw); + let v_20 = (r4.xy + v2.xy); + r6 = vec4(v_20.xy, r6.zw); + let v_21 = r2.yz; + let v_22 = r3.zw; + r6 = textureSampleGrad(t2, s2, r6.xyxx.xy, v_21, v_22); + r4.w = r4.z; + let v_23 = r5; + let v_24 = r5; + r5 = vec4(v_24.x, v_23.xz, v_24.w); + r4.z = r5.w; + r5.x = r6.x; + } else { + r5.z = r2.x; + } + r5.z = bitcast((bitcast(r5.z) + 1i)); + } + let v_25 = -(r5.xxxx); + r1.x = (r4.z + v_25.x); + let v_26 = -(r5.yyyy); + r2.x = (r4.w + v_26.x); + r2.y = ((-(r1.xxxx)).y + r2.x); + r2.z = bitcast(select(0u, 4294967295u, (0.0f < r2.y))); + r1.x = (r1.x * r4.w); + let v_27 = -(r1.xxxx); + r1.x = fma(r4.z, r2.x, v_27.x); + r1.x = (r1.x / r2.y); + let v_28 = bitcast>(r2.zzzz); + let v_29 = r1.xxxx; + r1.x = clamp(select(r5.xxxx, v_29, (v_28 != vec4())).x, 0.0f, 1.0f); + } + r1.x = ((-(r1.xxxx)).x + 1.0f); + let v_30 = fma(r3.xy, r1.xx, r1.zw); + let v_31 = r1; + r1 = vec4(v_30.x, v_31.y, v_30.y, v_31.w); + let v_32 = (r1.xz + v2.xy); + let v_33 = r1; + r1 = vec4(v_32.x, v_33.y, v_32.y, v_33.w); + let v_34 = r1; + r2 = vec4(v_34.xz, r2.zw); + } + r3 = textureSample(t0, s0, r2.xyxx.xy); + r4 = textureSample(t3, s3, r1.xzxx.xy); + let v_35 = fma(r4.xy, vec2(2.0f), vec2(-1.0f)); + let v_36 = r1; + r1 = vec4(v_35.x, v_36.y, v_35.y, v_36.w); + r1.w = dot(r1.xz, r1.xz); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.w = sqrt(abs(r1.wwww).w); + r2.z = max(cb12_12.tint_symbol_3[0u].w, 0.00100000004749745131f); + let v_37 = (r1.xz * r2.zz); + let v_38 = r1; + r1 = vec4(v_37.x, v_38.y, v_37.y, v_38.w); + let v_39 = (r1.zzz * v6.xyz); + r4 = vec4(v_39.xyz, r4.w); + let v_40 = fma(r1.xxx, v5.xyz, r4.xyz); + r4 = vec4(v_40.xyz, r4.w); + let v_41 = fma(r1.www, v3.xyz, r4.xyz); + r1 = vec4(v_41.x, r1.y, v_41.yz); + r2.z = dot(r1.xzw, r1.xzw); + r2.z = inverseSqrt(r2.z); + let v_42 = (r1.xzw * r2.zzz); + r4 = vec4(v_42.xyz, r4.w); + r5.x = dot(v5.xyz, cb3_3.tint_symbol_1[0u].xyz); + r5.y = dot(v6.xyz, cb3_3.tint_symbol_1[0u].xyz); + r1.x = dot(v3.xyz, cb3_3.tint_symbol_1[0u].xyz); + r1.z = ((-(v2.zzzz)).z + 1.0f); + r2.w = (cb2_2.tint_symbol[1u].x * cb12_12.tint_symbol_3[1u].x); + let v_43 = (r2.ww * r5.xy); + r5 = vec4(v_43.xy, r5.zw); + let v_44 = (r1.zz * r5.xy); + r5 = vec4(v_44.xy, r5.zw); + let v_45 = (r5.xy / r1.xx); + let v_46 = r1; + r1 = vec4(v_45.x, v_46.y, v_45.y, v_46.w); + r5 = textureSample(t2, s2, r2.xyxx.xy); + r6 = fma(r1.xzxz, vec4(0.87999999523162841797f, 0.87999999523162841797f, 0.76999998092651367188f, 0.76999998092651367188f), r2.xyxy); + r7 = textureSample(t2, s2, r6.xyxx.xy); + r2.w = ((-(r5.xxxx)).w + r7.x); + r2.w = (r2.w + -0.87999999523162841797f); + r6 = textureSample(t2, s2, r6.zwzz.xy); + r4.w = ((-(r5.xxxx)).w + r6.x); + r4.w = (r4.w + -0.76999998092651367188f); + r4.w = (r4.w + r4.w); + r6 = fma(r1.xzxz, vec4(0.66000002622604370117f, 0.66000002622604370117f, 0.55000001192092895508f, 0.55000001192092895508f), r2.xyxy); + r7 = textureSample(t2, s2, r6.xyxx.xy); + r5.y = ((-(r5.xxxx)).y + r7.x); + r5.y = (r5.y + -0.66000002622604370117f); + r6 = textureSample(t2, s2, r6.zwzz.xy); + r5.z = ((-(r5.xxxx)).z + r6.x); + r5.z = (r5.z + -0.55000001192092895508f); + r6 = fma(r1.xzxz, vec4(0.43999999761581420898f, 0.43999999761581420898f, 0.33000001311302185059f, 0.33000001311302185059f), r2.xyxy); + r7 = textureSample(t2, s2, r6.xyxx.xy); + r5.w = ((-(r5.xxxx)).w + r7.x); + r5.w = (r5.w + -0.43999999761581420898f); + let v_47 = (r5.yzw * vec3(4.0f, 6.0f, 8.0f)); + r5 = vec4(r5.x, v_47.xyz); + r6 = textureSample(t2, s2, r6.zwzz.xy); + r6.x = ((-(r5.xxxx)).x + r6.x); + r6.x = (r6.x + -0.33000001311302185059f); + r6.x = (r6.x * 10.0f); + let v_48 = fma(r1.xz, vec2(0.21999999880790710449f), r2.xy); + let v_49 = r1; + r1 = vec4(v_48.x, v_49.y, v_48.y, v_49.w); + r7 = textureSample(t2, s2, r1.xzxx.xy); + r1.x = ((-(r5.xxxx)).x + r7.x); + r1.x = (r1.x + -0.21999999880790710449f); + r1.x = (r1.x * 12.0f); + r1.z = max(r2.w, r4.w); + r1.z = max(r5.y, r1.z); + r1.z = max(r5.z, r1.z); + r1.z = max(r5.w, r1.z); + r1.z = max(r6.x, r1.z); + r1.x = clamp(max(r1.xxxx, r1.zzzz).x, 0.0f, 1.0f); + o2.w = fma((-(r1.xxxx)).w, cb12_12.tint_symbol_3[1u].z, 1.0f); + r0.z = ((-(r0.yyyy)).z + 1.0f); + r0.w = 0.0f; + let v_50 = bitcast>(r1.yyy); + let v_51 = r0.xzw; + let v_52 = select(r3.xyz, v_51, (v_50 != vec3())); + r0 = vec4(v_52.xyz, r0.w); + r0.w = clamp(fma(v3.xyz.zzzz, vec4(128.0f), vec4(-127.0f)).w, 0.0f, 1.0f); + r1.x = (r3.w * v1.w); + let v_53 = (v1.xy * cb2_2.tint_symbol[15u].zy); + let v_54 = r3; + r3 = vec4(v_54.x, v_53.xy, v_54.w); + o0.w = (r1.x * cb2_2.tint_symbol[15u].x); + let v_55 = fma(r4.xyz, vec3(0.5f), vec3(0.5f)); + o1 = vec4(v_55.xyz, o1.w); + r1.x = (cb12_12.tint_symbol_3[1u].w + -0.20000000298023223877f); + r1.x = clamp(((r1.xxxx * vec4(10.0f))).x, 0.0f, 1.0f); + o1.w = (r0.w * r1.x); + r3.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w); + let v_56 = (r3.xz * vec2(0.5f)); + r1 = vec4(v_56.xy, r1.zw); + let v_57 = sqrt(r1.xy); + o3 = vec4(v_57.xy, o3.zw); + r0.w = fma(r1.w, r2.z, -0.34999999403953552246f); + r0.w = clamp(((r0.wwww * vec4(1.53846156597137451172f))).w, 0.0f, 1.0f); + r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z); + r1.x = ((-(cb2_2.tint_symbol[16u].zzzz)).x + 1.0f); + r0.w = (r0.w * r1.x); + r0.w = (r3.y * r0.w); + r1.x = (cb12_12.tint_symbol_3[0u].y * 0.001953125f); + r1.z = (-(r1.xxxx)).z; + r2.x = fma((-(cb12_12.tint_symbol_3[0u].zzzz)).x, 0.5f, 1.0f); + r2.x = (r0.w * r2.x); + r0.w = (r0.w * cb12_12.tint_symbol_3[1u].w); + r2.x = fma(r2.x, -0.5f, 1.0f); + let v_58 = (r0.xyz * r2.xxx); + o0 = vec4(v_58.xyz, o0.w); + r0.x = clamp(((cb12_12.tint_symbol_3[0u].zzzz + vec4(0.40000000596046447754f))).x, 0.0f, 1.0f); + let v_59 = (r0.xx * vec2(0.5f, 0.48828125f)); + r0 = vec4(v_59.xy, r0.zw); + let v_60 = (-(cb12_12.tint_symbol_3[0u].zzzx)).yw; + let v_61 = r1; + r1 = vec4(v_61.x, v_60.x, v_61.z, v_60.y); + r0.z = 0.97000002861022949219f; + let v_62 = (r0.xyz + r1.yzw); + r0 = vec4(v_62.xyz, r0.w); + let v_63 = max(r0.xyz, vec3()); + r0 = vec4(v_63.xyz, r0.w); + let v_64 = fma(r0.xz, r0.ww, cb12_12.tint_symbol_3[0u].zx); + let v_65 = r2; + r2 = vec4(v_64.x, v_65.y, v_64.y, v_65.w); + r2.y = fma(r0.y, r0.w, r1.x); + let v_66 = sqrt(r2.xy); + o2 = vec4(v_66.xy, o2.zw); + o2.z = r2.z; + o3 = vec4(o3.xy, vec2(0.0f, 1.00188386440277099609f)); +} + +struct tint_symbol_4 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4) -> tint_symbol_4 { + main_inner(v1, v2, v3, v4, v5, v6); + return tint_symbol_4(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/0081a738fe9b7258.wgsl b/b/8b0b5899ed/shaders/0081a738fe9b7258.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..016d27b651e7cdb23f051e05e78b1c61bcb2d087 --- /dev/null +++ b/b/8b0b5899ed/shaders/0081a738fe9b7258.wgsl @@ -0,0 +1,28 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +@group(1u) @binding(47u) var t15 : texture_multisampled_2d; + +var v0 : vec4; + +var oDepth : f32; + +fn main_inner(v : vec4) { + var v_1 : vec4 = v; + v_1.w = (1.0f / v.w); + v0 = v_1; + let v_2 = v0.xy; + let v_3 = max(v_2, vec2(-2147483648.0f)); + let v_4 = bitcast>(select(select(vec2(v_3), vec2(2147483647i), (v_3 >= vec2(2147483648.0f))), vec2(), !((v_2 == v_2)))); + r0 = vec4(v_4.xy, r0.zw); + r0 = vec4(r0.xy, vec2()); + r0.x = textureLoad(t15, bitcast>(r0.xy), 0i).x; + oDepth = r0.x; +} + +@fragment +fn main(@builtin(position) v_5 : vec4) -> @builtin(frag_depth) f32 { + main_inner(v_5); + return oDepth; +} diff --git a/b/8b0b5899ed/shaders/0083d1a975976c79.wgsl b/b/8b0b5899ed/shaders/0083d1a975976c79.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..7c508f7e70d3a26ec3b98791efe4f5d79ae2cbc9 --- /dev/null +++ b/b/8b0b5899ed/shaders/0083d1a975976c79.wgsl @@ -0,0 +1,145 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +struct cb17_struct { + tint_symbol : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb46_struct { + tint_symbol_1 : array, 46u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb46_struct; + +struct cb4_struct { + tint_symbol_2 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb2_struct { + tint_symbol_3 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4) { + r0.x = dot(v4.xyz, v4.xyz); + r0.x = inverseSqrt(r0.x); + let v = (r0.xxx * v4.xyz); + r0 = vec4(v.xyz, r0.w); + r0.w = dot(v3.xyz, v3.xyz); + r0.w = inverseSqrt(r0.w); + let v_1 = (r0.www * v3.xyz); + r1 = vec4(v_1.xyz, r1.w); + r0.w = fma(v3.z, r0.w, -0.34999999403953552246f); + r0.w = clamp(((r0.wwww * vec4(1.53846156597137451172f))).w, 0.0f, 1.0f); + r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z); + r1.w = dot((-(r0.xyzx)).xyz, r1.xyz); + r1.w = (r1.w + r1.w); + let v_2 = -(r1.wwww); + let v_3 = -(r0.xyzx); + let v_4 = fma(r1.xyz, v_2.xyz, v_3.xyz); + r0 = vec4(v_4.xyz, r0.w); + let v_5 = fma(r1.xyz, vec3(0.5f), vec3(0.5f)); + o1 = vec4(v_5.xyz, o1.w); + r0.y = dot(r0.xyz, r0.xyz); + r0.y = inverseSqrt(r0.y); + let v_6 = fma(r0.xz, r0.yy, vec2(1.0f)); + r0 = vec4(v_6.xy, r0.zw); + let v_7 = (r0.xy * vec2(-0.5f)); + r0 = vec4(v_7.xy, r0.zw); + r1 = textureSample(t3, s3, r0.xyxx.xy); + r2 = textureSample(t0, s0, v2.xy.xyxx.xy); + let v_8 = fma(r1.xyz, cb12_12.tint_symbol_3[1u].www, r2.xyz); + r0 = vec4(v_8.xyz, r0.w); + r1.x = (r2.w * v1.w); + o0.w = (r1.x * cb2_2.tint_symbol[15u].x); + r1.x = ((-(cb2_2.tint_symbol[16u].zzzz)).x + 1.0f); + r0.w = (r0.w * r1.x); + let v_9 = (v1.xy * cb2_2.tint_symbol[15u].zy); + let v_10 = r1; + r1 = vec4(v_10.x, v_9.xy, v_10.w); + r0.w = (r0.w * r1.y); + r2 = textureSample(t2, s2, v2.xy.xyxx.xy); + let v_11 = (r2.xy * r2.xy); + r2 = vec4(v_11.xy, r2.zw); + r1.y = (r2.w * cb12_12.tint_symbol_3[0u].y); + r3.y = (r1.y * 0.001953125f); + r1.y = dot(r2.xyz, cb12_12.tint_symbol_3[1u].xyz); + r3.x = (r1.y * cb12_12.tint_symbol_3[0u].z); + r1.y = clamp(fma(r1.yyyy, cb12_12.tint_symbol_3[0u].zzzz, vec4(0.40000000596046447754f)).y, 0.0f, 1.0f); + let v_12 = (r1.yy * vec2(0.5f, 0.48828125f)); + r2 = vec4(v_12.xy, r2.zw); + r1.y = fma((-(r3.xxxx)).y, 0.5f, 1.0f); + r1.y = (r0.w * r1.y); + r1.y = fma(r1.y, -0.5f, 1.0f); + let v_13 = (r0.xyz * r1.yyy); + o0 = vec4(v_13.xyz, o0.w); + o1.w = clamp(fma(v3.xyz.zzzz, vec4(128.0f), vec4(-127.0f)).w, 0.0f, 1.0f); + r2.z = 0.97000002861022949219f; + r3.z = cb12_12.tint_symbol_3[0u].x; + let v_14 = -(r3.xyzx); + let v_15 = (r2.xyz + v_14.xyz); + r0 = vec4(v_15.xyz, r0.w); + let v_16 = max(r0.xyz, vec3()); + r0 = vec4(v_16.xyz, r0.w); + let v_17 = fma(r0.xyz, r0.www, r3.xyz); + r0 = vec4(v_17.xyz, r0.w); + let v_18 = sqrt(r0.xy); + o2 = vec4(v_18.xy, o2.zw); + o2.z = r0.z; + o2.w = 1.0f; + r1.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w); + let v_19 = (r1.xz * vec2(0.5f)); + r0 = vec4(v_19.xy, r0.zw); + let v_20 = sqrt(r0.xy); + o3 = vec4(v_20.xy, o3.zw); + o3 = vec4(o3.xy, vec2(0.0f, 1.00188386440277099609f)); +} + +struct tint_symbol_4 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4) -> tint_symbol_4 { + main_inner(v1, v2, v3, v4); + return tint_symbol_4(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/00845f3f8756888a.wgsl b/b/8b0b5899ed/shaders/00845f3f8756888a.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..ce8a2a8a1636585431a83b16ec5466658d7afc7d --- /dev/null +++ b/b/8b0b5899ed/shaders/00845f3f8756888a.wgsl @@ -0,0 +1,89 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +struct cb4_struct { + tint_symbol : array, 4u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb4_struct; + +struct cb29_struct { + tint_symbol_1 : array, 29u>, +} + +@group(0u) @binding(12u) var cb12_12 : cb29_struct; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v0 : vec4, v1 : vec4, v3 : vec2) { + r0.x = bitcast(select(0u, 4294967295u, !((0.0f == cb12_12.tint_symbol_1[23u].w)))); + let v = (v0.yyy * cb1_1.tint_symbol[1u].xyz); + r0 = vec4(r0.x, v.xyz); + let v_1 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.yzw); + r0 = vec4(r0.x, v_1.xyz); + let v_2 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.yzw); + r0 = vec4(r0.x, v_2.xyz); + let v_3 = fma(v0.www, cb1_1.tint_symbol[3u].xyz, r0.yzw); + r0 = vec4(r0.x, v_3.xyz); + r1 = (r0.zzzz * cb12_12.tint_symbol_1[20u]); + r1 = fma(r0.yyyy, cb12_12.tint_symbol_1[19u], r1); + r1 = fma(r0.wwww, cb12_12.tint_symbol_1[21u], r1); + r1 = (r1 + cb12_12.tint_symbol_1[22u]); + r0.y = bitcast(select(0u, 4294967295u, (r1.z < 0.0f))); + r0.z = (0.10000000149011611938f / r1.w); + let v_4 = bitcast(r0.y); + let v_5 = r0.z; + r0.y = select(r1.z, v_5, (v_4 != 0u)); + r0.z = bitcast(select(0u, 4294967295u, (r1.w < r1.z))); + r0.w = (r1.w + -0.10000000149011611938f); + let v_6 = bitcast(r0.z); + let v_7 = r0.w; + r0.z = select(r1.z, v_7, (v_6 != 0u)); + let v_8 = bitcast(r0.x); + let v_9 = r0.y; + r0.x = select(r0.z, v_9, (v_8 != 0u)); + r0.y = bitcast(select(0u, 4294967295u, (0.0f < r1.w))); + let v_10 = bitcast(r0.y); + let v_11 = r0.x; + o0.z = select(r1.z, v_11, (v_10 != 0u)); + let v_12 = r1; + o0 = vec4(v_12.xy, o0.z, v_12.w); + o1 = v1; + let v_13 = fma(v3, cb12_12.tint_symbol_1[25u].zw, cb12_12.tint_symbol_1[24u].xy); + r0 = vec4(v_13.xy, r0.zw); + o2 = fma(cb12_12.tint_symbol_1[17u].xy, cb12_12.tint_symbol_1[27u].zw, r0.xy).xyxy; + let v_14 = fma(v3, cb12_12.tint_symbol_1[26u].xy, cb12_12.tint_symbol_1[24u].zw); + r0 = vec4(v_14.xy, r0.zw); + let v_15 = fma(cb12_12.tint_symbol_1[17u].zw, cb12_12.tint_symbol_1[28u].xy, r0.xy); + o3 = vec4(v_15.xy, o3.zw); + let v_16 = fma(v3, cb12_12.tint_symbol_1[26u].zw, cb12_12.tint_symbol_1[25u].xy); + r0 = vec4(v_16.xy, r0.zw); + let v_17 = fma(cb12_12.tint_symbol_1[18u].xy, cb12_12.tint_symbol_1[28u].zw, r0.xy); + o3 = vec4(o3.xy, v_17.xy); +} + +struct tint_symbol_2 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(3u) v3 : vec2) -> tint_symbol_2 { + main_inner(v0, v1, v3); + return tint_symbol_2(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.consts.json b/b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.wgsl b/b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..480cd71274068d0b8ab9d5d3d7cc3544a25864e3 --- /dev/null +++ b/b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.wgsl @@ -0,0 +1,1213 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb3_struct { + tint_symbol_4 : array, 3u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb3_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(21u) var s5 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(36u) var t4 : texture_2d; + +@group(1u) @binding(37u) var t5 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v7 : vec4; + +var v8 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v7 = v_2; + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t0, s0, v2.xy.xyxx.xy); + r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x))); + v_3((bitcast(r1.x) != 0u)); + r1 = textureSample(t4, s4, v2.xy.xyxx.xy); + let v_4 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_4.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[2u].x, 0.00100000004749745131f); + let v_5 = (r1.ww * r1.xy); + r1 = vec4(v_5.xy, r1.zw); + let v_6 = (r1.yyy * v5.xyz); + r2 = vec4(v_6.xyz, r2.w); + let v_7 = fma(r1.xxx, v4.xyz, r2.xyz); + r1 = vec4(v_7.xy, r1.z, v_7.z); + let v_8 = fma(r1.zzz, v3.xyz, r1.xyw); + r1 = vec4(v_8.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_9 = (r1.www * r1.xyz); + r2 = vec4(v_9.xyz, r2.w); + r3 = textureSample(t5, s5, v2.xy.xyxx.xy); + let v_10 = (r3.xy * r3.xy); + r1 = vec4(v_10.xy, r1.zw); + r1.x = (r1.x * cb12_12.tint_symbol_4[0u].z); + let v_11 = (r0.xyz * v1.xyz); + r0 = vec4(v_11.xyz, r0.w); + r0.w = (r0.w * v0.w); + let v_12 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r3 = vec4(v_12.xy, r3.zw); + let v_13 = (r0.xyz * r0.xyz); + r0 = vec4(v_13.xyz, r0.w); + let v_14 = -(v6.xyzx); + let v_15 = (v_14.xyz + cb1_1.tint_symbol[15u].xyz); + r4 = vec4(v_15.xyz, r4.w); + r2.w = dot(r4.xyz, r4.xyz); + r2.w = inverseSqrt(r2.w); + let v_16 = (r2.www * r4.xyz); + r5 = vec4(v_16.xyz, r5.w); + let v_17 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_18 = fma(r4.xyz, r2.www, v_17.xyz); + r6 = vec4(v_18.xyz, r6.w); + r3.z = dot(r6.xyz, r6.xyz); + r3.z = inverseSqrt(r3.z); + let v_19 = (r3.zzz * r6.xyz); + r6 = vec4(v_19.xyz, r6.w); + r1.x = clamp(r1.xxxx.x, 0.0f, 1.0f); + r3.z = fma(r1.y, cb12_12.tint_symbol_4[0u].y, -500.0f); + r3.z = max(r3.z, 0.0f); + let v_20 = -(r3.zzzz); + r1.y = fma(r1.y, cb12_12.tint_symbol_4[0u].y, v_20.y); + r3.z = (r3.z * 558.0f); + r1.y = fma(r1.y, 3.0f, r3.z); + r3.z = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz); + let v_21 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r7 = vec4(v_21.xyz, r7.w); + let v_22 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_22.xyz, r8.w); + let v_23 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_23.xyz, r8.w); + let v_24 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_24.xyz, r8.w); + let v_25 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_25.xyz, r9.w); + let v_26 = &(x0[0u]); + let v_27 = r9; + *(v_26) = vec4(v_27.xyz, (*(v_26)).w); + let v_28 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_28.xyz, r10.w); + let v_29 = &(x0[1u]); + let v_30 = r10; + *(v_29) = vec4(v_30.xyz, (*(v_29)).w); + let v_31 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_31.xyz, r11.w); + let v_32 = &(x0[2u]); + let v_33 = r11; + *(v_32) = vec4(v_33.xyz, (*(v_32)).w); + let v_34 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_34.xyz, r8.w); + let v_35 = &(x0[3u]); + let v_36 = r8; + *(v_35) = vec4(v_36.xyz, (*(v_35)).w); + let v_37 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_38 = r12; + r12 = vec4(v_38.x, v_37.x, v_38.z, v_37.y); + r3.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r3.w = (r3.w * 0.5f); + let v_39 = abs(r11.yyyy); + r4.w = max(v_39.w, abs(r11.xxxx).w); + r4.w = bitcast(select(0u, 4294967295u, (r4.w < r3.w))); + let v_40 = (bitcast(r4.w) != 0u); + let v_41 = bitcast(v.tint_symbol_6[0i].x); + r4.w = select(bitcast(v.tint_symbol_6[1i].x), v_41, v_40); + let v_42 = abs(r10.yyyy); + r5.w = max(v_42.w, abs(r10.xxxx).w); + r5.w = bitcast(select(0u, 4294967295u, (r5.w < r3.w))); + let v_43 = bitcast(r5.w); + r4.w = select(r4.w, bitcast(v.tint_symbol_6[2i].x), (v_43 != 0u)); + let v_44 = abs(r9.yyyy); + r5.w = max(v_44.w, abs(r9.xxxx).w); + r3.w = bitcast(select(0u, 4294967295u, (r5.w < r3.w))); + let v_45 = bitcast(r3.w); + r3.w = select(r4.w, 0.0f, (v_45 != 0u)); + let v_46 = x0[bitcast(r3.w)]; + r9 = vec4(v_46.xyz, r9.w); + r3.w = f32(bitcast(r3.w)); + r4.w = (r3.w + 0.5f); + r4.w = (r4.w * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r3.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r3.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r5.w = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r4.w); + r4.w = bitcast(select(0u, 4294967295u, !((r3.w == 0.0f)))); + r3.w = ((-(r3.wwww)).w + r9.z); + let v_47 = dpdx(r10.xyy); + r11 = vec4(v_47.xy, r11.z, v_47.z); + r11.z = dpdx(r3.w); + let v_48 = dpdy(r10.yxy); + r13 = vec4(v_48.xyz, r13.w); + r13.w = dpdy(r3.w); + let v_49 = (r11.yw * r13.yw); + r8 = vec4(r8.xy, v_49.xy); + let v_50 = -(r8.zwzz); + let v_51 = fma(r11.xz, r13.xz, v_50.xy); + r14 = vec4(v_51.xy, r14.zw); + r6.w = (1.0f / r14.x); + r7.w = (r11.z * r13.y); + let v_52 = -(r7.wwww); + r14.z = fma(r11.x, r13.w, v_52.z); + let v_53 = (r6.ww * r14.yz); + r8 = vec4(r8.xy, v_53.xy); + let v_54 = max(r8.zw, vec2()); + r8 = vec4(r8.xy, v_54.xy); + let v_55 = min(r8.zw, vec2(0.5f)); + r8 = vec4(r8.xy, v_55.xy); + r3.w = fma((-(r5.wwww)).w, r8.z, r3.w); + r3.w = fma((-(r5.wwww)).w, r8.w, r3.w); + let v_56 = bitcast(r4.w); + let v_57 = r3.w; + r12.z = select(r9.z, v_57, (v_56 != 0u)); + r10.z = 0.0f; + let v_58 = (r10.xyz + r12.ywz); + r9 = vec4(v_58.xyz, r9.w); + let v_59 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_59.xy, r12.zw); + let v_60 = (r10.xyz + r12.xyz); + r11 = vec4(v_60.xyz, r11.w); + let v_61 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_61.xy, r12.zw); + let v_62 = (r10.xyz + r12.xyz); + r13 = vec4(v_62.xyz, r13.w); + let v_63 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_63.xy, r12.zw); + let v_64 = (r10.xyz + r12.xyz); + r14 = vec4(v_64.xyz, r14.w); + let v_65 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_65.xy, r12.zw); + let v_66 = (r10.xyz + r12.xyz); + r15 = vec4(v_66.xyz, r15.w); + let v_67 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_67.xy, r12.zw); + let v_68 = (r10.xyz + r12.xyz); + r16 = vec4(v_68.xyz, r16.w); + let v_69 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_69.xy, r12.zw); + let v_70 = (r10.xyz + r12.xyz); + r17 = vec4(v_70.xyz, r17.w); + let v_71 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_71.xy, r12.zw); + let v_72 = (r10.xyz + r12.xyz); + r18 = vec4(v_72.xyz, r18.w); + let v_73 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_73.xy, r12.zw); + let v_74 = (r10.xyz + r12.xyz); + r19 = vec4(v_74.xyz, r19.w); + let v_75 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_75.xy, r12.zw); + let v_76 = (r10.xyz + r12.xyz); + r20 = vec4(v_76.xyz, r20.w); + let v_77 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_77.xy, r12.zw); + let v_78 = (r10.xyz + r12.xyz); + r21 = vec4(v_78.xyz, r21.w); + let v_79 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_79.xy, r12.zw); + let v_80 = (r10.xyz + r12.xyz); + r22 = vec4(v_80.xyz, r22.w); + let v_81 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_81.xy, r12.zw); + let v_82 = (r10.xyz + r12.xyz); + r23 = vec4(v_82.xyz, r23.w); + let v_83 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_83.xy, r12.zw); + let v_84 = (r10.xyz + r12.xyz); + r24 = vec4(v_84.xyz, r24.w); + let v_85 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_85.xy, r12.zw); + let v_86 = (r10.xyz + r12.xyz); + r25 = vec4(v_86.xyz, r25.w); + let v_87 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_87.xy, r12.zw); + let v_88 = (r10.xyz + r12.xyz); + r10 = vec4(v_88.xyz, r10.w); + let v_89 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_89.xy, r9.z); + let v_90 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_90.xy, r11.z); + let v_91 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_91.xy, r13.z); + let v_92 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_92.xy, r14.z); + let v_93 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_93.xy, r15.z); + let v_94 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_94.xy, r16.z); + let v_95 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_95.xy, r17.z); + let v_96 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_96.xy, r18.z); + let v_97 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_97.xy, r19.z); + let v_98 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_98.xy, r20.z); + let v_99 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_99.xy, r21.z); + let v_100 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_100.xy, r22.z); + let v_101 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_101.xy, r23.z); + let v_102 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_102.xy, r24.z); + let v_103 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_103.xy, r25.z); + let v_104 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_104.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r3.w = dot(r9, vec4(1.0f)); + r3.z = clamp(fma(r3.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f); + let v_105 = abs(r8.yyyy); + r4.w = max(v_105.w, abs(r8.xxxx).w); + r4.w = clamp(fma(r4.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r3.z = ((-(r3.zzzz)).z + 1.0f); + r3.z = (r4.w * r3.z); + r3.z = fma(r3.w, 0.0625f, r3.z); + let v_106 = (r3.xyz * r3.xyz); + r3 = vec4(v_106.xyz, r3.w); + r3.z = min(r3.z, 1.0f); + r3.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r3.w = sqrt(r3.w); + r3.w = (r3.w * cb6_6.tint_symbol_5[3u].z); + let v_107 = -(r3.zzzz); + r3.z = fma(r3.w, v_107.z, r3.z); + let v_108 = dot(r2.xyz, v_17.xyz); + r3.w = clamp(vec4(v_108, v_108, v_108, v_108).w, 0.0f, 1.0f); + let v_109 = dot(r5.xyz, r2.xyz); + r8.x = clamp(vec4(v_109, v_109, v_109, v_109).x, 0.0f, 1.0f); + let v_110 = dot(r6.xyz, v_17.xyz); + r8.y = clamp(vec4(v_110, v_110, v_110, v_110).y, 0.0f, 1.0f); + let v_111 = ((-(r8.xyxx)).xy + vec2(1.0f)); + r8 = vec4(v_111.xy, r8.zw); + let v_112 = (r8.xy * r8.xy); + r8 = vec4(r8.xy, v_112.xy); + let v_113 = (r8.zw * r8.zw); + r8 = vec4(r8.xy, v_113.xy); + let v_114 = (r8.xy * r8.zw); + r8 = vec4(v_114.xy, r8.zw); + r4.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f); + let v_115 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r4.ww); + r8 = vec4(v_115.xy, r8.zw); + let v_116 = (r1.yy + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(r8.xy, v_116.xy); + r1.y = (r8.z * 0.125f); + r5.w = fma((-(r1.xxxx)).w, r8.x, 1.0f); + r6.x = dot(r2.xyz, r6.xyz); + r6.x = clamp(((r6.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r6.x = log2(r6.x); + r6.x = (r6.x * r8.w); + r6.x = exp2(r6.x); + r6.x = (r8.y * r6.x); + r6.x = (r1.y * r6.x); + r6.x = (r1.x * r6.x); + r6.x = (r3.w * r6.x); + r3.w = (r3.w * r5.w); + let v_117 = fma(r0.xyz, r3.www, r6.xxx); + r6 = vec4(v_117.xyz, r6.w); + let v_118 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz); + r6 = vec4(v_118.xyz, r6.w); + r3.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r3.w) != 0u)) { + r9 = vec4(vec3(), r9.w); + r8 = vec4(vec3(), r8.w); + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_119 = (v_14.xyz + cb3_3.tint_symbol_2[3u].xyz); + r8 = vec4(v_119.xyz, r8.w); + let v_120 = (v6.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r9 = vec4(v_120.xyz, r9.w); + r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w); + let v_121 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_121.xyz, r9.w); + let v_122 = (r9.xyz + v_14.xyz); + r9 = vec4(v_122.xyz, r9.w); + let v_123 = bitcast>(r6.www); + let v_124 = r8.xyz; + let v_125 = select(r9.xyz, v_124, (v_123 != vec3())); + r8 = vec4(v_125.xyz, r8.w); + r6.w = dot(r8.xyz, r8.xyz); + let v_126 = (r8.xyz + vec3(0.00000099999999747524f)); + r8 = vec4(v_126.xyz, r8.w); + r7.w = dot(r8.xyz, r8.xyz); + r7.w = inverseSqrt(r7.w); + let v_127 = (r7.www * r8.xyz); + r8 = vec4(v_127.xyz, r8.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[11u].w); + r6.w = (r6.w / r7.w); + let v_128 = -(cb3_3.tint_symbol_2[11u].xyzx); + r7.w = dot(r8.xyz, v_128.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_129 = dot(r8.xyz, r2.xyz); + r9.x = clamp(vec4(v_129, v_129, v_129, v_129).x, 0.0f, 1.0f); + r7.w = (r7.w * r9.x); + r9.x = (r6.w * r7.w); + let v_130 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_130.xyz, r9.w); + let v_131 = (r0.xyz * r9.xyz); + r9 = vec4(v_131.xyz, r9.w); + let v_132 = fma(r4.xyz, r2.www, r8.xyz); + r8 = vec4(v_132.xyz, r8.w); + r9.w = dot(r8.xyz, r8.xyz); + r9.w = inverseSqrt(r9.w); + let v_133 = (r8.xyz * r9.www); + r8 = vec4(v_133.xyz, r8.w); + let v_134 = dot(r8.xyz, r5.xyz); + r9.w = clamp(vec4(v_134, v_134, v_134, v_134).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.x = (r9.w * r9.w); + r10.x = (r10.x * r10.x); + r9.w = (r9.w * r10.x); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_135 = dot(r8.xyz, r2.xyz); + r8.x = clamp(vec4(v_135, v_135, v_135, v_135).x, 0.0f, 1.0f); + r8.x = log2(r8.x); + r8.x = (r8.x * r8.w); + r8.x = exp2(r8.x); + r8.x = (r8.x * r9.w); + r7.w = (r7.w * r8.x); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_136 = (r6.www * cb3_3.tint_symbol_2[19u].xyz); + r8 = vec4(v_136.xyz, r8.w); + } + r6.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r7.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + let v_137 = bitcast(r7.w); + let v_138 = r6.w; + r3.w = select(r3.w, v_138, (v_137 != 0u)); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_139 = (v_14.xyz + cb3_3.tint_symbol_2[4u].xyz); + r10 = vec4(v_139.xyz, r10.w); + let v_140 = (v6.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r11 = vec4(v_140.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w); + let v_141 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_141.xyz, r11.w); + let v_142 = (r11.xyz + v_14.xyz); + r11 = vec4(v_142.xyz, r11.w); + let v_143 = bitcast>(r6.www); + let v_144 = r10.xyz; + let v_145 = select(r11.xyz, v_144, (v_143 != vec3())); + r10 = vec4(v_145.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_146 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_146.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_147 = (r7.www * r10.xyz); + r10 = vec4(v_147.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[12u].w); + r6.w = (r6.w / r7.w); + let v_148 = -(cb3_3.tint_symbol_2[12u].xyzx); + r7.w = dot(r10.xyz, v_148.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_149 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_149, v_149, v_149, v_149).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_150 = (r9.www * cb3_3.tint_symbol_2[20u].xyz); + r11 = vec4(v_150.xyz, r11.w); + let v_151 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_151.xyz, r9.w); + let v_152 = fma(r4.xyz, r2.www, r10.xyz); + r10 = vec4(v_152.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_153 = (r9.www * r10.xyz); + r10 = vec4(v_153.xyz, r10.w); + let v_154 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_154, v_154, v_154, v_154).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_155 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_155, v_155, v_155, v_155).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_156 = fma(r6.www, cb3_3.tint_symbol_2[20u].xyz, r8.xyz); + r8 = vec4(v_156.xyz, r8.w); + } + } else { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_157 = (v_14.xyz + cb3_3.tint_symbol_2[5u].xyz); + r10 = vec4(v_157.xyz, r10.w); + let v_158 = (v6.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r11 = vec4(v_158.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w); + let v_159 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_159.xyz, r11.w); + let v_160 = (r11.xyz + v_14.xyz); + r11 = vec4(v_160.xyz, r11.w); + let v_161 = bitcast>(r6.www); + let v_162 = r10.xyz; + let v_163 = select(r11.xyz, v_162, (v_161 != vec3())); + r10 = vec4(v_163.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_164 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_164.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_165 = (r7.www * r10.xyz); + r10 = vec4(v_165.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[13u].w); + r6.w = (r6.w / r7.w); + let v_166 = -(cb3_3.tint_symbol_2[13u].xyzx); + r7.w = dot(r10.xyz, v_166.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_167 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_167, v_167, v_167, v_167).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_168 = (r9.www * cb3_3.tint_symbol_2[21u].xyz); + r11 = vec4(v_168.xyz, r11.w); + let v_169 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_169.xyz, r9.w); + let v_170 = fma(r4.xyz, r2.www, r10.xyz); + r10 = vec4(v_170.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_171 = (r9.www * r10.xyz); + r10 = vec4(v_171.xyz, r10.w); + let v_172 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_172, v_172, v_172, v_172).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_173 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_173, v_173, v_173, v_173).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_174 = fma(r6.www, cb3_3.tint_symbol_2[21u].xyz, r8.xyz); + r8 = vec4(v_174.xyz, r8.w); + } + } + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_175 = (v_14.xyz + cb3_3.tint_symbol_2[6u].xyz); + r10 = vec4(v_175.xyz, r10.w); + let v_176 = (v6.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r11 = vec4(v_176.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[22u].w); + let v_177 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.www, cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_177.xyz, r11.w); + let v_178 = (r11.xyz + v_14.xyz); + r11 = vec4(v_178.xyz, r11.w); + let v_179 = bitcast>(r6.www); + let v_180 = r10.xyz; + let v_181 = select(r11.xyz, v_180, (v_179 != vec3())); + r10 = vec4(v_181.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_182 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_182.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_183 = (r7.www * r10.xyz); + r10 = vec4(v_183.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[14u].w); + r6.w = (r6.w / r7.w); + let v_184 = -(cb3_3.tint_symbol_2[14u].xyzx); + r7.w = dot(r10.xyz, v_184.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_185 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_185, v_185, v_185, v_185).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_186 = (r9.www * cb3_3.tint_symbol_2[22u].xyz); + r11 = vec4(v_186.xyz, r11.w); + let v_187 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_187.xyz, r9.w); + let v_188 = fma(r4.xyz, r2.www, r10.xyz); + r10 = vec4(v_188.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_189 = (r9.www * r10.xyz); + r10 = vec4(v_189.xyz, r10.w); + let v_190 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_190, v_190, v_190, v_190).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_191 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_191, v_191, v_191, v_191).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_192 = fma(r6.www, cb3_3.tint_symbol_2[22u].xyz, r8.xyz); + r8 = vec4(v_192.xyz, r8.w); + } + } + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (4i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f))); + let v_193 = (v_14.xyz + cb3_3.tint_symbol_2[7u].xyz); + r10 = vec4(v_193.xyz, r10.w); + let v_194 = (v6.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz); + r11 = vec4(v_194.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[15u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[23u].w); + let v_195 = fma(cb3_3.tint_symbol_2[15u].xyz, r7.www, cb3_3.tint_symbol_2[7u].xyz); + r11 = vec4(v_195.xyz, r11.w); + let v_196 = (r11.xyz + v_14.xyz); + r11 = vec4(v_196.xyz, r11.w); + let v_197 = bitcast>(r6.www); + let v_198 = r10.xyz; + let v_199 = select(r11.xyz, v_198, (v_197 != vec3())); + r10 = vec4(v_199.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_200 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_200.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_201 = (r7.www * r10.xyz); + r10 = vec4(v_201.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[7u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[15u].w); + r6.w = (r6.w / r7.w); + let v_202 = -(cb3_3.tint_symbol_2[15u].xyzx); + r7.w = dot(r10.xyz, v_202.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f); + let v_203 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_203, v_203, v_203, v_203).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_204 = (r9.www * cb3_3.tint_symbol_2[23u].xyz); + r11 = vec4(v_204.xyz, r11.w); + let v_205 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_205.xyz, r9.w); + let v_206 = fma(r4.xyz, r2.www, r10.xyz); + r10 = vec4(v_206.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_207 = (r9.www * r10.xyz); + r10 = vec4(v_207.xyz, r10.w); + let v_208 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_208, v_208, v_208, v_208).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_209 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_209, v_209, v_209, v_209).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_210 = fma(r6.www, cb3_3.tint_symbol_2[23u].xyz, r8.xyz); + r8 = vec4(v_210.xyz, r8.w); + } + } + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (5i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f))); + let v_211 = (v_14.xyz + cb3_3.tint_symbol_2[8u].xyz); + r10 = vec4(v_211.xyz, r10.w); + let v_212 = (v6.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz); + r11 = vec4(v_212.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[16u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[24u].w); + let v_213 = fma(cb3_3.tint_symbol_2[16u].xyz, r7.www, cb3_3.tint_symbol_2[8u].xyz); + r11 = vec4(v_213.xyz, r11.w); + let v_214 = (r11.xyz + v_14.xyz); + r11 = vec4(v_214.xyz, r11.w); + let v_215 = bitcast>(r6.www); + let v_216 = r10.xyz; + let v_217 = select(r11.xyz, v_216, (v_215 != vec3())); + r10 = vec4(v_217.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_218 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_218.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_219 = (r7.www * r10.xyz); + r10 = vec4(v_219.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[8u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[16u].w); + r6.w = (r6.w / r7.w); + let v_220 = -(cb3_3.tint_symbol_2[16u].xyzx); + r7.w = dot(r10.xyz, v_220.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f); + let v_221 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_221, v_221, v_221, v_221).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_222 = (r9.www * cb3_3.tint_symbol_2[24u].xyz); + r11 = vec4(v_222.xyz, r11.w); + let v_223 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_223.xyz, r9.w); + let v_224 = fma(r4.xyz, r2.www, r10.xyz); + r10 = vec4(v_224.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_225 = (r9.www * r10.xyz); + r10 = vec4(v_225.xyz, r10.w); + let v_226 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_226, v_226, v_226, v_226).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_227 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_227, v_227, v_227, v_227).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_228 = fma(r6.www, cb3_3.tint_symbol_2[24u].xyz, r8.xyz); + r8 = vec4(v_228.xyz, r8.w); + } + } + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (6i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f))); + let v_229 = (v_14.xyz + cb3_3.tint_symbol_2[9u].xyz); + r10 = vec4(v_229.xyz, r10.w); + let v_230 = (v6.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz); + r11 = vec4(v_230.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[17u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[25u].w); + let v_231 = fma(cb3_3.tint_symbol_2[17u].xyz, r7.www, cb3_3.tint_symbol_2[9u].xyz); + r11 = vec4(v_231.xyz, r11.w); + let v_232 = (r11.xyz + v_14.xyz); + r11 = vec4(v_232.xyz, r11.w); + let v_233 = bitcast>(r6.www); + let v_234 = r10.xyz; + let v_235 = select(r11.xyz, v_234, (v_233 != vec3())); + r10 = vec4(v_235.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_236 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_236.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_237 = (r7.www * r10.xyz); + r10 = vec4(v_237.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[9u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[17u].w); + r6.w = (r6.w / r7.w); + let v_238 = -(cb3_3.tint_symbol_2[17u].xyzx); + r7.w = dot(r10.xyz, v_238.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f); + let v_239 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_239, v_239, v_239, v_239).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_240 = (r9.www * cb3_3.tint_symbol_2[25u].xyz); + r11 = vec4(v_240.xyz, r11.w); + let v_241 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_241.xyz, r9.w); + let v_242 = fma(r4.xyz, r2.www, r10.xyz); + r10 = vec4(v_242.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_243 = (r9.www * r10.xyz); + r10 = vec4(v_243.xyz, r10.w); + let v_244 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_244, v_244, v_244, v_244).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_245 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_245, v_245, v_245, v_245).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r1.y * r6.w); + let v_246 = fma(r6.www, cb3_3.tint_symbol_2[25u].xyz, r8.xyz); + r8 = vec4(v_246.xyz, r8.w); + } + } + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (7i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f))); + let v_247 = (v_14.xyz + cb3_3.tint_symbol_2[10u].xyz); + r10 = vec4(v_247.xyz, r10.w); + let v_248 = (v6.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz); + r11 = vec4(v_248.xyz, r11.w); + r6.w = dot(r11.xyz, cb3_3.tint_symbol_2[18u].xyz); + r6.w = clamp(((r6.wwww / cb3_3.tint_symbol_2[26u].wwww)).w, 0.0f, 1.0f); + r6.w = (r6.w * cb3_3.tint_symbol_2[26u].w); + let v_249 = fma(cb3_3.tint_symbol_2[18u].xyz, r6.www, cb3_3.tint_symbol_2[10u].xyz); + r11 = vec4(v_249.xyz, r11.w); + let v_250 = (r11.xyz + v_14.xyz); + r11 = vec4(v_250.xyz, r11.w); + let v_251 = bitcast>(r3.www); + let v_252 = r10.xyz; + let v_253 = select(r11.xyz, v_252, (v_251 != vec3())); + r10 = vec4(v_253.xyz, r10.w); + r3.w = dot(r10.xyz, r10.xyz); + let v_254 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_254.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + r6.w = inverseSqrt(r6.w); + let v_255 = (r6.www * r10.xyz); + r10 = vec4(v_255.xyz, r10.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r6.w = ((-(cb3_3.tint_symbol_2[18u].wwww)).w + 1.0f); + r6.w = fma(r6.w, r3.w, cb3_3.tint_symbol_2[18u].w); + r3.w = (r3.w / r6.w); + let v_256 = -(cb3_3.tint_symbol_2[18u].xyzx); + r6.w = dot(r10.xyz, v_256.xyz); + r6.w = clamp(fma(r6.wwww, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).w, 0.0f, 1.0f); + let v_257 = dot(r10.xyz, r2.xyz); + r7.w = clamp(vec4(v_257, v_257, v_257, v_257).w, 0.0f, 1.0f); + r6.w = (r6.w * r7.w); + r7.w = (r3.w * r6.w); + let v_258 = (r7.www * cb3_3.tint_symbol_2[26u].xyz); + r11 = vec4(v_258.xyz, r11.w); + let v_259 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_259.xyz, r9.w); + let v_260 = fma(r4.xyz, r2.www, r10.xyz); + r4 = vec4(v_260.xyz, r4.w); + r2.w = dot(r4.xyz, r4.xyz); + r2.w = inverseSqrt(r2.w); + let v_261 = (r2.www * r4.xyz); + r4 = vec4(v_261.xyz, r4.w); + let v_262 = dot(r4.xyz, r5.xyz); + r2.w = clamp(vec4(v_262, v_262, v_262, v_262).w, 0.0f, 1.0f); + r2.w = ((-(r2.wwww)).w + 1.0f); + r5.x = (r2.w * r2.w); + r5.x = (r5.x * r5.x); + r2.w = (r2.w * r5.x); + r2.w = fma(cb12_12.tint_symbol_4[0u].x, r2.w, r4.w); + let v_263 = dot(r4.xyz, r2.xyz); + r4.x = clamp(vec4(v_263, v_263, v_263, v_263).x, 0.0f, 1.0f); + r4.x = log2(r4.x); + r4.x = (r4.x * r8.w); + r4.x = exp2(r4.x); + r2.w = (r2.w * r4.x); + r2.w = (r6.w * r2.w); + r2.w = (r3.w * r2.w); + r1.y = (r1.y * r2.w); + let v_264 = fma(r1.yyy, cb3_3.tint_symbol_2[26u].xyz, r8.xyz); + r8 = vec4(v_264.xyz, r8.w); + } + } + r1.y = (r5.w * r5.w); + r1.x = (r1.x * r1.x); + let v_265 = (r8.xyz * r1.xxx); + r4 = vec4(v_265.xyz, r4.w); + let v_266 = fma(r1.yyy, r9.xyz, r4.xyz); + r4 = vec4(v_266.xyz, r4.w); + let v_267 = fma(r6.xyz, r3.zzz, r4.xyz); + r4 = vec4(v_267.xyz, r4.w); + r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_268 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r1 = vec4(r1.x, v_268.xyz); + r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_269 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r5 = vec4(v_269.xyz, r5.w); + let v_270 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz); + r5 = vec4(v_270.xyz, r5.w); + let v_271 = fma(r1.yzw, r2.www, r5.xyz); + r1 = vec4(r1.x, v_271.xyz); + let v_272 = (r3.yyy * r1.yzw); + r1 = vec4(r1.x, v_272.xyz); + let v_273 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r3 = vec4(r3.x, v_273.xyz); + r5.x = cb3_3.tint_symbol_2[46u].w; + r5.y = cb3_3.tint_symbol_2[47u].w; + r5.z = cb3_3.tint_symbol_2[48u].w; + let v_274 = dot(r5.xyz, r2.xyz); + r1.x = clamp(vec4(v_274, v_274, v_274, v_274).x, 0.0f, 1.0f); + let v_275 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r3.yzw); + r2 = vec4(v_275.xyz, r2.w); + let v_276 = fma(r2.xyz, r3.xxx, r1.yzw); + r1 = vec4(v_276.xyz, r1.w); + let v_277 = (r5.www * r1.xyz); + r1 = vec4(v_277.xyz, r1.w); + let v_278 = fma(r1.xyz, r0.xyz, r4.xyz); + r0 = vec4(v_278.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r7.xyz, r7.xyz); + r1.x = sqrt(r0.w); + let v_279 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_279.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r7.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_280 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_280 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_281 = (r0.www * r7.xyz); + r2 = vec4(v_281.xyz, r2.w); + let v_282 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_282, v_282, v_282, v_282).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_283 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_283, v_283, v_283, v_283).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_284 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_284.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_285 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_285.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_286 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_286.xyz, r2.w); + let v_287 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_287.xyz, r2.w); + let v_288 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_288.xyz, r3.w); + let v_289 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_289.xyz, r2.w); + let v_290 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_291 = (r2.xyz + v_290.xyz); + r2 = vec4(v_291.xyz, r2.w); + let v_292 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_292.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_293 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_293.xyz, r3.w); + let v_294 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_294.xy, r1.z, v_294.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_295 = (v7.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_295.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_296 = -(r0.xyxz); + let v_297 = fma(r1.xyw, r0.www, v_296.xyw); + r1 = vec4(v_297.xy, r1.z, v_297.z); + let v_298 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_298.xyz, r1.w); + } else { + r0.w = dot(r7.xyz, r7.xyz); + r1.w = sqrt(r0.w); + let v_299 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_299.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r7.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_300 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_300 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_301 = (r0.www * r7.xyz); + r3 = vec4(v_301.xyz, r3.w); + let v_302 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_302, v_302, v_302, v_302).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_303 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_303, v_303, v_303, v_303).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_304 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_304.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_305 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_305.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_306 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_306.xyz, r3.w); + let v_307 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_307.xyz, r3.w); + let v_308 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_308.xyz, r4.w); + let v_309 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_309.xyz, r3.w); + let v_310 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_311 = (r3.xyz + v_310.xyz); + r3 = vec4(v_311.xyz, r3.w); + let v_312 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_312.x, r2.y, v_312.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_313 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_313.xyz, r3.w); + let v_314 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_314.x, r2.y, v_314.yz); + let v_315 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_315.x, r2.y, v_315.yz); + let v_316 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_316.xyz, r1.w); + } + let v_317 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_317.xyz, o0.w); +} + +fn v_3(v_318 : bool) { + if (v_318) { + discard; + return; + } +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @builtin(position) v_319 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v_319); + return o0; +} diff --git a/b/8b0b5899ed/shaders/008de4769b557904.wgsl b/b/8b0b5899ed/shaders/008de4769b557904.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..881e28d7b6df9c7d4cc7a24bb1a98d1c25b02fa1 --- /dev/null +++ b/b/8b0b5899ed/shaders/008de4769b557904.wgsl @@ -0,0 +1,75 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb18_struct { + tint_symbol : array, 18u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb18_struct; + +struct cb4_struct { + tint_symbol_1 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb4_struct_1 { + tint_symbol_2 : array, 4u>, +} + +@group(1u) @binding(11u) var cb11_11 : cb4_struct_1; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +var o0 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4) { + r0.x = (cb5_5.tint_symbol_1[3u].z * cb11_11.tint_symbol_2[2u].z); + let v = ((-(cb11_11.tint_symbol_2[2u].zzzz)).yz + vec2(1.0f, 2.0f)); + let v_1 = r0; + r0 = vec4(v_1.x, v.xy, v_1.w); + let v_2 = (r0.zz * v1.zw); + r0 = vec4(r0.xy, v_2.xy); + r1 = textureSample(t3, s3, r0.zwzz.xy); + r0.z = ((-(r1.xxxx)).z + r1.z); + r0.x = fma(r0.x, r0.z, r1.x); + r0.z = fma(v2.z, r0.y, -1.0f); + r0.z = fma(r0.y, r0.z, 1.0f); + r0.y = (r0.y * v2.z); + let v_3 = (r0.xy * cb11_11.tint_symbol_2[2u].xx); + r0 = vec4(v_3.xy, r0.zw); + r0.x = (r0.z * r0.x); + r2 = textureSample(t0, s0, v1.xyxx.xy); + let v_4 = (r2.xyz * cb11_11.tint_symbol_2[0u].xyz); + r2 = vec4(v_4.xyz, r2.w); + r2 = (r2 * v2.xxxw); + let v_5 = -(r2.xyxz); + let v_6 = fma(cb11_11.tint_symbol_2[3u].xyz, cb11_11.tint_symbol_2[2u].yyy, v_5.xyw); + r1 = vec4(v_6.xy, r1.z, v_6.z); + let v_7 = fma(r0.xxx, r1.xyw, r2.xyz); + r0 = vec4(v_7.x, r0.y, v_7.yz); + o0.w = (r2.w * cb2_2.tint_symbol[15u].x); + let v_8 = ((-(r0.xzwx)).xyz + r1.zzz); + r1 = vec4(v_8.xyz, r1.w); + let v_9 = fma(r0.yyy, r1.xyz, r0.xzw); + r0 = vec4(v_9.xyz, r0.w); + let v_10 = (r0.xyz * cb2_2.tint_symbol[17u].zzz); + o0 = vec4(v_10.xyz, o0.w); +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4) -> @location(0u) vec4 { + main_inner(v1, v2); + return o0; +} diff --git a/b/8b0b5899ed/shaders/00928753ac46ae0c.wgsl b/b/8b0b5899ed/shaders/00928753ac46ae0c.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..548198648723fecdeac5855ffe7abdb8f22f1594 --- /dev/null +++ b/b/8b0b5899ed/shaders/00928753ac46ae0c.wgsl @@ -0,0 +1,25 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +struct cb11_struct { + tint_symbol : array, 11u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb11_struct; + +var o0 : vec4; + +fn main_inner(v1 : vec4) { + let v = (v1.xyz + (-(cb12_12.tint_symbol[10u].xyzx)).xyz); + r0 = vec4(v.xyz, r0.w); + let v_1 = fma(v1.www, r0.xyz, cb12_12.tint_symbol[10u].xyz); + o0 = vec4(v_1.xyz, o0.w); + o0.w = 1.0f; +} + +@fragment +fn main(@location(1u) v1 : vec4) -> @location(0u) vec4 { + main_inner(v1); + return o0; +} diff --git a/b/8b0b5899ed/shaders/00c3781b22af3678.consts.json b/b/8b0b5899ed/shaders/00c3781b22af3678.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/00c3781b22af3678.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/00c3781b22af3678.wgsl b/b/8b0b5899ed/shaders/00c3781b22af3678.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..5ccf28d5c5f2cbb687e7f8b4249645fa17b994ec --- /dev/null +++ b/b/8b0b5899ed/shaders/00c3781b22af3678.wgsl @@ -0,0 +1,957 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v5 : vec4; + +var v6 : array; + +var o0 : vec4; + +var o1 : f32; + +var o2 : f32; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v5 = v_2; + x1[0u].x = v6[0u]; + x1[0u].y = v6[1u]; + x1[0u].z = v6[2u]; + x1[0u].w = v6[3u]; + r0 = textureSample(t0, s0, v1.xyz.xyxx.xy); + r1.x = dot(v2.xyz, v2.xyz); + r1.x = inverseSqrt(r1.x); + let v_3 = (r1.xxx * v2.xyz); + r1 = vec4(r1.x, v_3.xyz); + r2 = textureSample(t2, s2, v1.xyz.xyxx.xy); + let v_4 = (r2.xy * r2.xy); + r2 = vec4(v_4.xy, r2.zw); + r2.x = dot(r2.xyz, cb12_12.tint_symbol_4[1u].xyz); + r2.x = clamp(((r2.xxxx * cb12_12.tint_symbol_4[0u].zzzz)).x, 0.0f, 1.0f); + r2.y = dot(v3.xyz, v3.xyz); + r2.y = inverseSqrt(r2.y); + let v_5 = (r2.yyy * v3.xyz); + r3 = vec4(v_5.xyz, r3.w); + r2.y = dot((-(r3.xyzx)).xyz, r1.yzw); + r2.y = (r2.y + r2.y); + let v_6 = -(r2.yyyy); + let v_7 = -(r3.xyzx); + let v_8 = fma(r1.yzw, v_6.xyz, v_7.xyz); + r3 = vec4(v_8.xyz, r3.w); + r2.y = dot(r3.xyz, r3.xyz); + r2.y = inverseSqrt(r2.y); + let v_9 = fma(r3.xz, r2.yy, vec2(1.0f)); + let v_10 = r2; + r2 = vec4(v_10.x, v_9.xy, v_10.w); + let v_11 = (r2.yz * vec2(-0.5f)); + let v_12 = r2; + r2 = vec4(v_12.x, v_11.xy, v_12.w); + r3 = textureSample(t3, s3, r2.yzyy.xy); + let v_13 = (r3.xyz * cb12_12.tint_symbol_4[1u].www); + r3 = vec4(v_13.xyz, r3.w); + r0.w = (r0.w * v0.w); + let v_14 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + let v_15 = r2; + r2 = vec4(v_15.x, v_14.xy, v_15.w); + let v_16 = (r0.xyz * r0.xyz); + r0 = vec4(v_16.xyz, r0.w); + let v_17 = -(v4.xyzx); + let v_18 = (v_17.xyz + cb1_1.tint_symbol[15u].xyz); + r4 = vec4(v_18.xyz, r4.w); + r3.w = dot(r4.xyz, r4.xyz); + r3.w = inverseSqrt(r3.w); + let v_19 = (r3.www * r4.xyz); + r5 = vec4(v_19.xyz, r5.w); + let v_20 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_21 = fma(r4.xyz, r3.www, v_20.xyz); + r6 = vec4(v_21.xyz, r6.w); + r4.w = dot(r6.xyz, r6.xyz); + r4.w = inverseSqrt(r4.w); + let v_22 = (r4.www * r6.xyz); + r6 = vec4(v_22.xyz, r6.w); + let v_23 = (r2.yz * r2.yz); + let v_24 = r2; + r2 = vec4(v_24.x, v_23.xy, v_24.w); + r4.w = fma(r2.w, cb12_12.tint_symbol_4[0u].y, -500.0f); + r4.w = max(r4.w, 0.0f); + let v_25 = -(r4.wwww); + r2.w = fma(r2.w, cb12_12.tint_symbol_4[0u].y, v_25.w); + r4.w = (r4.w * 558.0f); + r2.w = fma(r2.w, 3.0f, r4.w); + r4.w = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz); + let v_26 = (v4.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r7 = vec4(v_26.xyz, r7.w); + let v_27 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_27.xyz, r8.w); + let v_28 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_28.xyz, r8.w); + let v_29 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_29.xyz, r8.w); + let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_30.xyz, r9.w); + let v_31 = &(x0[0u]); + let v_32 = r9; + *(v_31) = vec4(v_32.xyz, (*(v_31)).w); + let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_33.xyz, r10.w); + let v_34 = &(x0[1u]); + let v_35 = r10; + *(v_34) = vec4(v_35.xyz, (*(v_34)).w); + let v_36 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_36.xyz, r11.w); + let v_37 = &(x0[2u]); + let v_38 = r11; + *(v_37) = vec4(v_38.xyz, (*(v_37)).w); + let v_39 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_39.xyz, r8.w); + let v_40 = &(x0[3u]); + let v_41 = r8; + *(v_40) = vec4(v_41.xyz, (*(v_40)).w); + let v_42 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_43 = r12; + r12 = vec4(v_43.x, v_42.x, v_43.z, v_42.y); + r5.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r5.w = (r5.w * 0.5f); + let v_44 = abs(r11.yyyy); + r6.w = max(v_44.w, abs(r11.xxxx).w); + r6.w = bitcast(select(0u, 4294967295u, (r6.w < r5.w))); + let v_45 = (bitcast(r6.w) != 0u); + let v_46 = bitcast(v.tint_symbol_6[0i].x); + r6.w = select(bitcast(v.tint_symbol_6[1i].x), v_46, v_45); + let v_47 = abs(r10.yyyy); + r7.w = max(v_47.w, abs(r10.xxxx).w); + r7.w = bitcast(select(0u, 4294967295u, (r7.w < r5.w))); + let v_48 = bitcast(r7.w); + r6.w = select(r6.w, bitcast(v.tint_symbol_6[2i].x), (v_48 != 0u)); + let v_49 = abs(r9.yyyy); + r7.w = max(v_49.w, abs(r9.xxxx).w); + r5.w = bitcast(select(0u, 4294967295u, (r7.w < r5.w))); + let v_50 = bitcast(r5.w); + r5.w = select(r6.w, 0.0f, (v_50 != 0u)); + let v_51 = x0[bitcast(r5.w)]; + r9 = vec4(v_51.xyz, r9.w); + r5.w = f32(bitcast(r5.w)); + r6.w = (r5.w + 0.5f); + r6.w = (r6.w * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r5.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r5.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r7.w = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r6.w); + r6.w = bitcast(select(0u, 4294967295u, !((r5.w == 0.0f)))); + r5.w = ((-(r5.wwww)).w + r9.z); + let v_52 = dpdx(r10.xyy); + r11 = vec4(v_52.xy, r11.z, v_52.z); + r11.z = dpdx(r5.w); + let v_53 = dpdy(r10.yxy); + r13 = vec4(v_53.xyz, r13.w); + r13.w = dpdy(r5.w); + let v_54 = (r11.yw * r13.yw); + r8 = vec4(r8.xy, v_54.xy); + let v_55 = -(r8.zwzz); + let v_56 = fma(r11.xz, r13.xz, v_55.xy); + r14 = vec4(v_56.xy, r14.zw); + r8.z = (1.0f / r14.x); + r8.w = (r11.z * r13.y); + let v_57 = -(r8.wwww); + r14.z = fma(r11.x, r13.w, v_57.z); + let v_58 = (r8.zz * r14.yz); + r8 = vec4(r8.xy, v_58.xy); + let v_59 = max(r8.zw, vec2()); + r8 = vec4(r8.xy, v_59.xy); + let v_60 = min(r8.zw, vec2(0.5f)); + r8 = vec4(r8.xy, v_60.xy); + r5.w = fma((-(r7.wwww)).w, r8.z, r5.w); + r5.w = fma((-(r7.wwww)).w, r8.w, r5.w); + let v_61 = bitcast(r6.w); + let v_62 = r5.w; + r12.z = select(r9.z, v_62, (v_61 != 0u)); + r10.z = 0.0f; + let v_63 = (r10.xyz + r12.ywz); + r9 = vec4(v_63.xyz, r9.w); + let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_64.xy, r12.zw); + let v_65 = (r10.xyz + r12.xyz); + r11 = vec4(v_65.xyz, r11.w); + let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_66.xy, r12.zw); + let v_67 = (r10.xyz + r12.xyz); + r13 = vec4(v_67.xyz, r13.w); + let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_68.xy, r12.zw); + let v_69 = (r10.xyz + r12.xyz); + r14 = vec4(v_69.xyz, r14.w); + let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_70.xy, r12.zw); + let v_71 = (r10.xyz + r12.xyz); + r15 = vec4(v_71.xyz, r15.w); + let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_72.xy, r12.zw); + let v_73 = (r10.xyz + r12.xyz); + r16 = vec4(v_73.xyz, r16.w); + let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_74.xy, r12.zw); + let v_75 = (r10.xyz + r12.xyz); + r17 = vec4(v_75.xyz, r17.w); + let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_76.xy, r12.zw); + let v_77 = (r10.xyz + r12.xyz); + r18 = vec4(v_77.xyz, r18.w); + let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_78.xy, r12.zw); + let v_79 = (r10.xyz + r12.xyz); + r19 = vec4(v_79.xyz, r19.w); + let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_80.xy, r12.zw); + let v_81 = (r10.xyz + r12.xyz); + r20 = vec4(v_81.xyz, r20.w); + let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_82.xy, r12.zw); + let v_83 = (r10.xyz + r12.xyz); + r21 = vec4(v_83.xyz, r21.w); + let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_84.xy, r12.zw); + let v_85 = (r10.xyz + r12.xyz); + r22 = vec4(v_85.xyz, r22.w); + let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_86.xy, r12.zw); + let v_87 = (r10.xyz + r12.xyz); + r23 = vec4(v_87.xyz, r23.w); + let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_88.xy, r12.zw); + let v_89 = (r10.xyz + r12.xyz); + r24 = vec4(v_89.xyz, r24.w); + let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_90.xy, r12.zw); + let v_91 = (r10.xyz + r12.xyz); + r25 = vec4(v_91.xyz, r25.w); + let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_92.xy, r12.zw); + let v_93 = (r10.xyz + r12.xyz); + r10 = vec4(v_93.xyz, r10.w); + let v_94 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_94.xy, r9.z); + let v_95 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_95.xy, r11.z); + let v_96 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_96.xy, r13.z); + let v_97 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_97.xy, r14.z); + let v_98 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_98.xy, r15.z); + let v_99 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_99.xy, r16.z); + let v_100 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_100.xy, r17.z); + let v_101 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_101.xy, r18.z); + let v_102 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_102.xy, r19.z); + let v_103 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_103.xy, r20.z); + let v_104 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_104.xy, r21.z); + let v_105 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_105.xy, r22.z); + let v_106 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_106.xy, r23.z); + let v_107 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_107.xy, r24.z); + let v_108 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_108.xy, r25.z); + let v_109 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_109.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r5.w = dot(r9, vec4(1.0f)); + r4.w = clamp(fma(r4.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f); + let v_110 = abs(r8.yyyy); + r6.w = max(v_110.w, abs(r8.xxxx).w); + r6.w = clamp(fma(r6.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r4.w = ((-(r4.wwww)).w + 1.0f); + r4.w = (r6.w * r4.w); + r4.w = fma(r5.w, 0.0625f, r4.w); + r4.w = (r4.w * r4.w); + r4.w = min(r4.w, 1.0f); + r5.w = clamp(fma(v4.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r5.w = sqrt(r5.w); + r5.w = (r5.w * cb6_6.tint_symbol_5[3u].z); + let v_111 = -(r4.wwww); + r4.w = fma(r5.w, v_111.w, r4.w); + let v_112 = dot(r1.yzw, v_20.xyz); + r5.w = clamp(vec4(v_112, v_112, v_112, v_112).w, 0.0f, 1.0f); + let v_113 = dot(r5.xyz, r1.yzw); + r8.x = clamp(vec4(v_113, v_113, v_113, v_113).x, 0.0f, 1.0f); + let v_114 = dot(r6.xyz, v_20.xyz); + r8.y = clamp(vec4(v_114, v_114, v_114, v_114).y, 0.0f, 1.0f); + let v_115 = ((-(r8.xyxx)).xy + vec2(1.0f)); + r8 = vec4(v_115.xy, r8.zw); + let v_116 = (r8.xy * r8.xy); + r8 = vec4(r8.xy, v_116.xy); + let v_117 = (r8.zw * r8.zw); + r8 = vec4(r8.xy, v_117.xy); + let v_118 = (r8.xy * r8.zw); + r8 = vec4(v_118.xy, r8.zw); + r6.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f); + let v_119 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r6.ww); + r8 = vec4(v_119.xy, r8.zw); + let v_120 = (r2.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(r8.xy, v_120.xy); + r7.w = (r8.z * 0.125f); + r8.x = fma((-(r2.xxxx)).x, r8.x, 1.0f); + r6.x = dot(r1.yzw, r6.xyz); + r6.x = clamp(((r6.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r6.x = log2(r6.x); + r6.x = (r6.x * r8.w); + r6.x = exp2(r6.x); + r6.x = (r8.y * r6.x); + r6.x = (r7.w * r6.x); + r6.x = (r2.x * r6.x); + r6.x = (r5.w * r6.x); + r5.w = (r5.w * r8.x); + let v_121 = fma(r0.xyz, r5.www, r6.xxx); + r6 = vec4(v_121.xyz, r6.w); + let v_122 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz); + r6 = vec4(v_122.xyz, r6.w); + r5.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r5.w) != 0u)) { + r10 = vec4(vec3(), r10.w); + r9 = vec4(vec3(), r9.w); + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_123 = (v_17.xyz + cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_123.xyz, r9.w); + let v_124 = (v4.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r10 = vec4(v_124.xyz, r10.w); + r8.z = dot(r10.xyz, cb3_3.tint_symbol_2[11u].xyz); + r8.z = clamp(((r8.zzzz / cb3_3.tint_symbol_2[19u].wwww)).z, 0.0f, 1.0f); + r8.z = (r8.z * cb3_3.tint_symbol_2[19u].w); + let v_125 = fma(cb3_3.tint_symbol_2[11u].xyz, r8.zzz, cb3_3.tint_symbol_2[3u].xyz); + r10 = vec4(v_125.xyz, r10.w); + let v_126 = (r10.xyz + v_17.xyz); + r10 = vec4(v_126.xyz, r10.w); + let v_127 = bitcast>(r8.yyy); + let v_128 = r9.xyz; + let v_129 = select(r10.xyz, v_128, (v_127 != vec3())); + r9 = vec4(v_129.xyz, r9.w); + r8.y = dot(r9.xyz, r9.xyz); + let v_130 = (r9.xyz + vec3(0.00000099999999747524f)); + r9 = vec4(v_130.xyz, r9.w); + r8.z = dot(r9.xyz, r9.xyz); + r8.z = inverseSqrt(r8.z); + let v_131 = (r8.zzz * r9.xyz); + r9 = vec4(v_131.xyz, r9.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r8.z = ((-(cb3_3.tint_symbol_2[11u].wwww)).z + 1.0f); + r8.z = fma(r8.z, r8.y, cb3_3.tint_symbol_2[11u].w); + r8.y = (r8.y / r8.z); + let v_132 = -(cb3_3.tint_symbol_2[11u].xyzx); + r8.z = dot(r9.xyz, v_132.xyz); + r8.z = clamp(fma(r8.zzzz, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).z, 0.0f, 1.0f); + let v_133 = dot(r9.xyz, r1.yzw); + r9.w = clamp(vec4(v_133, v_133, v_133, v_133).w, 0.0f, 1.0f); + r8.z = (r8.z * r9.w); + r9.w = (r8.y * r8.z); + let v_134 = (r9.www * cb3_3.tint_symbol_2[19u].xyz); + r10 = vec4(v_134.xyz, r10.w); + let v_135 = (r0.xyz * r10.xyz); + r10 = vec4(v_135.xyz, r10.w); + let v_136 = fma(r4.xyz, r3.www, r9.xyz); + r9 = vec4(v_136.xyz, r9.w); + r9.w = dot(r9.xyz, r9.xyz); + r9.w = inverseSqrt(r9.w); + let v_137 = (r9.www * r9.xyz); + r9 = vec4(v_137.xyz, r9.w); + let v_138 = dot(r9.xyz, r5.xyz); + r9.w = clamp(vec4(v_138, v_138, v_138, v_138).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r6.w); + let v_139 = dot(r9.xyz, r1.yzw); + r9.x = clamp(vec4(v_139, v_139, v_139, v_139).x, 0.0f, 1.0f); + r9.x = log2(r9.x); + r9.x = (r8.w * r9.x); + r9.x = exp2(r9.x); + r9.x = (r9.x * r9.w); + r8.z = (r8.z * r9.x); + r8.y = (r8.y * r8.z); + r8.y = (r7.w * r8.y); + let v_140 = (r8.yyy * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_140.xyz, r9.w); + } + r8.y = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r8.y) != 0u)) { + r8.z = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r8.y = bitcast((bitcast(r5.w) | bitcast(r8.y))); + let v_141 = bitcast(r8.z); + let v_142 = r8.y; + r5.w = select(r5.w, v_142, (v_141 != 0u)); + if ((bitcast(r5.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_143 = (v_17.xyz + cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_143.xyz, r11.w); + let v_144 = (v4.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r12 = vec4(v_144.xyz, r12.w); + r8.z = dot(r12.xyz, cb3_3.tint_symbol_2[12u].xyz); + r8.z = clamp(((r8.zzzz / cb3_3.tint_symbol_2[20u].wwww)).z, 0.0f, 1.0f); + r8.z = (r8.z * cb3_3.tint_symbol_2[20u].w); + let v_145 = fma(cb3_3.tint_symbol_2[12u].xyz, r8.zzz, cb3_3.tint_symbol_2[4u].xyz); + r12 = vec4(v_145.xyz, r12.w); + let v_146 = (r12.xyz + v_17.xyz); + r12 = vec4(v_146.xyz, r12.w); + let v_147 = bitcast>(r8.yyy); + let v_148 = r11.xyz; + let v_149 = select(r12.xyz, v_148, (v_147 != vec3())); + r11 = vec4(v_149.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_150 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_150.xyz, r11.w); + r8.z = dot(r11.xyz, r11.xyz); + r8.z = inverseSqrt(r8.z); + let v_151 = (r8.zzz * r11.xyz); + r11 = vec4(v_151.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r8.z = ((-(cb3_3.tint_symbol_2[12u].wwww)).z + 1.0f); + r8.z = fma(r8.z, r8.y, cb3_3.tint_symbol_2[12u].w); + r8.y = (r8.y / r8.z); + let v_152 = -(cb3_3.tint_symbol_2[12u].xyzx); + r8.z = dot(r11.xyz, v_152.xyz); + r8.z = clamp(fma(r8.zzzz, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).z, 0.0f, 1.0f); + let v_153 = dot(r11.xyz, r1.yzw); + r9.w = clamp(vec4(v_153, v_153, v_153, v_153).w, 0.0f, 1.0f); + r8.z = (r8.z * r9.w); + r9.w = (r8.y * r8.z); + let v_154 = (r9.www * cb3_3.tint_symbol_2[20u].xyz); + r12 = vec4(v_154.xyz, r12.w); + let v_155 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_155.xyz, r10.w); + let v_156 = fma(r4.xyz, r3.www, r11.xyz); + r11 = vec4(v_156.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_157 = (r9.www * r11.xyz); + r11 = vec4(v_157.xyz, r11.w); + let v_158 = dot(r11.xyz, r5.xyz); + r9.w = clamp(vec4(v_158, v_158, v_158, v_158).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r6.w); + let v_159 = dot(r11.xyz, r1.yzw); + r10.w = clamp(vec4(v_159, v_159, v_159, v_159).w, 0.0f, 1.0f); + r10.w = log2(r10.w); + r10.w = (r8.w * r10.w); + r10.w = exp2(r10.w); + r9.w = (r9.w * r10.w); + r8.z = (r8.z * r9.w); + r8.y = (r8.y * r8.z); + r8.y = (r7.w * r8.y); + let v_160 = fma(r8.yyy, cb3_3.tint_symbol_2[20u].xyz, r9.xyz); + r9 = vec4(v_160.xyz, r9.w); + } + } else { + r5.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r5.w) != 0u)) { + r5.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r8.y = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r5.w = bitcast((bitcast(r5.w) | bitcast(r8.y))); + if ((bitcast(r5.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_161 = (v_17.xyz + cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_161.xyz, r11.w); + let v_162 = (v4.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r12 = vec4(v_162.xyz, r12.w); + r8.z = dot(r12.xyz, cb3_3.tint_symbol_2[13u].xyz); + r8.z = clamp(((r8.zzzz / cb3_3.tint_symbol_2[21u].wwww)).z, 0.0f, 1.0f); + r8.z = (r8.z * cb3_3.tint_symbol_2[21u].w); + let v_163 = fma(cb3_3.tint_symbol_2[13u].xyz, r8.zzz, cb3_3.tint_symbol_2[5u].xyz); + r12 = vec4(v_163.xyz, r12.w); + let v_164 = (r12.xyz + v_17.xyz); + r12 = vec4(v_164.xyz, r12.w); + let v_165 = bitcast>(r8.yyy); + let v_166 = r11.xyz; + let v_167 = select(r12.xyz, v_166, (v_165 != vec3())); + r11 = vec4(v_167.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_168 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_168.xyz, r11.w); + r8.z = dot(r11.xyz, r11.xyz); + r8.z = inverseSqrt(r8.z); + let v_169 = (r8.zzz * r11.xyz); + r11 = vec4(v_169.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r8.z = ((-(cb3_3.tint_symbol_2[13u].wwww)).z + 1.0f); + r8.z = fma(r8.z, r8.y, cb3_3.tint_symbol_2[13u].w); + r8.y = (r8.y / r8.z); + let v_170 = -(cb3_3.tint_symbol_2[13u].xyzx); + r8.z = dot(r11.xyz, v_170.xyz); + r8.z = clamp(fma(r8.zzzz, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).z, 0.0f, 1.0f); + let v_171 = dot(r11.xyz, r1.yzw); + r9.w = clamp(vec4(v_171, v_171, v_171, v_171).w, 0.0f, 1.0f); + r8.z = (r8.z * r9.w); + r9.w = (r8.y * r8.z); + let v_172 = (r9.www * cb3_3.tint_symbol_2[21u].xyz); + r12 = vec4(v_172.xyz, r12.w); + let v_173 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_173.xyz, r10.w); + let v_174 = fma(r4.xyz, r3.www, r11.xyz); + r11 = vec4(v_174.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_175 = (r9.www * r11.xyz); + r11 = vec4(v_175.xyz, r11.w); + let v_176 = dot(r11.xyz, r5.xyz); + r9.w = clamp(vec4(v_176, v_176, v_176, v_176).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r6.w); + let v_177 = dot(r11.xyz, r1.yzw); + r10.w = clamp(vec4(v_177, v_177, v_177, v_177).w, 0.0f, 1.0f); + r10.w = log2(r10.w); + r10.w = (r8.w * r10.w); + r10.w = exp2(r10.w); + r9.w = (r9.w * r10.w); + r8.z = (r8.z * r9.w); + r8.y = (r8.y * r8.z); + r8.y = (r7.w * r8.y); + let v_178 = fma(r8.yyy, cb3_3.tint_symbol_2[21u].xyz, r9.xyz); + r9 = vec4(v_178.xyz, r9.w); + } + } + if ((bitcast(r5.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r5.w = bitcast((bitcast(r5.w) | bitcast(r8.y))); + if ((bitcast(r5.w) != 0u)) { + } else { + r5.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_179 = (v_17.xyz + cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_179.xyz, r11.w); + let v_180 = (v4.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r12 = vec4(v_180.xyz, r12.w); + r8.y = dot(r12.xyz, cb3_3.tint_symbol_2[14u].xyz); + r8.y = clamp(((r8.yyyy / cb3_3.tint_symbol_2[22u].wwww)).y, 0.0f, 1.0f); + r8.y = (r8.y * cb3_3.tint_symbol_2[22u].w); + let v_181 = fma(cb3_3.tint_symbol_2[14u].xyz, r8.yyy, cb3_3.tint_symbol_2[6u].xyz); + r12 = vec4(v_181.xyz, r12.w); + let v_182 = (r12.xyz + v_17.xyz); + r12 = vec4(v_182.xyz, r12.w); + let v_183 = bitcast>(r5.www); + let v_184 = r11.xyz; + let v_185 = select(r12.xyz, v_184, (v_183 != vec3())); + r11 = vec4(v_185.xyz, r11.w); + r5.w = dot(r11.xyz, r11.xyz); + let v_186 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_186.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + r8.y = inverseSqrt(r8.y); + let v_187 = (r8.yyy * r11.xyz); + r11 = vec4(v_187.xyz, r11.w); + r5.w = clamp(fma(-(r5.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r8.y = ((-(cb3_3.tint_symbol_2[14u].wwww)).y + 1.0f); + r8.y = fma(r8.y, r5.w, cb3_3.tint_symbol_2[14u].w); + r5.w = (r5.w / r8.y); + let v_188 = -(cb3_3.tint_symbol_2[14u].xyzx); + r8.y = dot(r11.xyz, v_188.xyz); + r8.y = clamp(fma(r8.yyyy, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).y, 0.0f, 1.0f); + let v_189 = dot(r11.xyz, r1.yzw); + r8.z = clamp(vec4(v_189, v_189, v_189, v_189).z, 0.0f, 1.0f); + r8.y = (r8.y * r8.z); + r8.z = (r5.w * r8.y); + let v_190 = (r8.zzz * cb3_3.tint_symbol_2[22u].xyz); + r12 = vec4(v_190.xyz, r12.w); + let v_191 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_191.xyz, r10.w); + let v_192 = fma(r4.xyz, r3.www, r11.xyz); + r4 = vec4(v_192.xyz, r4.w); + r3.w = dot(r4.xyz, r4.xyz); + r3.w = inverseSqrt(r3.w); + let v_193 = (r3.www * r4.xyz); + r4 = vec4(v_193.xyz, r4.w); + let v_194 = dot(r4.xyz, r5.xyz); + r3.w = clamp(vec4(v_194, v_194, v_194, v_194).w, 0.0f, 1.0f); + r3.w = ((-(r3.wwww)).w + 1.0f); + r5.x = (r3.w * r3.w); + r5.x = (r5.x * r5.x); + r3.w = (r3.w * r5.x); + r3.w = fma(cb12_12.tint_symbol_4[0u].x, r3.w, r6.w); + let v_195 = dot(r4.xyz, r1.yzw); + r4.x = clamp(vec4(v_195, v_195, v_195, v_195).x, 0.0f, 1.0f); + r4.x = log2(r4.x); + r4.x = (r4.x * r8.w); + r4.x = exp2(r4.x); + r3.w = (r3.w * r4.x); + r3.w = (r8.y * r3.w); + r3.w = (r5.w * r3.w); + r3.w = (r7.w * r3.w); + let v_196 = fma(r3.www, cb3_3.tint_symbol_2[22u].xyz, r9.xyz); + r9 = vec4(v_196.xyz, r9.w); + } + } + r3.w = (r8.x * r8.x); + r2.x = (r2.x * r2.x); + let v_197 = (r9.xyz * r2.xxx); + r4 = vec4(v_197.xyz, r4.w); + let v_198 = fma(r3.www, r10.xyz, r4.xyz); + r4 = vec4(v_198.xyz, r4.w); + let v_199 = fma(r6.xyz, r4.www, r4.xyz); + r4 = vec4(v_199.xyz, r4.w); + r1.x = fma(v2.z, r1.x, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_200 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r5 = vec4(v_200.xyz, r5.w); + r2.x = ((-(cb2_2.tint_symbol_1[16u].zzzz)).x + 1.0f); + let v_201 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r6 = vec4(v_201.xyz, r6.w); + let v_202 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz); + r6 = vec4(v_202.xyz, r6.w); + let v_203 = fma(r5.xyz, r2.xxx, r6.xyz); + r5 = vec4(v_203.xyz, r5.w); + let v_204 = (r2.zzz * r5.xyz); + r5 = vec4(v_204.xyz, r5.w); + let v_205 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r6 = vec4(v_205.xyz, r6.w); + r9.x = cb3_3.tint_symbol_2[46u].w; + r9.y = cb3_3.tint_symbol_2[47u].w; + r9.z = cb3_3.tint_symbol_2[48u].w; + let v_206 = dot(r9.xyz, r1.yzw); + r1.x = clamp(vec4(v_206, v_206, v_206, v_206).x, 0.0f, 1.0f); + let v_207 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r6.xyz); + r1 = vec4(v_207.xyz, r1.w); + let v_208 = fma(r1.xyz, r2.yyy, r5.xyz); + r1 = vec4(v_208.xyz, r1.w); + let v_209 = (r8.xxx * r1.xyz); + r1 = vec4(v_209.xyz, r1.w); + let v_210 = fma(r1.xyz, r0.xyz, r4.xyz); + r0 = vec4(v_210.xyz, r0.w); + r1.x = ((-(r8.xxxx)).x + 1.0f); + r1.y = max(r2.z, r2.y); + let v_211 = (r1.yyy * r3.xyz); + r1 = vec4(r1.x, v_211.xyz); + r2.x = clamp(((r2.wwww * vec4(0.00177619897294789553f))).x, 0.0f, 1.0f); + let v_212 = (r1.yzw * r2.xxx); + r2 = vec4(v_212.xyz, r2.w); + let v_213 = (r2.xyz * vec3(0.68169009685516357422f)); + r2 = vec4(v_213.xyz, r2.w); + let v_214 = fma(r1.yzw, vec3(0.31830990314483642578f), r2.xyz); + r1 = vec4(r1.x, v_214.xyz); + let v_215 = fma(r1.yzw, r1.xxx, r0.xyz); + r0 = vec4(v_215.xyz, r0.w); + r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r1.x = dot(r7.xyz, r7.xyz); + r1.y = sqrt(r1.x); + let v_216 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.z = (r1.y + v_216.z); + r1.z = max(r1.z, 0.0f); + r1.y = (r1.z / r1.y); + r1.y = (r1.y * r7.z); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].z); + r1.y = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.yyyy).y))); + r2.x = (r1.w * -1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.w = (r2.x / r1.w); + let v_217 = bitcast(r1.y); + r1.y = select(1.0f, r1.w, (v_217 != 0u)); + r1.w = (r1.z * cb3_3.tint_symbol_2[51u].w); + r1.y = (r1.y * r1.w); + r1.y = min(r1.y, 1.0f); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = min(r1.y, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].y); + r1.x = inverseSqrt(r1.x); + let v_218 = (r1.xxx * r7.xyz); + r2 = vec4(v_218.xyz, r2.w); + let v_219 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.x = clamp(vec4(v_219, v_219, v_219, v_219).x, 0.0f, 1.0f); + r1.x = log2(r1.x); + r1.x = (r1.x * cb3_3.tint_symbol_2[54u].w); + r1.x = exp2(r1.x); + let v_220 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.x = clamp(vec4(v_220, v_220, v_220, v_220).x, 0.0f, 1.0f); + r2.x = log2(r2.x); + r2.x = (r2.x * cb3_3.tint_symbol_2[53u].w); + r2.x = exp2(r2.x); + r1.y = fma((-(r1.yyyy)).y, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.y = (r1.y * cb3_3.tint_symbol_2[51u].y); + let v_221 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.y = (r1.z + v_221.y); + r2.y = max(r2.y, 0.0f); + r2.y = (r2.y * cb3_3.tint_symbol_2[51u].x); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + r1.w = clamp(fma(r1.yyyy, r2.yyyy, r1.wwww).w, 0.0f, 1.0f); + let v_222 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.z = (r1.z * v_222.z); + r1.z = (r1.z * 1.44269502162933349609f); + r1.z = exp2(r1.z); + r1.z = ((-(r1.zzzz)).z + 1.0f); + let v_223 = ((-(cb3_3.tint_symbol_2[56u].xxyz)).yzw + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(r2.x, v_223.xyz); + let v_224 = fma(r1.xxx, r2.yzw, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(r2.x, v_224.xyz); + let v_225 = ((-(r2.yzwy)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_225.xyz, r3.w); + let v_226 = fma(r2.xxx, r3.xyz, r2.yzw); + r2 = vec4(v_226.xyz, r2.w); + let v_227 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_228 = (r2.xyz + v_227.xyz); + r2 = vec4(v_228.xyz, r2.w); + let v_229 = fma(r1.zzz, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_229.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_230 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_230.xyz, r3.w); + let v_231 = fma(r1.yyy, r3.xyz, r2.xyz); + r1 = vec4(v_231.xyz, r1.w); + r2.x = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r2.x) != 0u)) { + let v_232 = (v5.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_232.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r2.x = (r2.x + -1.0f); + r2.x = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r2.xxxx, vec4(1.0f)).x, 0.0f, 1.0f); + } else { + r2.x = 1.0f; + } + let v_233 = -(r0.xyzx); + let v_234 = fma(r1.xyz, r2.xxx, v_233.xyz); + r1 = vec4(v_234.xyz, r1.w); + let v_235 = fma(r1.www, r1.xyz, r0.xyz); + r1 = vec4(v_235.xyz, r1.w); + } else { + r1.w = dot(r7.xyz, r7.xyz); + r2.x = sqrt(r1.w); + let v_236 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.y = (r2.x + v_236.y); + r2.y = max(r2.y, 0.0f); + r2.x = (r2.y / r2.x); + r2.x = (r2.x * r7.z); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].z); + r2.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r2.xxxx).x))); + r2.w = (r2.z * -1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.z = (r2.w / r2.z); + let v_237 = bitcast(r2.x); + r2.x = select(1.0f, r2.z, (v_237 != 0u)); + r2.z = (r2.y * cb3_3.tint_symbol_2[51u].w); + r2.x = (r2.x * r2.z); + r2.x = min(r2.x, 1.0f); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = min(r2.x, 1.0f); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].y); + r1.w = inverseSqrt(r1.w); + let v_238 = (r1.www * r7.xyz); + r3 = vec4(v_238.xyz, r3.w); + let v_239 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.w = clamp(vec4(v_239, v_239, v_239, v_239).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[54u].w); + r1.w = exp2(r1.w); + let v_240 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.w = clamp(vec4(v_240, v_240, v_240, v_240).w, 0.0f, 1.0f); + r2.w = log2(r2.w); + r2.w = (r2.w * cb3_3.tint_symbol_2[53u].w); + r2.w = exp2(r2.w); + r2.x = fma((-(r2.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].y); + let v_241 = -(cb3_3.tint_symbol_2[52u].xxxx); + r3.x = (r2.y + v_241.x); + r3.x = max(r3.x, 0.0f); + r3.x = (r3.x * cb3_3.tint_symbol_2[51u].x); + r3.x = (r3.x * 1.44269502162933349609f); + r3.x = exp2(r3.x); + r3.x = ((-(r3.xxxx)).x + 1.0f); + r2.z = clamp(fma(r2.xxxx, r3.xxxx, r2.zzzz).z, 0.0f, 1.0f); + let v_242 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.y = (r2.y * v_242.y); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + let v_243 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_243.xyz, r3.w); + let v_244 = fma(r1.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_244.xyz, r3.w); + let v_245 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_245.xyz, r4.w); + let v_246 = fma(r2.www, r4.xyz, r3.xyz); + r3 = vec4(v_246.xyz, r3.w); + let v_247 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_248 = (r3.xyz + v_247.xyz); + r3 = vec4(v_248.xyz, r3.w); + let v_249 = fma(r2.yyy, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r3 = vec4(v_249.xyz, r3.w); + r4.x = cb3_3.tint_symbol_2[55u].w; + r4.y = cb3_3.tint_symbol_2[56u].w; + r4.z = cb3_3.tint_symbol_2[57u].w; + let v_250 = ((-(r3.xyzx)).xyz + r4.xyz); + r4 = vec4(v_250.xyz, r4.w); + let v_251 = fma(r2.xxx, r4.xyz, r3.xyz); + r2 = vec4(v_251.xy, r2.z, v_251.z); + let v_252 = ((-(r0.xyxz)).xyw + r2.xyw); + r2 = vec4(v_252.xy, r2.z, v_252.z); + let v_253 = fma(r2.zzz, r2.xyw, r0.xyz); + r1 = vec4(v_253.xyz, r1.w); + } + let v_254 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_254.xyz, o0.w); + r0.x = bitcast(select(0u, 4294967295u, (0.30000001192092895508f < r0.w))); + r0.x = bitcast((bitcast(r0.x) & 1065353216u)); + o1 = (r0.x * v1.z); + o0.w = r0.w; + o2 = r0.x; +} + +struct tint_symbol_8 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : f32, + @location(2u) + o2 : f32, +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @builtin(position) v_255 : vec4) -> tint_symbol_8 { + main_inner(v0, v1, v2, v3, v4, v_255); + return tint_symbol_8(o0, o1, o2); +} diff --git a/b/8b0b5899ed/shaders/00c5eac137500fba.consts.json b/b/8b0b5899ed/shaders/00c5eac137500fba.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..5fccacd3c1d416721b775ddc9a06f6f9a0cfec43 --- /dev/null +++ b/b/8b0b5899ed/shaders/00c5eac137500fba.consts.json @@ -0,0 +1 @@ +[4294967295, 2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/00c5eac137500fba.wgsl b/b/8b0b5899ed/shaders/00c5eac137500fba.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..f369a4706fd5ce41145c31b72517821019b68131 --- /dev/null +++ b/b/8b0b5899ed/shaders/00c5eac137500fba.wgsl @@ -0,0 +1,660 @@ +enable clip_distances; +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +struct cb1_struct { + tint_symbol : array, 1u>, +} + +@group(0u) @binding(13u) var cb13_13 : cb1_struct; + +struct cb16_struct { + tint_symbol_1 : array, 16u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb1_struct_1 { + tint_symbol_2 : array, 1u>, +} + +@group(0u) @binding(0u) var cb0_0 : cb1_struct_1; + +struct cb17_struct { + tint_symbol_3 : array, 17u>, +} + +@group(0u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb59_struct { + tint_symbol_4 : array, 59u>, +} + +@group(0u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(0u) @binding(6u) var cb6_6 : cb15_struct; + +struct cb1_struct_2 { + tint_symbol_6 : array, 1u>, +} + +@group(0u) @binding(7u) var cb7_7 : cb1_struct_2; + +struct cb5_struct { + tint_symbol_7 : array, 5u>, +} + +@group(0u) @binding(9u) var cb9_9 : cb5_struct; + +struct cb4_struct { + tint_symbol_8 : array, 4u>, +} + +@group(0u) @binding(8u) var cb8_8 : cb4_struct; + +@group(0u) @binding(31u) var s15 : sampler_comparison; + +@group(0u) @binding(47u) var t15 : texture_depth_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +var o6 : vec4; + +var o7 : vec4; + +var o8 : vec4; + +var o9 : vec4; + +var o10 : vec4; + +var o11 : vec4; + +var o12 : array; + +var v : vec4; + +var x0 : array, 3u>; + +var x1 : array, 3u>; + +var x2 : array, 3u>; + +var x3 : array, 3u>; + +var x4 : array, 4u>; + +var x5 : array, 1u>; + +struct tint_symbol_10 { + tint_symbol_9 : array, 4u>, +} + +@group(0u) @binding(15u) var v_1 : tint_symbol_10; + +fn main_inner(v0 : vec3, v1 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v7 : vec4, v8 : vec4, v9 : vec4, v10 : vec4, v11 : vec4, v13 : vec3) { + r0 = vec4(((v0.xz + v7.xz)).xy, r0.zw); + r1.x = v6.w; + r1.y = v8.w; + let v_2 = (r0.xy + r1.xy); + r0 = vec4(v_2.xy, r0.zw); + let v_3 = ((-(r1.xxxy)).zw + v8.xz); + r0 = vec4(r0.xy, v_3.xy); + r1 = vec4(((v6.xz + (-(v7.xzxx)).xy)).xy, r1.zw); + let v_4 = (r0.zw + r1.xy); + r1 = vec4(r1.xy, v_4.xy); + let v_5 = fma(r1.zw, vec2(0.5f), r0.xy); + r2 = vec4(v_5.xy, r2.zw); + r1 = vec4(r1.xy, (((-(v10.xxxw)).zw + v10.yz)).xy); + r3 = vec4((((-(v11.xwxx)).xy + v11.yz)).xy, r3.zw); + x0[0u].x = v9.x; + x0[1u].x = 0.5f; + x0[2u].x = v9.y; + x1[0u].x = v9.z; + x1[1u].x = 0.5f; + x1[2u].x = v9.w; + x2[0u].x = v9.x; + x2[1u].x = 0.5f; + x2[2u].x = v9.y; + x3[0u].x = v9.z; + x3[1u].x = 0.5f; + x3[2u].x = v9.w; + let v_6 = v13.xy; + let v_7 = max(v_6, vec2(-2147483648.0f)); + let v_8 = bitcast>(select(select(vec2(v_7), vec2(2147483647i), (v_7 >= vec2(2147483648.0f))), vec2(), !((v_6 == v_6)))); + r3 = vec4(r3.xy, v_8.xy); + r2.w = x0[bitcast(r3.z)].x; + r4.x = x1[bitcast(r3.w)].x; + let v_9 = fma(r0.zw, r2.ww, r0.xy); + r0 = vec4(v_9.xy, r0.zw); + let v_10 = fma(r1.xy, r4.xx, r0.xy); + r0 = vec4(v_10.xy, r0.zw); + o1.x = fma(r2.w, r1.z, v10.x); + o1.y = fma(r4.x, r1.w, v10.w); + o1.z = fma(r2.w, r3.x, v11.x); + o1.w = fma(r4.x, r3.y, v11.w); + r0.w = x2[bitcast(r3.z)].x; + o2.x = fma(r0.w, r1.z, v10.x); + r0.w = x3[bitcast(r3.w)].x; + o2.y = fma(r0.w, r1.w, v10.w); + o3.x = clamp(v3.x, 0.0f, 1.0f); + r0.z = 1.0f; + r1.x = dot(r0.xyz, cb9_9.tint_symbol_7[2u].xyz); + r1.y = dot(r0.xyz, cb9_9.tint_symbol_7[3u].xyz); + r1.z = dot(r0.xyz, cb9_9.tint_symbol_7[4u].xyz); + let v_11 = (r1.xyz * cb7_7.tint_symbol_6[0u].xxx); + r3 = vec4(v_11.xyz, r3.w); + let v_12 = fma(r1.xyz, cb7_7.tint_symbol_6[0u].xxx, cb1_1.tint_symbol_1[15u].xyz); + r1 = vec4(v_12.xyz, r1.w); + r2.z = 1.0f; + r4.x = dot(r2.xyz, cb9_9.tint_symbol_7[2u].xyz); + r4.y = dot(r2.xyz, cb9_9.tint_symbol_7[3u].xyz); + r4.z = dot(r2.xyz, cb9_9.tint_symbol_7[4u].xyz); + let v_13 = fma(r4.xyz, cb7_7.tint_symbol_6[0u].xxx, cb1_1.tint_symbol_1[15u].xyz); + r2 = vec4(v_13.xyz, r2.w); + let v_14 = -(r2.xyzx); + let v_15 = (r1.xyz + v_14.xyz); + r4 = vec4(v_15.xyz, r4.w); + r0.w = dot(r4.xyz, r4.xyz); + r1.w = bitcast(select(0u, 4294967295u, (r0.w < 0.00100000004749745131f))); + r0.w = inverseSqrt(r0.w); + let v_16 = (r0.www * r4.xyz); + r4 = vec4(v_16.xyz, r4.w); + let v_17 = -(cb1_1.tint_symbol_1[14u].xyzx); + let v_18 = bitcast>(r1.www); + let v_19 = select(r4.xyz, v_17.xyz, (v_18 != vec3())); + r4 = vec4(v_19.xyz, r4.w); + let v_20 = (r4.xyz + cb1_1.tint_symbol_1[14u].xyz); + r4 = vec4(v_20.xyz, r4.w); + let v_21 = fma(v5.xxx, r4.xyz, v_17.xyz); + r4 = vec4(v_21.xyz, r4.w); + r0.w = dot(r4.xyz, r4.xyz); + r0.w = inverseSqrt(r0.w); + let v_22 = (r0.www * r4.xyz); + r4 = vec4(v_22.xy, r4.z, v_22.z); + r5 = vec4(((v1.xyz * v1.xyz)).xyz, r5.w); + let v_23 = (cb2_2.tint_symbol_3[15u].zy * cb8_8.tint_symbol_8[2u].zz); + r6 = vec4(v_23.xy, r6.zw); + r1.w = clamp(((cb2_2.tint_symbol_3[16u].zzzz + cb3_3.tint_symbol_4[49u].wwww)).w, 0.0f, 1.0f); + r1.w = (r1.w * r6.y); + r2.w = clamp(fma(r1.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r2.w = sqrt(r2.w); + r2.w = fma((-(r2.wwww)).w, cb6_6.tint_symbol_5[3u].z, 1.0f); + r2.w = (r2.w * cb8_8.tint_symbol_8[2u].y); + let v_24 = -(cb3_3.tint_symbol_4[0u].xyzx); + let v_25 = dot(r4.xyw, v_24.xyz); + r3.w = clamp(vec4(v_25, v_25, v_25, v_25).w, 0.0f, 1.0f); + r3.w = (r3.w + cb13_13.tint_symbol[0u].x); + r5.w = (cb13_13.tint_symbol[0u].x + 1.0f); + r5.w = (r5.w * r5.w); + r3.w = clamp(((r3.wwww / r5.wwww)).w, 0.0f, 1.0f); + let v_26 = (r3.www * r5.xyz); + r6 = vec4(r6.x, v_26.xyz); + let v_27 = (r6.yzw * cb3_3.tint_symbol_4[1u].xyz); + r6 = vec4(r6.x, v_27.xyz); + o9 = ((r2.www * r6.yzw)).xyzx; + r2.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_4[2u].x)))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_4[19u].w == 0.0f))); + let v_28 = ((-(r1.xxyz)).yzw + cb3_3.tint_symbol_4[3u].xyz); + r6 = vec4(r6.x, v_28.xyz); + let v_29 = -(cb3_3.tint_symbol_4[3u].xyzx); + let v_30 = (r1.xyz + v_29.xyz); + r7 = vec4(v_30.xyz, r7.w); + r7.x = dot(r7.xyz, cb3_3.tint_symbol_4[11u].xyz); + r7.x = clamp(((r7.xxxx / cb3_3.tint_symbol_4[19u].wwww)).x, 0.0f, 1.0f); + r7.x = (r7.x * cb3_3.tint_symbol_4[19u].w); + let v_31 = fma(cb3_3.tint_symbol_4[11u].xyz, r7.xxx, cb3_3.tint_symbol_4[3u].xyz); + r7 = vec4(v_31.xyz, r7.w); + let v_32 = ((-(r1.xyzx)).xyz + r7.xyz); + r7 = vec4(v_32.xyz, r7.w); + let v_33 = bitcast>(r3.www); + let v_34 = r6.yzw; + let v_35 = select(r7.xyz, v_34, (v_33 != vec3())); + r6 = vec4(r6.x, v_35.xyz); + r3.w = dot(r6.yzw, r6.yzw); + let v_36 = (r6.yzw + vec3(0.00000099999999747524f)); + r6 = vec4(r6.x, v_36.xyz); + r7.x = dot(r6.yzw, r6.yzw); + r7.x = inverseSqrt(r7.x); + let v_37 = (r6.yzw * r7.xxx); + r6 = vec4(r6.x, v_37.xyz); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.x = ((-(cb3_3.tint_symbol_4[11u].wwww)).x + 1.0f); + r7.x = fma(r7.x, r3.w, cb3_3.tint_symbol_4[11u].w); + r3.w = (r3.w / r7.x); + let v_38 = -(cb3_3.tint_symbol_4[11u].xyzx); + r7.x = dot(r6.yzw, v_38.xyz); + r7.x = clamp(fma(r7.xxxx, cb3_3.tint_symbol_4[27u].xxxx, cb3_3.tint_symbol_4[35u].xxxx).x, 0.0f, 1.0f); + let v_39 = dot(r6.yzw, r4.xyw); + r6.y = clamp(vec4(v_39, v_39, v_39, v_39).y, 0.0f, 1.0f); + r6.y = (r6.y + cb13_13.tint_symbol[0u].x); + r6.y = clamp(((r6.yyyy / r5.wwww)).y, 0.0f, 1.0f); + r6.y = (r7.x * r6.y); + r3.w = (r3.w * r6.y); + let v_40 = (r3.www * cb3_3.tint_symbol_4[19u].xyz); + r6 = vec4(r6.x, v_40.xyz); + let v_41 = (r5.xyz * r6.yzw); + r6 = vec4(r6.x, v_41.xyz); + let v_42 = bitcast>(r2.www); + let v_43 = select(r6.yzw, vec3(), (v_42 != vec3())); + r6 = vec4(r6.x, v_43.xyz); + r3.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_4[2u].x)))); + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_4[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_4[20u].w == 0.0f))); + let v_44 = ((-(r1.xyzx)).xyz + cb3_3.tint_symbol_4[4u].xyz); + r7 = vec4(v_44.xyz, r7.w); + let v_45 = -(cb3_3.tint_symbol_4[4u].xyzx); + let v_46 = (r1.xyz + v_45.xyz); + r8 = vec4(v_46.xyz, r8.w); + r7.w = dot(r8.xyz, cb3_3.tint_symbol_4[12u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_4[20u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_4[20u].w); + let v_47 = fma(cb3_3.tint_symbol_4[12u].xyz, r7.www, cb3_3.tint_symbol_4[4u].xyz); + r8 = vec4(v_47.xyz, r8.w); + let v_48 = ((-(r1.xyzx)).xyz + r8.xyz); + r8 = vec4(v_48.xyz, r8.w); + let v_49 = bitcast>(r3.www); + let v_50 = r7.xyz; + let v_51 = select(r8.xyz, v_50, (v_49 != vec3())); + r7 = vec4(v_51.xyz, r7.w); + r3.w = dot(r7.xyz, r7.xyz); + let v_52 = (r7.xyz + vec3(0.00000099999999747524f)); + r7 = vec4(v_52.xyz, r7.w); + r7.w = dot(r7.xyz, r7.xyz); + r7.w = inverseSqrt(r7.w); + let v_53 = (r7.www * r7.xyz); + r7 = vec4(v_53.xyz, r7.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_4[12u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r3.w, cb3_3.tint_symbol_4[12u].w); + r3.w = (r3.w / r7.w); + let v_54 = -(cb3_3.tint_symbol_4[12u].xyzx); + r7.w = dot(r7.xyz, v_54.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_4[28u].xxxx, cb3_3.tint_symbol_4[36u].xxxx).w, 0.0f, 1.0f); + let v_55 = dot(r7.xyz, r4.xyw); + r7.x = clamp(vec4(v_55, v_55, v_55, v_55).x, 0.0f, 1.0f); + r7.x = (r7.x + cb13_13.tint_symbol[0u].x); + r7.x = clamp(((r7.xxxx / r5.wwww)).x, 0.0f, 1.0f); + r7.x = (r7.w * r7.x); + r3.w = (r3.w * r7.x); + let v_56 = (r3.www * cb3_3.tint_symbol_4[20u].xyz); + r7 = vec4(v_56.xyz, r7.w); + let v_57 = fma(r7.xyz, r5.xyz, r6.yzw); + r7 = vec4(v_57.xyz, r7.w); + let v_58 = bitcast>(r2.www); + let v_59 = r6.yzw; + let v_60 = select(r7.xyz, v_59, (v_58 != vec3())); + r6 = vec4(r6.x, v_60.xyz); + } else { + r2.w = bitcast(v_1.tint_symbol_9[0i].x); + } + if ((bitcast(r2.w) != 0u)) { + r2.w = bitcast(v_1.tint_symbol_9[0i].x); + } else { + r3.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_4[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_4[21u].w == 0.0f))); + let v_61 = ((-(r1.xyzx)).xyz + cb3_3.tint_symbol_4[5u].xyz); + r7 = vec4(v_61.xyz, r7.w); + let v_62 = -(cb3_3.tint_symbol_4[5u].xyzx); + let v_63 = (r1.xyz + v_62.xyz); + r8 = vec4(v_63.xyz, r8.w); + r7.w = dot(r8.xyz, cb3_3.tint_symbol_4[13u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_4[21u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_4[21u].w); + let v_64 = fma(cb3_3.tint_symbol_4[13u].xyz, r7.www, cb3_3.tint_symbol_4[5u].xyz); + r8 = vec4(v_64.xyz, r8.w); + let v_65 = ((-(r1.xyzx)).xyz + r8.xyz); + r8 = vec4(v_65.xyz, r8.w); + let v_66 = bitcast>(r3.www); + let v_67 = r7.xyz; + let v_68 = select(r8.xyz, v_67, (v_66 != vec3())); + r7 = vec4(v_68.xyz, r7.w); + r3.w = dot(r7.xyz, r7.xyz); + let v_69 = (r7.xyz + vec3(0.00000099999999747524f)); + r7 = vec4(v_69.xyz, r7.w); + r7.w = dot(r7.xyz, r7.xyz); + r7.w = inverseSqrt(r7.w); + let v_70 = (r7.www * r7.xyz); + r7 = vec4(v_70.xyz, r7.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_4[13u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r3.w, cb3_3.tint_symbol_4[13u].w); + r3.w = (r3.w / r7.w); + let v_71 = -(cb3_3.tint_symbol_4[13u].xyzx); + r7.w = dot(r7.xyz, v_71.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_4[29u].xxxx, cb3_3.tint_symbol_4[37u].xxxx).w, 0.0f, 1.0f); + let v_72 = dot(r7.xyz, r4.xyw); + r7.x = clamp(vec4(v_72, v_72, v_72, v_72).x, 0.0f, 1.0f); + r7.x = (r7.x + cb13_13.tint_symbol[0u].x); + r7.x = clamp(((r7.xxxx / r5.wwww)).x, 0.0f, 1.0f); + r7.x = (r7.w * r7.x); + r3.w = (r3.w * r7.x); + let v_73 = (r3.www * cb3_3.tint_symbol_4[21u].xyz); + r7 = vec4(v_73.xyz, r7.w); + let v_74 = fma(r7.xyz, r5.xyz, r6.yzw); + r7 = vec4(v_74.xyz, r7.w); + let v_75 = bitcast>(r2.www); + let v_76 = r6.yzw; + let v_77 = select(r7.xyz, v_76, (v_75 != vec3())); + r6 = vec4(r6.x, v_77.xyz); + } + if ((bitcast(r2.w) != 0u)) { + } else { + r3.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_4[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_4[22u].w == 0.0f))); + let v_78 = ((-(r1.xyzx)).xyz + cb3_3.tint_symbol_4[6u].xyz); + r7 = vec4(v_78.xyz, r7.w); + let v_79 = -(cb3_3.tint_symbol_4[6u].xyzx); + let v_80 = (r1.xyz + v_79.xyz); + r8 = vec4(v_80.xyz, r8.w); + r7.w = dot(r8.xyz, cb3_3.tint_symbol_4[14u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_4[22u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_4[22u].w); + let v_81 = fma(cb3_3.tint_symbol_4[14u].xyz, r7.www, cb3_3.tint_symbol_4[6u].xyz); + r8 = vec4(v_81.xyz, r8.w); + let v_82 = ((-(r1.xyzx)).xyz + r8.xyz); + r8 = vec4(v_82.xyz, r8.w); + let v_83 = bitcast>(r3.www); + let v_84 = r7.xyz; + let v_85 = select(r8.xyz, v_84, (v_83 != vec3())); + r7 = vec4(v_85.xyz, r7.w); + r3.w = dot(r7.xyz, r7.xyz); + let v_86 = (r7.xyz + vec3(0.00000099999999747524f)); + r7 = vec4(v_86.xyz, r7.w); + r7.w = dot(r7.xyz, r7.xyz); + r7.w = inverseSqrt(r7.w); + let v_87 = (r7.www * r7.xyz); + r7 = vec4(v_87.xyz, r7.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_4[14u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r3.w, cb3_3.tint_symbol_4[14u].w); + r3.w = (r3.w / r7.w); + let v_88 = -(cb3_3.tint_symbol_4[14u].xyzx); + r7.w = dot(r7.xyz, v_88.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_4[30u].xxxx, cb3_3.tint_symbol_4[38u].xxxx).w, 0.0f, 1.0f); + let v_89 = dot(r7.xyz, r4.xyw); + r7.x = clamp(vec4(v_89, v_89, v_89, v_89).x, 0.0f, 1.0f); + r7.x = (r7.x + cb13_13.tint_symbol[0u].x); + r5.w = clamp(((r7.xxxx / r5.wwww)).w, 0.0f, 1.0f); + r5.w = (r7.w * r5.w); + r3.w = (r3.w * r5.w); + let v_90 = (r3.www * cb3_3.tint_symbol_4[22u].xyz); + r7 = vec4(v_90.xyz, r7.w); + let v_91 = fma(r7.xyz, r5.xyz, r6.yzw); + r7 = vec4(v_91.xyz, r7.w); + let v_92 = bitcast>(r2.www); + let v_93 = r6.yzw; + let v_94 = select(r7.xyz, v_93, (v_92 != vec3())); + r6 = vec4(r6.x, v_94.xyz); + } + r0.w = fma(r4.z, r0.w, cb3_3.tint_symbol_4[43u].w); + r0.w = (r0.w * cb3_3.tint_symbol_4[44u].w); + r0.w = max(r0.w, 0.0f); + let v_95 = fma(cb3_3.tint_symbol_4[47u].xyz, r0.www, cb3_3.tint_symbol_4[48u].xyz); + r7 = vec4(v_95.xyz, r7.w); + r2.w = ((-(cb2_2.tint_symbol_3[16u].zzzz)).w + 1.0f); + let v_96 = fma(cb3_3.tint_symbol_4[45u].xyz, r0.www, cb3_3.tint_symbol_4[46u].xyz); + r8 = vec4(v_96.xyz, r8.w); + let v_97 = (r8.xyz * cb2_2.tint_symbol_3[16u].zzz); + r8 = vec4(v_97.xyz, r8.w); + let v_98 = fma(r7.xyz, r2.www, r8.xyz); + r7 = vec4(v_98.xyz, r7.w); + let v_99 = (r1.www * r7.xyz); + r7 = vec4(v_99.xyz, r7.w); + let v_100 = fma(cb3_3.tint_symbol_4[43u].xyz, r0.www, cb3_3.tint_symbol_4[44u].xyz); + r8 = vec4(v_100.xyz, r8.w); + r9.x = cb3_3.tint_symbol_4[46u].w; + r9.y = cb3_3.tint_symbol_4[47u].w; + r9.z = cb3_3.tint_symbol_4[48u].w; + let v_101 = dot(r9.xyz, r4.xyw); + r0.w = clamp(vec4(v_101, v_101, v_101, v_101).w, 0.0f, 1.0f); + let v_102 = fma(cb3_3.tint_symbol_4[49u].xyz, r0.www, r8.xyz); + r4 = vec4(v_102.xyz, r4.w); + let v_103 = fma(r4.xyz, r6.xxx, r7.xyz); + r4 = vec4(v_103.xyz, r4.w); + let v_104 = (r5.xyz * r4.xyz); + r4 = vec4(v_104.xyz, r4.w); + let v_105 = fma(r6.yzw, cb8_8.tint_symbol_8[3u].xxx, r4.xyz); + o0 = vec4(v_105.xyz, o0.w); + r0.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r0.w = (r0.w * 0.5f); + let v_106 = r2; + r4 = vec4(v_106.xyz, r4.w); + r1.w = 0.0f; + r2.w = 0.0f; + loop { + r3.w = f32(bitcast(r2.w)); + r3.w = bitcast(select(0u, 4294967295u, (r3.w >= 4.0f))); + if ((bitcast(r3.w) != 0u)) { + break; + } + let v_107 = -(cb1_1.tint_symbol_1[15u].xyzx); + let v_108 = (r4.xyz + v_107.xyz); + r5 = vec4(v_108.xyz, r5.w); + let v_109 = (r5.yyy * cb6_6.tint_symbol_5[1u].xyz); + r6 = vec4(v_109.xyz, r6.w); + let v_110 = fma(r5.xxx, cb6_6.tint_symbol_5[0u].xyz, r6.xyz); + r5 = vec4(v_110.xy, r5.z, v_110.z); + let v_111 = fma(r5.zzz, cb6_6.tint_symbol_5[2u].xyz, r5.xyw); + r5 = vec4(v_111.xyz, r5.w); + let v_112 = fma(r5.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r6 = vec4(v_112.xyz, r6.w); + let v_113 = &(x4[0u]); + let v_114 = r6; + *(v_113) = vec4(v_114.xyz, (*(v_113)).w); + let v_115 = fma(r5.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r7 = vec4(v_115.xyz, r7.w); + let v_116 = &(x4[1u]); + let v_117 = r7; + *(v_116) = vec4(v_117.xyz, (*(v_116)).w); + let v_118 = fma(r5.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r8 = vec4(v_118.xyz, r8.w); + let v_119 = &(x4[2u]); + let v_120 = r8; + *(v_119) = vec4(v_120.xyz, (*(v_119)).w); + let v_121 = fma(r5.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r5 = vec4(v_121.xyz, r5.w); + let v_122 = &(x4[3u]); + let v_123 = r5; + *(v_122) = vec4(v_123.xyz, (*(v_122)).w); + let v_124 = abs(r8.yyyy); + r3.w = max(v_124.w, abs(r8.xxxx).w); + r3.w = bitcast(select(0u, 4294967295u, (r3.w < r0.w))); + let v_125 = (bitcast(r3.w) != 0u); + let v_126 = bitcast(v_1.tint_symbol_9[1i].x); + r3.w = select(bitcast(v_1.tint_symbol_9[2i].x), v_126, v_125); + let v_127 = abs(r7.yyyy); + r4.w = max(v_127.w, abs(r7.xxxx).w); + r4.w = bitcast(select(0u, 4294967295u, (r4.w < r0.w))); + let v_128 = bitcast(r4.w); + r3.w = select(r3.w, bitcast(v_1.tint_symbol_9[3i].x), (v_128 != 0u)); + let v_129 = abs(r6.yyyy); + r4.w = max(v_129.w, abs(r6.xxxx).w); + r4.w = bitcast(select(0u, 4294967295u, (r4.w < r0.w))); + let v_130 = bitcast(r4.w); + r3.w = select(r3.w, 0.0f, (v_130 != 0u)); + let v_131 = x4[bitcast(r3.w)]; + r5 = vec4(v_131.xyz, r5.w); + r3.w = f32(bitcast(r3.w)); + r3.w = (r3.w + 0.5f); + r3.w = (r3.w * 0.25f); + r5.x = (r5.x + cb6_6.tint_symbol_5[14u].z); + r3.w = fma(r5.y, 0.25f, r3.w); + let v_132 = (r5.xz + vec2(0.5f, 0.0f)); + let v_133 = r5; + r5 = vec4(v_132.x, v_133.y, v_132.y, v_133.w); + r5.y = fma(cb6_6.tint_symbol_5[14u].w, 0.25f, r3.w); + let v_134 = r5.xyxx; + r3.w = textureSampleCompareLevel(t15, s15, v_134.xy, r5.z); + r1.w = (r1.w + r3.w); + r2.w = bitcast((bitcast(r2.w) + 1i)); + } + r0.w = fma(r1.w, 0.25f, -1.0f); + o7.z = fma(v4.z, r0.w, 1.0f); + o0.w = (v1.w * v4.y); + r0.w = dot(r3.xyz, r3.xyz); + r1.w = sqrt(r0.w); + let v_135 = -(cb3_3.tint_symbol_4[50u].xxxx); + r2.x = (r1.w + v_135.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r3.z); + r2.y = (r1.w * cb3_3.tint_symbol_4[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_136 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_136 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_4[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_4[52u].y); + r0.w = inverseSqrt(r0.w); + let v_137 = (r0.www * r3.xyz); + r3 = vec4(v_137.xyz, r3.w); + let v_138 = dot(r3.xyz, cb3_3.tint_symbol_4[54u].xyz); + r0.w = clamp(vec4(v_138, v_138, v_138, v_138).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_4[54u].w); + r0.w = exp2(r0.w); + let v_139 = dot(r3.xyz, cb3_3.tint_symbol_4[53u].xyz); + r2.z = clamp(vec4(v_139, v_139, v_139, v_139).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_4[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_4[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_4[51u].y); + let v_140 = -(cb3_3.tint_symbol_4[52u].xxxx); + r2.w = (r2.x + v_140.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_4[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + o4.w = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).w, 0.0f, 1.0f); + let v_141 = -(cb3_3.tint_symbol_4[51u].zzzz); + r2.x = (r2.x * v_141.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_142 = ((-(cb3_3.tint_symbol_4[56u].xyzx)).xyz + cb3_3.tint_symbol_4[58u].xyz); + r3 = vec4(v_142.xyz, r3.w); + let v_143 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_4[56u].xyz); + r3 = vec4(v_143.xyz, r3.w); + let v_144 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_4[55u].xyz); + r4 = vec4(v_144.xyz, r4.w); + let v_145 = fma(r2.zzz, r4.xyz, r3.xyz); + r2 = vec4(r2.x, v_145.xyz); + let v_146 = -(cb3_3.tint_symbol_4[57u].xxyz); + let v_147 = (r2.yzw + v_146.yzw); + r2 = vec4(r2.x, v_147.xyz); + let v_148 = fma(r2.xxx, r2.yzw, cb3_3.tint_symbol_4[57u].xyz); + r2 = vec4(v_148.xyz, r2.w); + r3.x = ((-(r2.xxxx)).x + cb3_3.tint_symbol_4[55u].w); + r3.y = ((-(r2.yyyy)).y + cb3_3.tint_symbol_4[56u].w); + r3.z = ((-(r2.zzzz)).z + cb3_3.tint_symbol_4[57u].w); + let v_149 = fma(r1.www, r3.xyz, r2.xyz); + o4 = vec4(v_149.xyz, o4.w); + x5[0u].x = dot(r0.xyz, cb0_0.tint_symbol_2[0u].xyw); + o2 = vec4(o2.xy, vec2()); + o5.x = v4.x; + o5 = vec4(o5.x, v1.xyz); + o6 = vec4(v5.xy, o6.zw); + o6 = vec4(o6.xy, vec2()); + o7 = vec4(vec2(), o7.z, 0.0f); + let v_150 = r1; + o8 = vec4(v_150.xyz, o8.w); + o8.w = 0.0f; + o10 = vec4(); + let v_151 = r0; + o11 = vec4(v_151.xy, o11.zw); + o11 = vec4(o11.xy, vec2(0.0f, 1.0f)); + let v_152 = &(x5[0u]); + *(v_152) = vec4((*(v_152)).x, vec3()); + o3.y = v3.y; + o12[0u] = x5[0u].x; + o12[1u] = x5[0u].y; + o12[2u] = x5[0u].z; + o12[3u] = x5[0u].w; + v = vec4(o12[0u], o12[1u], o12[2u], o12[3u]); +} + +struct tint_symbol_12 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, + @location(6u) + o6 : vec4, + @location(7u) + o7 : vec4, + @location(8u) + o8 : vec4, + @location(9u) + o9 : vec4, + @location(10u) + o10 : vec4, + @builtin(position) + o11 : vec4, + @builtin(clip_distances) + o12 : array, + @location(15u) + tint_symbol_11 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @location(7u) v7 : vec4, @location(8u) v8 : vec4, @location(9u) v9 : vec4, @location(10u) v10 : vec4, @location(11u) v11 : vec4, @location(13u) v13 : vec3) -> tint_symbol_12 { + main_inner(v0, v1, v3, v4, v5, v6, v7, v8, v9, v10, v11, v13); + return tint_symbol_12(o0, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, v); +} diff --git a/b/8b0b5899ed/shaders/00dfd3a1331419c1.consts.json b/b/8b0b5899ed/shaders/00dfd3a1331419c1.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/00dfd3a1331419c1.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/00dfd3a1331419c1.wgsl b/b/8b0b5899ed/shaders/00dfd3a1331419c1.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..d524dad6842336b87a6d115deb95e74a85879644 --- /dev/null +++ b/b/8b0b5899ed/shaders/00dfd3a1331419c1.wgsl @@ -0,0 +1,957 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb1_struct { + tint_symbol_4 : array, 1u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb1_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(17u) var s1 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(33u) var t1 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v8 : vec4; + +var v9 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v5 : vec4, v6 : vec4, v7 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v8 = v_2; + x1[0u].x = v9[0u]; + x1[0u].y = v9[1u]; + x1[0u].z = v9[2u]; + x1[0u].w = v9[3u]; + r0 = textureSample(t0, s0, v2.xy.xyxx.xy); + r1 = textureSample(t3, s3, v2.xy.xyxx.xy); + let v_3 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_3.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[0u].w, 0.00100000004749745131f); + let v_4 = (r1.ww * r1.xy); + r1 = vec4(v_4.xy, r1.zw); + let v_5 = (r1.yyy * v6.xyz); + r2 = vec4(v_5.xyz, r2.w); + let v_6 = fma(r1.xxx, v5.xyz, r2.xyz); + r1 = vec4(v_6.xy, r1.z, v_6.z); + let v_7 = fma(r1.zzz, v3.xyz, r1.xyw); + r1 = vec4(v_7.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_8 = (r1.www * r1.xyz); + r2 = vec4(v_8.xyz, r2.w); + let v_9 = (r0.xyz * v1.xyz); + r0 = vec4(v_9.xyz, r0.w); + r0.w = (r0.w * v0.w); + let v_10 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r1 = vec4(v_10.xy, r1.zw); + let v_11 = (r0.xyz * r0.xyz); + r0 = vec4(v_11.xyz, r0.w); + let v_12 = -(v7.xyzx); + let v_13 = (v_12.xyz + cb1_1.tint_symbol[15u].xyz); + r3 = vec4(v_13.xyz, r3.w); + r2.w = dot(r3.xyz, r3.xyz); + r2.w = inverseSqrt(r2.w); + let v_14 = (r2.www * r3.xyz); + r4 = vec4(v_14.xyz, r4.w); + let v_15 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_16 = fma(r3.xyz, r2.www, v_15.xyz); + r5 = vec4(v_16.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + r3.w = inverseSqrt(r3.w); + let v_17 = (r3.www * r5.xyz); + r5 = vec4(v_17.xyz, r5.w); + r3.w = clamp(cb12_12.tint_symbol_4[0u].z, 0.0f, 1.0f); + let v_18 = (r1.xy * r1.xy); + r1 = vec4(v_18.xy, r1.zw); + r4.w = (cb12_12.tint_symbol_4[0u].y + -500.0f); + r4.w = max(r4.w, 0.0f); + r5.w = ((-(r4.wwww)).w + cb12_12.tint_symbol_4[0u].y); + r4.w = (r4.w * 558.0f); + r4.w = fma(r5.w, 3.0f, r4.w); + r5.w = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz); + let v_19 = (v7.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r6 = vec4(v_19.xyz, r6.w); + let v_20 = (r6.yyy * cb6_6.tint_symbol_5[1u].xyz); + r7 = vec4(v_20.xyz, r7.w); + let v_21 = fma(r6.xxx, cb6_6.tint_symbol_5[0u].xyz, r7.xyz); + r7 = vec4(v_21.xyz, r7.w); + let v_22 = fma(r6.zzz, cb6_6.tint_symbol_5[2u].xyz, r7.xyz); + r7 = vec4(v_22.xyz, r7.w); + let v_23 = fma(r7.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r8 = vec4(v_23.xyz, r8.w); + let v_24 = &(x0[0u]); + let v_25 = r8; + *(v_24) = vec4(v_25.xyz, (*(v_24)).w); + let v_26 = fma(r7.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r9 = vec4(v_26.xyz, r9.w); + let v_27 = &(x0[1u]); + let v_28 = r9; + *(v_27) = vec4(v_28.xyz, (*(v_27)).w); + let v_29 = fma(r7.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r10 = vec4(v_29.xyz, r10.w); + let v_30 = &(x0[2u]); + let v_31 = r10; + *(v_30) = vec4(v_31.xyz, (*(v_30)).w); + let v_32 = fma(r7.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r7 = vec4(v_32.xyz, r7.w); + let v_33 = &(x0[3u]); + let v_34 = r7; + *(v_33) = vec4(v_34.xyz, (*(v_33)).w); + let v_35 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_36 = r11; + r11 = vec4(v_36.x, v_35.x, v_36.z, v_35.y); + r6.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r6.w = (r6.w * 0.5f); + let v_37 = abs(r10.yyyy); + r7.z = max(v_37.z, abs(r10.xxxx).z); + r7.z = bitcast(select(0u, 4294967295u, (r7.z < r6.w))); + let v_38 = (bitcast(r7.z) != 0u); + let v_39 = bitcast(v.tint_symbol_6[0i].x); + r7.z = select(bitcast(v.tint_symbol_6[1i].x), v_39, v_38); + let v_40 = abs(r9.yyyy); + r7.w = max(v_40.w, abs(r9.xxxx).w); + r7.w = bitcast(select(0u, 4294967295u, (r7.w < r6.w))); + let v_41 = bitcast(r7.w); + r7.z = select(r7.z, bitcast(v.tint_symbol_6[2i].x), (v_41 != 0u)); + let v_42 = abs(r8.yyyy); + r7.w = max(v_42.w, abs(r8.xxxx).w); + r6.w = bitcast(select(0u, 4294967295u, (r7.w < r6.w))); + let v_43 = bitcast(r6.w); + r6.w = select(r7.z, 0.0f, (v_43 != 0u)); + let v_44 = x0[bitcast(r6.w)]; + r8 = vec4(v_44.xyz, r8.w); + r6.w = f32(bitcast(r6.w)); + r7.z = (r6.w + 0.5f); + r7.z = (r7.z * 0.25f); + r9 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r6.wwww))); + r9 = bitcast>((bitcast>(r9) & vec4(1065353216u))); + r6.w = dot(r9, cb6_6.tint_symbol_5[12u]); + r7.w = dot(r9, cb6_6.tint_symbol_5[13u]); + r9.x = (r8.x + 0.5f); + r9.y = fma(r8.y, 0.25f, r7.z); + r7.z = bitcast(select(0u, 4294967295u, !((r6.w == 0.0f)))); + r6.w = ((-(r6.wwww)).w + r8.z); + let v_45 = dpdx(r9.xyy); + r10 = vec4(v_45.xy, r10.z, v_45.z); + r10.z = dpdx(r6.w); + let v_46 = dpdy(r9.yxy); + r12 = vec4(v_46.xyz, r12.w); + r12.w = dpdy(r6.w); + let v_47 = (r10.yw * r12.yw); + r8 = vec4(v_47.xy, r8.zw); + let v_48 = -(r8.xyxx); + let v_49 = fma(r10.xz, r12.xz, v_48.xy); + r13 = vec4(v_49.xy, r13.zw); + r8.x = (1.0f / r13.x); + r8.y = (r10.z * r12.y); + let v_50 = -(r8.yyyy); + r13.z = fma(r10.x, r12.w, v_50.z); + let v_51 = (r8.xx * r13.yz); + r8 = vec4(v_51.xy, r8.zw); + let v_52 = max(r8.xy, vec2()); + r8 = vec4(v_52.xy, r8.zw); + let v_53 = min(r8.xy, vec2(0.5f)); + r8 = vec4(v_53.xy, r8.zw); + r6.w = fma((-(r7.wwww)).w, r8.x, r6.w); + r6.w = fma((-(r7.wwww)).w, r8.y, r6.w); + let v_54 = bitcast(r7.z); + let v_55 = r6.w; + r11.z = select(r8.z, v_55, (v_54 != 0u)); + r9.z = 0.0f; + let v_56 = (r9.xyz + r11.ywz); + r8 = vec4(v_56.xyz, r8.w); + let v_57 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r11 = vec4(v_57.xy, r11.zw); + let v_58 = (r9.xyz + r11.xyz); + r10 = vec4(v_58.xyz, r10.w); + let v_59 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r11 = vec4(v_59.xy, r11.zw); + let v_60 = (r9.xyz + r11.xyz); + r12 = vec4(v_60.xyz, r12.w); + let v_61 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r11 = vec4(v_61.xy, r11.zw); + let v_62 = (r9.xyz + r11.xyz); + r13 = vec4(v_62.xyz, r13.w); + let v_63 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r11 = vec4(v_63.xy, r11.zw); + let v_64 = (r9.xyz + r11.xyz); + r14 = vec4(v_64.xyz, r14.w); + let v_65 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r11 = vec4(v_65.xy, r11.zw); + let v_66 = (r9.xyz + r11.xyz); + r15 = vec4(v_66.xyz, r15.w); + let v_67 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r11 = vec4(v_67.xy, r11.zw); + let v_68 = (r9.xyz + r11.xyz); + r16 = vec4(v_68.xyz, r16.w); + let v_69 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r11 = vec4(v_69.xy, r11.zw); + let v_70 = (r9.xyz + r11.xyz); + r17 = vec4(v_70.xyz, r17.w); + let v_71 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r11 = vec4(v_71.xy, r11.zw); + let v_72 = (r9.xyz + r11.xyz); + r18 = vec4(v_72.xyz, r18.w); + let v_73 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r11 = vec4(v_73.xy, r11.zw); + let v_74 = (r9.xyz + r11.xyz); + r19 = vec4(v_74.xyz, r19.w); + let v_75 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r11 = vec4(v_75.xy, r11.zw); + let v_76 = (r9.xyz + r11.xyz); + r20 = vec4(v_76.xyz, r20.w); + let v_77 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r11 = vec4(v_77.xy, r11.zw); + let v_78 = (r9.xyz + r11.xyz); + r21 = vec4(v_78.xyz, r21.w); + let v_79 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r11 = vec4(v_79.xy, r11.zw); + let v_80 = (r9.xyz + r11.xyz); + r22 = vec4(v_80.xyz, r22.w); + let v_81 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r11 = vec4(v_81.xy, r11.zw); + let v_82 = (r9.xyz + r11.xyz); + r23 = vec4(v_82.xyz, r23.w); + let v_83 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r11 = vec4(v_83.xy, r11.zw); + let v_84 = (r9.xyz + r11.xyz); + r24 = vec4(v_84.xyz, r24.w); + let v_85 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r11 = vec4(v_85.xy, r11.zw); + let v_86 = (r9.xyz + r11.xyz); + r9 = vec4(v_86.xyz, r9.w); + let v_87 = r8.xyxx; + r8.x = textureSampleCompareLevel(t15, s15, v_87.xy, r8.z); + let v_88 = r10.xyxx; + r8.y = textureSampleCompareLevel(t15, s15, v_88.xy, r10.z); + let v_89 = r12.xyxx; + r8.z = textureSampleCompareLevel(t15, s15, v_89.xy, r12.z); + let v_90 = r13.xyxx; + r8.w = textureSampleCompareLevel(t15, s15, v_90.xy, r13.z); + let v_91 = r14.xyxx; + r10.x = textureSampleCompareLevel(t15, s15, v_91.xy, r14.z); + let v_92 = r15.xyxx; + r10.y = textureSampleCompareLevel(t15, s15, v_92.xy, r15.z); + let v_93 = r16.xyxx; + r10.z = textureSampleCompareLevel(t15, s15, v_93.xy, r16.z); + let v_94 = r17.xyxx; + r10.w = textureSampleCompareLevel(t15, s15, v_94.xy, r17.z); + let v_95 = r18.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_95.xy, r18.z); + let v_96 = r19.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_96.xy, r19.z); + let v_97 = r20.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_97.xy, r20.z); + let v_98 = r21.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_98.xy, r21.z); + let v_99 = r22.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_99.xy, r22.z); + let v_100 = r23.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_100.xy, r23.z); + let v_101 = r24.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_101.xy, r24.z); + let v_102 = r9.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_102.xy, r9.z); + r8 = (r8 + r10); + r8 = (r11 + r8); + r8 = (r12 + r8); + r6.w = dot(r8, vec4(1.0f)); + r5.w = clamp(fma(r5.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f); + let v_103 = abs(r7.yyyy); + r7.x = max(v_103.x, abs(r7.xxxx).x); + r7.x = clamp(fma(r7.xxxx, vec4(15.0f), vec4(-6.30000019073486328125f)).x, 0.0f, 1.0f); + r5.w = ((-(r5.wwww)).w + 1.0f); + r5.w = (r7.x * r5.w); + r5.w = fma(r6.w, 0.0625f, r5.w); + r5.w = (r5.w * r5.w); + r5.w = min(r5.w, 1.0f); + r6.w = clamp(fma(v7.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r6.w = sqrt(r6.w); + r6.w = (r6.w * cb6_6.tint_symbol_5[3u].z); + let v_104 = -(r5.wwww); + r5.w = fma(r6.w, v_104.w, r5.w); + let v_105 = dot(r2.xyz, v_15.xyz); + r6.w = clamp(vec4(v_105, v_105, v_105, v_105).w, 0.0f, 1.0f); + let v_106 = dot(r4.xyz, r2.xyz); + r7.x = clamp(vec4(v_106, v_106, v_106, v_106).x, 0.0f, 1.0f); + let v_107 = dot(r5.xyz, v_15.xyz); + r7.y = clamp(vec4(v_107, v_107, v_107, v_107).y, 0.0f, 1.0f); + let v_108 = ((-(r7.xyxx)).xy + vec2(1.0f)); + r7 = vec4(v_108.xy, r7.zw); + let v_109 = (r7.xy * r7.xy); + r7 = vec4(r7.xy, v_109.xy); + let v_110 = (r7.zw * r7.zw); + r7 = vec4(r7.xy, v_110.xy); + let v_111 = (r7.xy * r7.zw); + r7 = vec4(v_111.xy, r7.zw); + r7.z = ((-(cb12_12.tint_symbol_4[0u].xxxx)).z + 1.0f); + let v_112 = fma(cb12_12.tint_symbol_4[0u].xx, r7.xy, r7.zz); + r7 = vec4(v_112.xy, r7.zw); + let v_113 = (r4.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(v_113.xy, r8.zw); + r7.w = (r8.x * 0.125f); + r7.x = fma((-(r3.wwww)).x, r7.x, 1.0f); + r5.x = dot(r2.xyz, r5.xyz); + r5.x = clamp(((r5.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r5.x = log2(r5.x); + r5.x = (r5.x * r8.y); + r5.x = exp2(r5.x); + r5.x = (r7.y * r5.x); + r5.x = (r7.w * r5.x); + r5.x = (r3.w * r5.x); + r5.x = (r6.w * r5.x); + r5.y = (r6.w * r7.x); + let v_114 = fma(r0.xyz, r5.yyy, r5.xxx); + r5 = vec4(v_114.xyz, r5.w); + let v_115 = (r5.xyz * cb3_3.tint_symbol_2[1u].xyz); + r5 = vec4(v_115.xyz, r5.w); + r6.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r9 = vec4(r9.x, vec3()); + r8 = vec4(0.0f, r8.y, vec2()); + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_116 = ((-(v7.xxyz)).xzw + cb3_3.tint_symbol_2[3u].xyz); + r8 = vec4(v_116.x, r8.y, v_116.yz); + let v_117 = (v7.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r9 = vec4(v_117.xyz, r9.w); + r9.x = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz); + r9.x = clamp(((r9.xxxx / cb3_3.tint_symbol_2[19u].wwww)).x, 0.0f, 1.0f); + r9.x = (r9.x * cb3_3.tint_symbol_2[19u].w); + let v_118 = fma(cb3_3.tint_symbol_2[11u].xyz, r9.xxx, cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_118.xyz, r9.w); + let v_119 = (r9.xyz + v_12.xyz); + r9 = vec4(v_119.xyz, r9.w); + let v_120 = bitcast>(r7.yyy); + let v_121 = r8.xzw; + let v_122 = select(r9.xyz, v_121, (v_120 != vec3())); + r8 = vec4(v_122.x, r8.y, v_122.yz); + r7.y = dot(r8.xzw, r8.xzw); + let v_123 = (r8.xzw + vec3(0.00000099999999747524f)); + r8 = vec4(v_123.x, r8.y, v_123.yz); + r9.x = dot(r8.xzw, r8.xzw); + r9.x = inverseSqrt(r9.x); + let v_124 = (r8.xzw * r9.xxx); + r8 = vec4(v_124.x, r8.y, v_124.yz); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.x = ((-(cb3_3.tint_symbol_2[11u].wwww)).x + 1.0f); + r9.x = fma(r9.x, r7.y, cb3_3.tint_symbol_2[11u].w); + r7.y = (r7.y / r9.x); + let v_125 = -(cb3_3.tint_symbol_2[11u].xyzx); + r9.x = dot(r8.xzw, v_125.xyz); + r9.x = clamp(fma(r9.xxxx, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).x, 0.0f, 1.0f); + let v_126 = dot(r8.xzw, r2.xyz); + r9.y = clamp(vec4(v_126, v_126, v_126, v_126).y, 0.0f, 1.0f); + r9.x = (r9.x * r9.y); + r9.y = (r7.y * r9.x); + let v_127 = (r9.yyy * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(r9.x, v_127.xyz); + let v_128 = (r0.xyz * r9.yzw); + r9 = vec4(r9.x, v_128.xyz); + let v_129 = fma(r3.xyz, r2.www, r8.xzw); + r8 = vec4(v_129.x, r8.y, v_129.yz); + r10.x = dot(r8.xzw, r8.xzw); + r10.x = inverseSqrt(r10.x); + let v_130 = (r8.xzw * r10.xxx); + r8 = vec4(v_130.x, r8.y, v_130.yz); + let v_131 = dot(r8.xzw, r4.xyz); + r10.x = clamp(vec4(v_131, v_131, v_131, v_131).x, 0.0f, 1.0f); + r10.x = ((-(r10.xxxx)).x + 1.0f); + r10.y = (r10.x * r10.x); + r10.y = (r10.y * r10.y); + r10.x = (r10.y * r10.x); + r10.x = fma(cb12_12.tint_symbol_4[0u].x, r10.x, r7.z); + let v_132 = dot(r8.xzw, r2.xyz); + r8.x = clamp(vec4(v_132, v_132, v_132, v_132).x, 0.0f, 1.0f); + r8.x = log2(r8.x); + r8.x = (r8.x * r8.y); + r8.x = exp2(r8.x); + r8.x = (r8.x * r10.x); + r8.x = (r9.x * r8.x); + r7.y = (r7.y * r8.x); + r7.y = (r7.w * r7.y); + let v_133 = (r7.yyy * cb3_3.tint_symbol_2[19u].xyz); + r8 = vec4(v_133.x, r8.y, v_133.yz); + } + r7.y = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r7.y) != 0u)) { + r9.x = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r7.y = bitcast((bitcast(r6.w) | bitcast(r7.y))); + let v_134 = bitcast(r9.x); + let v_135 = r7.y; + r6.w = select(r6.w, v_135, (v_134 != 0u)); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_136 = (v_12.xyz + cb3_3.tint_symbol_2[4u].xyz); + r10 = vec4(v_136.xyz, r10.w); + let v_137 = (v7.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r11 = vec4(v_137.xyz, r11.w); + r9.x = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz); + r9.x = clamp(((r9.xxxx / cb3_3.tint_symbol_2[20u].wwww)).x, 0.0f, 1.0f); + r9.x = (r9.x * cb3_3.tint_symbol_2[20u].w); + let v_138 = fma(cb3_3.tint_symbol_2[12u].xyz, r9.xxx, cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_138.xyz, r11.w); + let v_139 = (r11.xyz + v_12.xyz); + r11 = vec4(v_139.xyz, r11.w); + let v_140 = bitcast>(r7.yyy); + let v_141 = r10.xyz; + let v_142 = select(r11.xyz, v_141, (v_140 != vec3())); + r10 = vec4(v_142.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_143 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_143.xyz, r10.w); + r9.x = dot(r10.xyz, r10.xyz); + r9.x = inverseSqrt(r9.x); + let v_144 = (r9.xxx * r10.xyz); + r10 = vec4(v_144.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.x = ((-(cb3_3.tint_symbol_2[12u].wwww)).x + 1.0f); + r9.x = fma(r9.x, r7.y, cb3_3.tint_symbol_2[12u].w); + r7.y = (r7.y / r9.x); + let v_145 = -(cb3_3.tint_symbol_2[12u].xyzx); + r9.x = dot(r10.xyz, v_145.xyz); + r9.x = clamp(fma(r9.xxxx, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).x, 0.0f, 1.0f); + let v_146 = dot(r10.xyz, r2.xyz); + r10.w = clamp(vec4(v_146, v_146, v_146, v_146).w, 0.0f, 1.0f); + r9.x = (r9.x * r10.w); + r10.w = (r7.y * r9.x); + let v_147 = (r10.www * cb3_3.tint_symbol_2[20u].xyz); + r11 = vec4(v_147.xyz, r11.w); + let v_148 = fma(r11.xyz, r0.xyz, r9.yzw); + r9 = vec4(r9.x, v_148.xyz); + let v_149 = fma(r3.xyz, r2.www, r10.xyz); + r10 = vec4(v_149.xyz, r10.w); + r10.w = dot(r10.xyz, r10.xyz); + r10.w = inverseSqrt(r10.w); + let v_150 = (r10.www * r10.xyz); + r10 = vec4(v_150.xyz, r10.w); + let v_151 = dot(r10.xyz, r4.xyz); + r10.w = clamp(vec4(v_151, v_151, v_151, v_151).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.x = (r10.w * r10.w); + r11.x = (r11.x * r11.x); + r10.w = (r10.w * r11.x); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.z); + let v_152 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_152, v_152, v_152, v_152).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r10.x = (r10.x * r10.w); + r9.x = (r9.x * r10.x); + r7.y = (r7.y * r9.x); + r7.y = (r7.w * r7.y); + let v_153 = fma(r7.yyy, cb3_3.tint_symbol_2[20u].xyz, r8.xzw); + r8 = vec4(v_153.x, r8.y, v_153.yz); + } + } else { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r7.y = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_154 = (v_12.xyz + cb3_3.tint_symbol_2[5u].xyz); + r10 = vec4(v_154.xyz, r10.w); + let v_155 = (v7.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r11 = vec4(v_155.xyz, r11.w); + r9.x = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz); + r9.x = clamp(((r9.xxxx / cb3_3.tint_symbol_2[21u].wwww)).x, 0.0f, 1.0f); + r9.x = (r9.x * cb3_3.tint_symbol_2[21u].w); + let v_156 = fma(cb3_3.tint_symbol_2[13u].xyz, r9.xxx, cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_156.xyz, r11.w); + let v_157 = (r11.xyz + v_12.xyz); + r11 = vec4(v_157.xyz, r11.w); + let v_158 = bitcast>(r7.yyy); + let v_159 = r10.xyz; + let v_160 = select(r11.xyz, v_159, (v_158 != vec3())); + r10 = vec4(v_160.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_161 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_161.xyz, r10.w); + r9.x = dot(r10.xyz, r10.xyz); + r9.x = inverseSqrt(r9.x); + let v_162 = (r9.xxx * r10.xyz); + r10 = vec4(v_162.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.x = ((-(cb3_3.tint_symbol_2[13u].wwww)).x + 1.0f); + r9.x = fma(r9.x, r7.y, cb3_3.tint_symbol_2[13u].w); + r7.y = (r7.y / r9.x); + let v_163 = -(cb3_3.tint_symbol_2[13u].xyzx); + r9.x = dot(r10.xyz, v_163.xyz); + r9.x = clamp(fma(r9.xxxx, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).x, 0.0f, 1.0f); + let v_164 = dot(r10.xyz, r2.xyz); + r10.w = clamp(vec4(v_164, v_164, v_164, v_164).w, 0.0f, 1.0f); + r9.x = (r9.x * r10.w); + r10.w = (r7.y * r9.x); + let v_165 = (r10.www * cb3_3.tint_symbol_2[21u].xyz); + r11 = vec4(v_165.xyz, r11.w); + let v_166 = fma(r11.xyz, r0.xyz, r9.yzw); + r9 = vec4(r9.x, v_166.xyz); + let v_167 = fma(r3.xyz, r2.www, r10.xyz); + r10 = vec4(v_167.xyz, r10.w); + r10.w = dot(r10.xyz, r10.xyz); + r10.w = inverseSqrt(r10.w); + let v_168 = (r10.www * r10.xyz); + r10 = vec4(v_168.xyz, r10.w); + let v_169 = dot(r10.xyz, r4.xyz); + r10.w = clamp(vec4(v_169, v_169, v_169, v_169).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.x = (r10.w * r10.w); + r11.x = (r11.x * r11.x); + r10.w = (r10.w * r11.x); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.z); + let v_170 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_170, v_170, v_170, v_170).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r10.x = (r10.x * r10.w); + r9.x = (r9.x * r10.x); + r7.y = (r7.y * r9.x); + r7.y = (r7.w * r7.y); + let v_171 = fma(r7.yyy, cb3_3.tint_symbol_2[21u].xyz, r8.xzw); + r8 = vec4(v_171.x, r8.y, v_171.yz); + } + } + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_172 = (v_12.xyz + cb3_3.tint_symbol_2[6u].xyz); + r10 = vec4(v_172.xyz, r10.w); + let v_173 = (v7.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r11 = vec4(v_173.xyz, r11.w); + r7.y = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz); + r7.y = clamp(((r7.yyyy / cb3_3.tint_symbol_2[22u].wwww)).y, 0.0f, 1.0f); + r7.y = (r7.y * cb3_3.tint_symbol_2[22u].w); + let v_174 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.yyy, cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_174.xyz, r11.w); + let v_175 = (r11.xyz + v_12.xyz); + r11 = vec4(v_175.xyz, r11.w); + let v_176 = bitcast>(r6.www); + let v_177 = r10.xyz; + let v_178 = select(r11.xyz, v_177, (v_176 != vec3())); + r10 = vec4(v_178.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_179 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_179.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + r7.y = inverseSqrt(r7.y); + let v_180 = (r7.yyy * r10.xyz); + r10 = vec4(v_180.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.y = ((-(cb3_3.tint_symbol_2[14u].wwww)).y + 1.0f); + r7.y = fma(r7.y, r6.w, cb3_3.tint_symbol_2[14u].w); + r6.w = (r6.w / r7.y); + let v_181 = -(cb3_3.tint_symbol_2[14u].xyzx); + r7.y = dot(r10.xyz, v_181.xyz); + r7.y = clamp(fma(r7.yyyy, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).y, 0.0f, 1.0f); + let v_182 = dot(r10.xyz, r2.xyz); + r9.x = clamp(vec4(v_182, v_182, v_182, v_182).x, 0.0f, 1.0f); + r7.y = (r7.y * r9.x); + r9.x = (r6.w * r7.y); + let v_183 = (r9.xxx * cb3_3.tint_symbol_2[22u].xyz); + r11 = vec4(v_183.xyz, r11.w); + let v_184 = fma(r11.xyz, r0.xyz, r9.yzw); + r9 = vec4(r9.x, v_184.xyz); + let v_185 = fma(r3.xyz, r2.www, r10.xyz); + r3 = vec4(v_185.xyz, r3.w); + r2.w = dot(r3.xyz, r3.xyz); + r2.w = inverseSqrt(r2.w); + let v_186 = (r2.www * r3.xyz); + r3 = vec4(v_186.xyz, r3.w); + let v_187 = dot(r3.xyz, r4.xyz); + r2.w = clamp(vec4(v_187, v_187, v_187, v_187).w, 0.0f, 1.0f); + r2.w = ((-(r2.wwww)).w + 1.0f); + r9.x = (r2.w * r2.w); + r9.x = (r9.x * r9.x); + r2.w = (r2.w * r9.x); + r2.w = fma(cb12_12.tint_symbol_4[0u].x, r2.w, r7.z); + let v_188 = dot(r3.xyz, r2.xyz); + r3.x = clamp(vec4(v_188, v_188, v_188, v_188).x, 0.0f, 1.0f); + r3.x = log2(r3.x); + r3.x = (r3.x * r8.y); + r3.x = exp2(r3.x); + r2.w = (r2.w * r3.x); + r2.w = (r7.y * r2.w); + r2.w = (r6.w * r2.w); + r2.w = (r7.w * r2.w); + let v_189 = fma(r2.www, cb3_3.tint_symbol_2[22u].xyz, r8.xzw); + r8 = vec4(v_189.x, r8.y, v_189.yz); + } + } + r2.w = (r7.x * r7.x); + r3.x = (r3.w * r3.w); + let v_190 = (r8.xzw * r3.xxx); + r3 = vec4(v_190.xyz, r3.w); + let v_191 = fma(r2.www, r9.yzw, r3.xyz); + r3 = vec4(v_191.xyz, r3.w); + let v_192 = fma(r5.xyz, r5.www, r3.xyz); + r3 = vec4(v_192.xyz, r3.w); + r1.z = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.z = (r1.z * cb3_3.tint_symbol_2[44u].w); + r1.z = max(r1.z, 0.0f); + let v_193 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.zzz, cb3_3.tint_symbol_2[48u].xyz); + r5 = vec4(v_193.xyz, r5.w); + r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_194 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.zzz, cb3_3.tint_symbol_2[46u].xyz); + r7 = vec4(r7.x, v_194.xyz); + let v_195 = (r7.yzw * cb2_2.tint_symbol_1[16u].zzz); + r7 = vec4(r7.x, v_195.xyz); + let v_196 = fma(r5.xyz, r1.www, r7.yzw); + r5 = vec4(v_196.xyz, r5.w); + let v_197 = (r1.yyy * r5.xyz); + r5 = vec4(v_197.xyz, r5.w); + let v_198 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.zzz, cb3_3.tint_symbol_2[44u].xyz); + r7 = vec4(r7.x, v_198.xyz); + r8.x = cb3_3.tint_symbol_2[46u].w; + r8.y = cb3_3.tint_symbol_2[47u].w; + r8.z = cb3_3.tint_symbol_2[48u].w; + let v_199 = dot(r8.xyz, r2.xyz); + r1.z = clamp(vec4(v_199, v_199, v_199, v_199).z, 0.0f, 1.0f); + let v_200 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.zzz, r7.yzw); + r7 = vec4(r7.x, v_200.xyz); + let v_201 = fma(r7.yzw, r1.xxx, r5.xyz); + r5 = vec4(v_201.xyz, r5.w); + let v_202 = (r7.xxx * r5.xyz); + r5 = vec4(v_202.xyz, r5.w); + let v_203 = fma(r5.xyz, r0.xyz, r3.xyz); + r0 = vec4(v_203.xyz, r0.w); + r1.z = ((-(r7.xxxx)).z + 1.0f); + r1.w = dot((-(r4.xyzx)).xyz, r2.xyz); + r1.w = (r1.w + r1.w); + let v_204 = -(r1.wwww); + let v_205 = -(r4.xyzx); + let v_206 = fma(r2.xyz, v_204.xyz, v_205.xyz); + r2 = vec4(v_206.xyz, r2.w); + let v_207 = clamp(((r4.wwww * vec4(0.00066666665952652693f, 0.00177619897294789553f, 0.0f, 0.0f))).xy, vec2(), vec2(1.0f)); + r3 = vec4(v_207.xy, r3.zw); + r1.w = ((-(r3.xxxx)).w + 1.0f); + r2.w = (cb5_5.tint_symbol_3[6u].z + -5.0f); + r3.x = (r1.w * cb5_5.tint_symbol_3[6u].z); + r3.x = bitcast(select(0u, 4294967295u, (r3.x < r2.w))); + r3.z = fma(r1.w, cb5_5.tint_symbol_3[6u].z, -5.0f); + r1.w = (r1.w * r1.w); + r1.w = fma(r1.w, 5.0f, r2.w); + let v_208 = bitcast(r3.x); + let v_209 = r3.z; + r1.w = select(r1.w, v_209, (v_208 != 0u)); + let v_210 = (r2.xyx * vec3(-0.25f, 0.5f, 0.25f)); + r2 = vec4(v_210.xy, r2.z, v_210.z); + r3.x = (abs(r2.zzzz).x + 1.0f); + let v_211 = (r2.xyw / r3.xxx); + r2 = vec4(v_211.xy, r2.z, v_211.z); + let v_212 = ((-(r2.xyxw)).xyw + vec3(0.75f, 0.5f, 0.25f)); + r2 = vec4(v_212.xy, r2.z, v_212.z); + r2.z = bitcast(select(0u, 4294967295u, (0.0f < r2.z))); + let v_213 = bitcast>(r2.zz); + let v_214 = r2.xy; + let v_215 = select(r2.wy, v_214, (v_213 != vec2())); + r2 = vec4(v_215.xy, r2.zw); + let v_216 = r1.w; + r2 = textureSampleLevel(t1, s1, r2.xyxx.xy, v_216); + r1.x = max(r1.y, r1.x); + let v_217 = (r1.xxx * r2.xyz); + r1 = vec4(v_217.xy, r1.z, v_217.z); + let v_218 = (r3.yyy * r1.xyw); + r2 = vec4(v_218.xyz, r2.w); + let v_219 = (r2.xyz * vec3(0.68169009685516357422f)); + r2 = vec4(v_219.xyz, r2.w); + let v_220 = fma(r1.xyw, vec3(0.31830990314483642578f), r2.xyz); + r1 = vec4(v_220.xy, r1.z, v_220.z); + let v_221 = fma(r1.xyw, r1.zzz, r0.xyz); + r0 = vec4(v_221.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r6.xyz, r6.xyz); + r1.x = sqrt(r0.w); + let v_222 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_222.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r6.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_223 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_223 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_224 = (r0.www * r6.xyz); + r2 = vec4(v_224.xyz, r2.w); + let v_225 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_225, v_225, v_225, v_225).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_226 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_226, v_226, v_226, v_226).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_227 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_227.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_228 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_228.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_229 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_229.xyz, r2.w); + let v_230 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_230.xyz, r2.w); + let v_231 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_231.xyz, r3.w); + let v_232 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_232.xyz, r2.w); + let v_233 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_234 = (r2.xyz + v_233.xyz); + r2 = vec4(v_234.xyz, r2.w); + let v_235 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_235.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_236 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_236.xyz, r3.w); + let v_237 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_237.xy, r1.z, v_237.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_238 = (v8.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_238.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_239 = -(r0.xyxz); + let v_240 = fma(r1.xyw, r0.www, v_239.xyw); + r1 = vec4(v_240.xy, r1.z, v_240.z); + let v_241 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_241.xyz, r1.w); + } else { + r0.w = dot(r6.xyz, r6.xyz); + r1.w = sqrt(r0.w); + let v_242 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_242.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r6.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_243 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_243 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_244 = (r0.www * r6.xyz); + r3 = vec4(v_244.xyz, r3.w); + let v_245 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_245, v_245, v_245, v_245).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_246 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_246, v_246, v_246, v_246).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_247 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_247.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_248 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_248.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_249 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_249.xyz, r3.w); + let v_250 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_250.xyz, r3.w); + let v_251 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_251.xyz, r4.w); + let v_252 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_252.xyz, r3.w); + let v_253 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_254 = (r3.xyz + v_253.xyz); + r3 = vec4(v_254.xyz, r3.w); + let v_255 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_255.x, r2.y, v_255.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_256 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_256.xyz, r3.w); + let v_257 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_257.x, r2.y, v_257.yz); + let v_258 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_258.x, r2.y, v_258.yz); + let v_259 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_259.xyz, r1.w); + } + let v_260 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_260.xyz, o0.w); +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @location(7u) v7 : vec4, @builtin(position) v_261 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3, v5, v6, v7, v_261); + return o0; +} diff --git a/b/8b0b5899ed/shaders/00e6b4c4b7cbbb2d.wgsl b/b/8b0b5899ed/shaders/00e6b4c4b7cbbb2d.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..b5042638577ce1396fb90fcaac8abd97bdb94cbf --- /dev/null +++ b/b/8b0b5899ed/shaders/00e6b4c4b7cbbb2d.wgsl @@ -0,0 +1,415 @@ +enable clip_distances; +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb1_struct { + tint_symbol_1 : array, 1u>, +} + +@group(0u) @binding(0u) var cb0_0 : cb1_struct; + +struct cb1_struct_1 { + tint_symbol_2 : array, 1u>, +} + +@group(0u) @binding(7u) var cb7_7 : cb1_struct_1; + +struct cb5_struct { + tint_symbol_3 : array, 5u>, +} + +@group(0u) @binding(12u) var cb12_12 : cb5_struct; + +@group(0u) @binding(18u) var s2 : sampler; + +@group(0u) @binding(34u) var t2 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +var o6 : array; + +var v : vec4; + +var x0 : array, 1u>; + +fn main_inner(v0 : vec3, v1 : vec4, v2 : vec2, v3 : vec3) { + if ((bitcast(cb7_7.tint_symbol_2[0u].x) != 0u)) { + let v_1 = (v0 + cb12_12.tint_symbol_3[1u].xyz); + r0 = vec4(v_1.xyz, r0.w); + r0.w = dot(r0.xyz, r0.xyz); + r0.w = sqrt(r0.w); + let v_2 = (r0.xyz / r0.www); + r0 = vec4(v_2.xyz, r0.w); + r0.z = ((-(r0.zzzz)).z + 1.0f); + r0.z = (r0.z * 0.5f); + r1.x = dot(r0.xy, r0.xy); + r1.x = max(r1.x, 0.00000000999999993923f); + r1.x = sqrt(r1.x); + r1 = (r0.xyxy / r1.xxxx); + r1 = (r0.zzzz * r1); + r1 = fma(r1, vec4(0.5f), vec4(0.5f)); + let v_3 = (r1.zw * vec2(126.73267364501953125f)); + r0 = vec4(v_3.xy, r0.zw); + let v_4 = -(r0.xyxx); + let v_5 = bitcast>(select(vec2(), vec2(4294967295u), (r0.xy >= v_4.xy))); + r2 = vec4(v_5.xy, r2.zw); + let v_6 = fract(abs(r0.xyxx).xy); + r0 = vec4(v_6.xy, r0.zw); + let v_7 = -(r0.xyxx); + let v_8 = bitcast>(r2.xy); + let v_9 = select(v_7.xy, r0.xy, (v_8 != vec2())); + r0 = vec4(v_9.xy, r0.zw); + r2 = textureSampleLevel(t2, s2, r1.zwzz.xy, 0.0f); + r1 = fma(-(r0.xyxy), vec4(0.00789062492549419403f), r1); + r3 = (r1.zwzw + vec4(0.00789062492549419403f, 0.0f, 0.0f, 0.00789062492549419403f)); + r4 = textureSampleLevel(t2, s2, r3.xyxx.xy, 0.0f); + r3 = textureSampleLevel(t2, s2, r3.zwzz.xy, 0.0f); + r5 = (r1.zwzw + vec4(0.00789062492549419403f, 0.00789062492549419403f, -0.5f, -0.5f)); + r6 = textureSampleLevel(t2, s2, r5.xyxx.xy, 0.0f); + let v_10 = ((-(r0.xyxx)).xy + vec2(1.0f)); + r5 = vec4(v_10.xy, r5.zw); + let v_11 = (r2.xyz * r5.xxx); + r7 = vec4(v_11.xyz, r7.w); + let v_12 = (r0.xxx * r4.xyz); + r8 = vec4(v_12.xyz, r8.w); + let v_13 = (r5.yyy * r8.xyz); + r8 = vec4(v_13.xyz, r8.w); + let v_14 = fma(r7.xyz, r5.yyy, r8.xyz); + r7 = vec4(v_14.xyz, r7.w); + let v_15 = (r3.xyz * r5.xxx); + r8 = vec4(v_15.xyz, r8.w); + let v_16 = fma(r8.xyz, r0.yyy, r7.xyz); + r7 = vec4(v_16.xyz, r7.w); + let v_17 = (r0.xxx * r6.xyz); + r6 = vec4(v_17.xyz, r6.w); + let v_18 = fma(r6.xyz, r0.yyy, r7.xyz); + r0 = vec4(v_18.xyz, r0.w); + r0.w = (r0.w / cb12_12.tint_symbol_3[0u].x); + r0.w = min(r0.w, 1.0f); + let v_19 = (r0.www * r0.xyz); + r0 = vec4(v_19.xyz, r0.w); + let v_20 = (r0.xyz * cb12_12.tint_symbol_3[0u].yyy); + r0 = vec4(v_20.xyz, r0.w); + let v_21 = fma(r0.xyz, v1.yyy, v0); + r6 = vec4(v_21.xyz, r6.w); + r0.x = bitcast(select(0u, 4294967295u, (0.0f < cb12_12.tint_symbol_3[2u].w))); + let v_22 = -(cb12_12.tint_symbol_3[1u].xyzx); + let v_23 = (v_22.xyz + cb12_12.tint_symbol_3[2u].xyz); + r7 = vec4(v_23.xyz, r7.w); + let v_24 = -(r7.xxyz); + let v_25 = (r6.xyz + v_24.xzw); + r7 = vec4(v_25.x, r7.y, v_25.yz); + r0.y = dot(r7.xzw, r7.xzw); + r0.y = sqrt(r0.y); + r0.z = (cb12_12.tint_symbol_3[2u].w * 1.10000002384185791016f); + r2.w = clamp(((r0.yyyy / r0.zzzz)).w, 0.0f, 1.0f); + r3.w = bitcast(select(0u, 4294967295u, (r2.w < 1.0f))); + r0.y = (r7.z / r0.y); + r2.w = fma(r2.w, 0.10000000149011611938f, 0.89999997615814208984f); + r0.y = (r0.y * r2.w); + r0.y = fma(r0.y, r0.z, r7.y); + let v_26 = bitcast(r3.w); + let v_27 = r0.y; + r0.y = select(r6.y, v_27, (v_26 != 0u)); + let v_28 = bitcast(r0.x); + let v_29 = r0.y; + r6.w = select(r6.y, v_29, (v_28 != 0u)); + r0.x = bitcast(select(0u, 4294967295u, (0.0f < cb12_12.tint_symbol_3[3u].w))); + let v_30 = (v_22.xyz + cb12_12.tint_symbol_3[3u].xyz); + r7 = vec4(v_30.xyz, r7.w); + let v_31 = -(r7.xxyz); + let v_32 = (r6.xwz + v_31.xzw); + r7 = vec4(v_32.x, r7.y, v_32.yz); + r0.y = dot(r7.xzw, r7.xzw); + r0.y = sqrt(r0.y); + r0.z = (cb12_12.tint_symbol_3[3u].w * 1.10000002384185791016f); + r2.w = clamp(((r0.yyyy / r0.zzzz)).w, 0.0f, 1.0f); + r3.w = bitcast(select(0u, 4294967295u, (r2.w < 1.0f))); + r0.y = (r7.z / r0.y); + r2.w = fma(r2.w, 0.10000000149011611938f, 0.89999997615814208984f); + r0.y = (r0.y * r2.w); + r0.y = fma(r0.y, r0.z, r7.y); + let v_33 = bitcast(r3.w); + let v_34 = r0.y; + r0.y = select(r6.w, v_34, (v_33 != 0u)); + let v_35 = bitcast(r0.x); + let v_36 = r0.y; + r0.x = select(r6.w, v_36, (v_35 != 0u)); + let v_37 = (r5.zw + r5.zw); + let v_38 = r0; + r0 = vec4(v_38.x, v_37.xy, v_38.w); + r2.w = dot(r0.yz, r0.yz); + r3.w = bitcast(select(0u, 4294967295u, (0.0f < r2.w))); + r2.w = sqrt(r2.w); + r2.w = bitcast((bitcast(r2.w) & bitcast(r3.w))); + r3.w = fma((-(r2.wwww)).w, 2.0f, 1.0f); + r5.z = max(r3.w, -1.0f); + r3.w = bitcast(select(0u, 4294967295u, (r5.z < 1.0f))); + r4.w = bitcast(select(0u, 4294967295u, (-1.0f < r5.z))); + r3.w = bitcast((bitcast(r3.w) & bitcast(r4.w))); + r4.w = bitcast(select(0u, 4294967295u, (0.0f < r2.w))); + r3.w = bitcast((bitcast(r3.w) & bitcast(r4.w))); + r4.w = fma((-(r5.zzzz)).w, r5.z, 1.0f); + r4.w = sqrt(r4.w); + r2.w = (r4.w / r2.w); + r2.w = bitcast((bitcast(r2.w) & bitcast(r3.w))); + let v_39 = (r0.yz * r2.ww); + r5 = vec4(v_39.xy, r5.zw); + let v_40 = (r0.www * r2.xyz); + r2 = vec4(v_40.xyz, r2.w); + let v_41 = (r2.xyz * cb12_12.tint_symbol_3[0u].yyy); + r2 = vec4(v_41.xyz, r2.w); + r1 = (r1 + vec4(-0.49210938811302185059f, -0.5f, -0.5f, -0.49210938811302185059f)); + r1 = (r1 + r1); + r0.y = dot(r1.xy, r1.xy); + r0.z = bitcast(select(0u, 4294967295u, (0.0f < r0.y))); + r0.y = sqrt(r0.y); + r0.y = bitcast((bitcast(r0.y) & bitcast(r0.z))); + r0.z = fma((-(r0.yyyy)).z, 2.0f, 1.0f); + r7.z = max(r0.z, -1.0f); + r0.z = bitcast(select(0u, 4294967295u, (r7.z < 1.0f))); + r2.w = bitcast(select(0u, 4294967295u, (-1.0f < r7.z))); + r0.z = bitcast((bitcast(r0.z) & bitcast(r2.w))); + r2.w = bitcast(select(0u, 4294967295u, (0.0f < r0.y))); + r0.z = bitcast((bitcast(r0.z) & bitcast(r2.w))); + r2.w = fma((-(r7.zzzz)).w, r7.z, 1.0f); + r2.w = sqrt(r2.w); + r0.y = (r2.w / r0.y); + r0.y = bitcast((bitcast(r0.y) & bitcast(r0.z))); + let v_42 = (r0.yy * r1.xy); + r7 = vec4(v_42.xy, r7.zw); + let v_43 = (r0.www * r4.xyz); + r4 = vec4(v_43.xyz, r4.w); + let v_44 = ((-(r5.xyzx)).xyz + r7.xyz); + r7 = vec4(v_44.xyz, r7.w); + let v_45 = -(r2.xyzx); + let v_46 = fma(r4.xyz, cb12_12.tint_symbol_3[0u].yyy, v_45.xyz); + r4 = vec4(v_46.xyz, r4.w); + r0.y = dot(r4.xyz, v3); + r0.z = dot(r7.xyz, r7.xyz); + r1.x = bitcast(select(0u, 4294967295u, (0.0f < r0.z))); + r4.x = (r0.y / r0.z); + r4.y = 1.0f; + let v_47 = (r7.xyz * r4.xyx); + r7 = vec4(v_47.xyz, r7.w); + r4.z = v1.y; + let v_48 = (r4.zxz * r7.xyz); + r4 = vec4(v_48.xyz, r4.w); + let v_49 = r7; + r7 = vec4(0.10000000149011611938f, v_49.y, 0.33329999446868896484f, v_49.w); + r7.y = v1.y; + let v_50 = fma(r4.xyz, r7.xyz, v3); + r4 = vec4(v_50.xyz, r4.w); + let v_51 = bitcast>(r1.xxx); + let v_52 = select(v3, r4.xyz, (v_51 != vec3())); + r4 = vec4(v_52.xyz, r4.w); + r0.y = dot(r1.zw, r1.zw); + r0.z = bitcast(select(0u, 4294967295u, (0.0f < r0.y))); + r0.y = sqrt(r0.y); + r0.y = bitcast((bitcast(r0.y) & bitcast(r0.z))); + r0.z = fma((-(r0.yyyy)).z, 2.0f, 1.0f); + r8.z = max(r0.z, -1.0f); + r0.z = bitcast(select(0u, 4294967295u, (r8.z < 1.0f))); + r1.x = bitcast(select(0u, 4294967295u, (-1.0f < r8.z))); + r0.z = bitcast((bitcast(r0.z) & bitcast(r1.x))); + r1.x = bitcast(select(0u, 4294967295u, (0.0f < r0.y))); + r0.z = bitcast((bitcast(r0.z) & bitcast(r1.x))); + r1.x = fma((-(r8.zzzz)).x, r8.z, 1.0f); + r1.x = sqrt(r1.x); + r0.y = (r1.x / r0.y); + r0.y = bitcast((bitcast(r0.y) & bitcast(r0.z))); + let v_53 = (r0.yy * r1.zw); + r8 = vec4(v_53.xy, r8.zw); + let v_54 = (r0.www * r3.xyz); + r0 = vec4(r0.x, v_54.xyz); + let v_55 = ((-(r5.xyzx)).xyz + r8.xyz); + r1 = vec4(v_55.xyz, r1.w); + let v_56 = -(r2.xxyz); + let v_57 = fma(r0.yzw, cb12_12.tint_symbol_3[0u].yyy, v_56.yzw); + r0 = vec4(r0.x, v_57.xyz); + r0.y = dot(r0.yzw, v3); + r0.z = dot(r1.xyz, r1.xyz); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < r0.z))); + r2.x = (r0.y / r0.z); + r2.y = 1.0f; + let v_58 = (r1.xyz * r2.xyx); + r1 = vec4(v_58.xyz, r1.w); + r2.z = v1.y; + let v_59 = (r1.xyz * r2.zxz); + r1 = vec4(v_59.xyz, r1.w); + let v_60 = fma(r1.xyz, r7.xyz, r4.xyz); + r1 = vec4(v_60.xyz, r1.w); + let v_61 = bitcast>(r0.www); + let v_62 = r1.xyz; + let v_63 = select(r4.xyz, v_62, (v_61 != vec3())); + r0 = vec4(r0.x, v_63.xyz); + let v_64 = (r0.yzw + vec3(0.00009999999747378752f)); + r0 = vec4(r0.x, v_64.xyz); + r1.x = dot(r0.yzw, r0.yzw); + r1.x = inverseSqrt(r1.x); + let v_65 = (r0.yzw * r1.xxx); + r0 = vec4(r0.x, v_65.xyz); + } else { + r0.x = v0.y; + let v_66 = v0.xz; + let v_67 = r6; + r6 = vec4(v_66.x, v_67.y, v_66.y, v_67.w); + r0 = vec4(r0.x, v3.xyz); + } + let v_68 = (r0.xxx * cb1_1.tint_symbol[1u].xyz); + r1 = vec4(v_68.xyz, r1.w); + let v_69 = fma(r6.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz); + r1 = vec4(v_69.xyz, r1.w); + let v_70 = fma(r6.zzz, cb1_1.tint_symbol[2u].xyz, r1.xyz); + r1 = vec4(v_70.xyz, r1.w); + let v_71 = (r1.xyz + cb1_1.tint_symbol[3u].xyz); + r1 = vec4(v_71.xyz, r1.w); + o3 = (((-(r1.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz)).xyzx; + let v_72 = (r0.zzz * cb1_1.tint_symbol[1u].xyz); + r2 = vec4(v_72.xyz, r2.w); + let v_73 = fma(r0.yyy, cb1_1.tint_symbol[0u].xyz, r2.xyz); + r2 = vec4(v_73.xyz, r2.w); + o1 = fma(r0.www, cb1_1.tint_symbol[2u].xyz, r2.xyz).xyzx; + if ((bitcast(cb12_12.tint_symbol_3[4u].x) != 0u)) { + let v_74 = (v0 + cb12_12.tint_symbol_3[1u].xyz); + r0 = vec4(r0.x, v_74.xyz); + r1.w = dot(r0.yzw, r0.yzw); + r1.w = sqrt(r1.w); + let v_75 = (r0.yzw / r1.www); + r0 = vec4(r0.x, v_75.xyz); + r0.w = ((-(r0.wwww)).w + 1.0f); + r0.w = (r0.w * 0.5f); + r2.x = dot(r0.yz, r0.yz); + r2.x = max(r2.x, 0.00000000999999993923f); + r2.x = sqrt(r2.x); + let v_76 = (r0.yz / r2.xx); + let v_77 = r0; + r0 = vec4(v_77.x, v_76.xy, v_77.w); + let v_78 = (r0.ww * r0.yz); + let v_79 = r0; + r0 = vec4(v_79.x, v_78.xy, v_79.w); + let v_80 = fma(r0.yz, vec2(0.5f), vec2(0.5f)); + let v_81 = r0; + r0 = vec4(v_81.x, v_80.xy, v_81.w); + let v_82 = (r0.yz * vec2(126.73267364501953125f)); + r2 = vec4(v_82.xy, r2.zw); + let v_83 = -(r2.xxxy); + let v_84 = bitcast>(select(vec2(), vec2(4294967295u), (r2.xy >= v_83.zw))); + r2 = vec4(r2.xy, v_84.xy); + let v_85 = fract(abs(r2.xyxx).xy); + r2 = vec4(v_85.xy, r2.zw); + let v_86 = -(r2.xyxx); + let v_87 = bitcast>(r2.zw); + let v_88 = select(v_86.xy, r2.xy, (v_87 != vec2())); + r2 = vec4(v_88.xy, r2.zw); + r3 = textureSampleLevel(t2, s2, r0.yzyy.xy, 0.0f); + let v_89 = fma((-(r2.xxyx)).yz, vec2(0.00789062492549419403f), r0.yz); + let v_90 = r0; + r0 = vec4(v_90.x, v_89.xy, v_90.w); + r4 = (r0.yzyz + vec4(0.00789062492549419403f, 0.0f, 0.0f, 0.00789062492549419403f)); + r5 = textureSampleLevel(t2, s2, r4.xyxx.xy, 0.0f); + r4 = textureSampleLevel(t2, s2, r4.zwzz.xy, 0.0f); + let v_91 = (r0.yz + vec2(0.00789062492549419403f)); + let v_92 = r0; + r0 = vec4(v_92.x, v_91.xy, v_92.w); + r7 = textureSampleLevel(t2, s2, r0.yzyy.xy, 0.0f); + let v_93 = ((-(r2.xxyx)).yz + vec2(1.0f)); + let v_94 = r0; + r0 = vec4(v_94.x, v_93.xy, v_94.w); + r3 = (r0.yyyy * r3); + r5 = (r2.xxxx * r5); + r5 = (r0.zzzz * r5); + r3 = fma(r3, r0.zzzz, r5); + r4 = (r0.yyyy * r4); + r3 = fma(r4, r2.yyyy, r3); + r4 = (r2.xxxx * r7); + r2 = fma(r4, r2.yyyy, r3); + r0.y = (r1.w / cb12_12.tint_symbol_3[0u].x); + r0.y = min(r0.y, 1.0f); + r2 = (r0.yyyy * r2); + r2 = fma(r2, vec4(0.5f), vec4(0.5f)); + } else { + r2 = v1; + } + r3.x = v1.y; + r3.w = 1.0f; + let v_95 = bitcast>(cb12_12.tint_symbol_3[4u].yyyy); + let v_96 = r3.xxxw; + o4 = select(r2, v_96, (v_95 != vec4())); + r0 = (r0.xxxx * cb1_1.tint_symbol[9u]); + r0 = fma(r6.xxxx, cb1_1.tint_symbol[8u], r0); + r0 = fma(r6.zzzz, cb1_1.tint_symbol[10u], r0); + r0 = (r0 + cb1_1.tint_symbol[11u]); + x0[0u].x = dot(r0, cb0_0.tint_symbol_1[0u]); + let v_97 = r1; + o2 = vec4(v_97.xyz, o2.w); + o2.w = 1.0f; + o5 = r0; + let v_98 = &(x0[0u]); + *(v_98) = vec4((*(v_98)).x, vec3()); + o0 = vec3(v2.xy, o0.xyz.z).xyzx; + o0.z = r0.w; + o6[0u] = x0[0u].x; + o6[1u] = x0[0u].y; + o6[2u] = x0[0u].z; + o6[3u] = x0[0u].w; + v = vec4(o6[0u], o6[1u], o6[2u], o6[3u]); +} + +struct tint_symbol_5 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @builtin(position) + o5 : vec4, + @builtin(clip_distances) + o6 : array, + @location(15u) + tint_symbol_4 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(2u) v2 : vec2, @location(3u) v3 : vec3) -> tint_symbol_5 { + main_inner(v0, v1, v2, v3); + return tint_symbol_5(o0, o1, o2, o3, o4, o5, o6, v); +} diff --git a/b/8b0b5899ed/shaders/00edbec406bcb4a0.wgsl b/b/8b0b5899ed/shaders/00edbec406bcb4a0.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..ba5985ba15c4ccc31618a53791c8e0a8ed808af8 --- /dev/null +++ b/b/8b0b5899ed/shaders/00edbec406bcb4a0.wgsl @@ -0,0 +1,306 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +struct cb15_struct { + tint_symbol : array, 15u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb15_struct; + +struct cb17_struct { + tint_symbol_1 : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb50_struct { + tint_symbol_2 : array, 50u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb50_struct; + +struct cb4_struct { + tint_symbol_3 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb18_struct { + tint_symbol_4 : array, 18u>, +} + +@group(1u) @binding(13u) var cb13_13 : cb18_struct; + +struct cb4_struct_1 { + tint_symbol_5 : array, 4u>, +} + +@group(1u) @binding(10u) var cb10_10 : cb4_struct_1; + +struct cb1_struct { + tint_symbol_6 : array, 1u>, +} + +@group(1u) @binding(8u) var cb8_8 : cb1_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(21u) var s5 : sampler; + +@group(1u) @binding(22u) var s6 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(36u) var t4 : texture_2d; + +@group(1u) @binding(37u) var t5 : texture_2d; + +@group(1u) @binding(38u) var t6 : texture_2d; + +var v0 : vec4; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v7 : vec4) { + var v_1 : vec4 = v; + v_1.w = (1.0f / v.w); + v0 = v_1; + r0 = textureSample(t0, s0, v1.xyxx.xy); + r1.x = bitcast(select(0u, 4294967295u, !((0.0f == v1.w)))); + if ((bitcast(r1.x) != 0u)) { + r1 = textureSample(t6, s6, v1.xyxx.xy); + let v_2 = -(r0.xyzx); + let v_3 = fma(r1.xyz, cb13_13.tint_symbol_4[9u].xyz, v_2.xyz); + r1 = vec4(v_3.xyz, r1.w); + let v_4 = fma(v1.www, r1.xyz, r0.xyz); + r0 = vec4(v_4.xyz, r0.w); + } + let v_5 = (v1.xy * cb10_10.tint_symbol_5[2u].xy); + r1 = vec4(v_5.xy, r1.zw); + let v_6 = (r1.xy * vec2(0.5f)); + r1 = vec4(v_6.xy, r1.zw); + r1 = textureSample(t3, s3, r1.xyxx.xy); + r1.y = clamp(fma(r1.wwww, vec4(2.0f), cb8_8.tint_symbol_6[0u].xxxx).y, 0.0f, 1.0f); + r0.w = (r0.w * r1.y); + r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + r1.y = dot(v0.xy, vec2(0.5f)); + r1.y = fract(r1.y); + r1.y = bitcast(select(0u, 4294967295u, (r1.y < 0.5f))); + let v_7 = bitcast>(select(vec2(), vec2(4294967295u), (vec2(0.94999998807907104492f, 0.50196081399917602539f) >= r0.ww))); + r1 = vec4(r1.xy, v_7.xy); + r1.y = bitcast((bitcast(r1.z) & bitcast(r1.y))); + r1.y = bitcast((bitcast(r1.w) | bitcast(r1.y))); + v_8((bitcast(r1.y) != 0u)); + r2 = textureSample(t4, s4, v1.xyxx.xy); + let v_9 = fma(r2.xy, vec2(2.0f), vec2(-1.0f)); + let v_10 = r1; + r1 = vec4(v_10.x, v_9.xy, v_10.w); + r1.w = dot(r1.yz, r1.yz); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.w = sqrt(abs(r1.wwww).w); + r2.x = max(cb10_10.tint_symbol_5[3u].x, 0.00100000004749745131f); + let v_11 = (r1.yz * r2.xx); + let v_12 = r1; + r1 = vec4(v_12.x, v_11.xy, v_12.w); + let v_13 = (r1.zzz * v6.xyz); + r2 = vec4(v_13.xyz, r2.w); + let v_14 = fma(r1.yyy, v5.xyz, r2.xyz); + r2 = vec4(v_14.xyz, r2.w); + let v_15 = fma(r1.www, v2.xyz, r2.xyz); + r1 = vec4(r1.x, v_15.xyz); + r2.x = dot(r1.yzw, r1.yzw); + r2.x = inverseSqrt(r2.x); + let v_16 = (r1.yzw * r2.xxx); + r2 = vec4(r2.x, v_16.xyz); + r3 = textureSample(t5, s5, v1.xyxx.xy); + let v_17 = (r3.yx * r3.yx); + let v_18 = r1; + r1 = vec4(v_18.x, v_17.xy, v_18.w); + r3.x = bitcast(select(0u, 4294967295u, (r3.z >= 0.8125f))); + o1.w = clamp(fma(v2.xyz.zzzz, vec4(128.0f), vec4(-127.0f)).w, 0.0f, 1.0f); + let v_19 = (v3.xx * cb2_2.tint_symbol_1[15u].zy); + let v_20 = r3; + r3 = vec4(v_20.x, v_19.x, v_20.z, v_19.y); + r4.x = fma(r2.w, 0.5f, 0.5f); + r4.y = fma(r4.x, cb5_5.tint_symbol_3[3u].y, cb5_5.tint_symbol_3[3u].x); + r4.x = (r4.x + 0.30000001192092895508f); + r3.w = (r3.w * r4.x); + let v_21 = (v1.zz + vec2(0.0f, -0.75f)); + let v_22 = r4; + r4 = vec4(v_21.x, v_22.y, v_21.y, v_22.w); + let v_23 = clamp(((r4.xxzx * vec4(4.0f, 0.0f, 4.0f, 0.0f))).xz, vec2(), vec2(1.0f)); + let v_24 = r4; + r4 = vec4(v_23.x, v_24.y, v_23.y, v_24.w); + r4.w = bitcast(select(0u, 4294967295u, (bitcast(r3.x) == 0i))); + let v_25 = (r0.xyz * cb13_13.tint_symbol_4[17u].xxx); + r5 = vec4(v_25.xyz, r5.w); + let v_26 = (r4.xxx * r5.xyz); + r5 = vec4(v_26.xyz, r5.w); + let v_27 = bitcast>((bitcast>(r4.www) & bitcast>(r5.xyz))); + r5 = vec4(v_27.xyz, r5.w); + let v_28 = -(r5.xyzx); + let v_29 = (r0.xyz + v_28.xyz); + r0 = vec4(v_29.xyz, r0.w); + let v_30 = (r4.zz * cb13_13.tint_symbol_4[17u].yz); + let v_31 = r4; + r4 = vec4(v_30.x, v_31.y, v_30.y, v_31.w); + let v_32 = fma(r1.yz, cb10_10.tint_symbol_5[3u].zw, r4.xz); + let v_33 = r1; + r1 = vec4(v_33.x, v_32.xy, v_33.w); + let v_34 = (r0.xyz * cb13_13.tint_symbol_4[4u].xxx); + r0 = vec4(v_34.xyz, r0.w); + r4.x = bitcast((bitcast(r3.x) & 1008981770u)); + r3.x = select(0.0f, -0.00999999977648258209f, (bitcast(r3.x) != 0u)); + r1.z = (r1.z + r3.x); + r1.z = fma(cb13_13.tint_symbol_4[4u].z, r1.z, r4.x); + r3.x = dot(v4.xyz, v4.xyz); + r3.x = inverseSqrt(r3.x); + let v_35 = (r3.xxx * v4.xyz); + r4 = vec4(v_35.x, r4.y, v_35.yz); + let v_36 = dot(r4.xzw, r2.yzw); + r3.x = clamp(vec4(v_36, v_36, v_36, v_36).x, 0.0f, 1.0f); + r3.x = ((-(r3.xxxx)).x + 1.0f); + r3.x = fma(r3.x, 0.40000000596046447754f, 0.5f); + r1.w = fma(r1.w, r2.x, 1.0f); + r1.w = clamp(fma(r1.wwww, vec4(0.5f), vec4(-0.30000001192092895508f)).w, 0.0f, 1.0f); + r1.w = (r1.w * 1.42857146263122558594f); + r2.x = clamp(v7.x, 0.0f, 1.0f); + r2.x = (r2.x * r3.x); + r1.w = (r1.w * r2.x); + let v_37 = (r0.xyz * r1.www); + r5 = vec4(v_37.xyz, r5.w); + let v_38 = fma(r5.xyz, cb13_13.tint_symbol_4[4u].yyy, r0.xyz); + r0 = vec4(v_38.xyz, r0.w); + r1.w = dot(v6.xyz, v6.xyz); + r1.w = inverseSqrt(r1.w); + let v_39 = (r1.www * v6.xyz); + r5 = vec4(v_39.xyz, r5.w); + let v_40 = (v1.xy * cb10_10.tint_symbol_5[2u].zw); + r6 = vec4(v_40.xy, r6.zw); + let v_41 = (r6.xy * vec2(0.5f)); + r6 = vec4(v_41.xy, r6.zw); + r6 = textureSample(t3, s3, r6.xyxx.xy); + let v_42 = fma(r6.xy, vec2(2.0f), vec2(-1.0f)); + r6 = vec4(v_42.xy, r6.zw); + let v_43 = (r6.xy * vec2(0.10000000149011611938f)); + r6 = vec4(v_43.xy, r6.zw); + let v_44 = fma(v2.xyz, r6.xxx, r5.xyz); + r6 = vec4(v_44.x, r6.y, v_44.yz); + r1.w = dot(r6.xzw, r6.xzw); + r1.w = inverseSqrt(r1.w); + let v_45 = (r1.www * r6.xzw); + r6 = vec4(v_45.x, r6.y, v_45.yz); + r1.w = dot(r4.xzw, r6.xzw); + r2.x = dot(cb1_1.tint_symbol[14u].xyz, r6.xzw); + let v_46 = fma(v2.xyz, r6.yyy, r5.xyz); + r5 = vec4(v_46.xyz, r5.w); + r3.x = dot(r5.xyz, r5.xyz); + r3.x = inverseSqrt(r3.x); + let v_47 = (r3.xxx * r5.xyz); + r5 = vec4(v_47.xyz, r5.w); + r3.x = dot(r4.xzw, r5.xyz); + r4.x = dot(cb1_1.tint_symbol[14u].xyz, r5.xyz); + r4.z = fma((-(r1.wwww)).z, r1.w, 1.0f); + r4.w = fma((-(r2.xxxx)).w, r2.x, 1.0f); + let v_48 = sqrt(r4.zw); + r4 = vec4(r4.xy, v_48.xy); + r1.w = (r1.w * r2.x); + let v_49 = -(r1.wwww); + r1.w = fma(r4.z, r4.w, v_49.w); + r2.x = fma((-(r3.xxxx)).x, r3.x, 1.0f); + r2.x = sqrt(r2.x); + r4.z = fma((-(r4.xxxx)).z, r4.x, 1.0f); + r4.z = sqrt(r4.z); + r3.x = (r3.x * r4.x); + let v_50 = -(r3.xxxx); + r2.x = fma(r2.x, r4.z, v_50.x); + let v_51 = (cb10_10.tint_symbol_5[0u].zw + vec2(8.0f, 16.0f)); + let v_52 = r4; + r4 = vec4(v_51.x, v_52.y, v_51.y, v_52.w); + r1.w = log2(abs(r1.wwww).w); + r1.w = (r1.w * r4.x); + r1.w = exp2(r1.w); + r2.x = log2(abs(r2.xxxx).x); + r2.x = (r2.x * r4.z); + r2.x = exp2(r2.x); + r3.x = (r2.x * cb10_10.tint_symbol_5[0u].y); + r1.w = fma(r1.w, cb10_10.tint_symbol_5[0u].x, r3.x); + r3.x = bitcast(select(0u, 4294967295u, (r3.z < 0.03125f))); + r3.z = bitcast((bitcast(r3.x) & 1065353216u)); + r1.x = (r1.x * r1.w); + let v_53 = bitcast(r3.x); + r1.x = select(1.0f, r1.x, (v_53 != 0u)); + r1.x = (r1.x * r1.z); + let v_54 = (r2.xxx * cb10_10.tint_symbol_5[1u].xyz); + r4 = vec4(v_54.x, r4.y, v_54.yz); + let v_55 = (r3.zzz * r4.xzw); + r4 = vec4(v_55.x, r4.y, v_55.yz); + let v_56 = fma(r4.xzw, vec3(0.5f), r0.xyz); + o0 = vec4(v_56.xyz, o0.w); + r0.x = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).x, 0.0f, 1.0f); + r0.y = (r0.x * r3.w); + let v_57 = fma(r2.yzw, vec3(0.5f), vec3(0.5f)); + o1 = vec4(v_57.xyz, o1.w); + r0.z = (r1.y * 0.001953125f); + r0.x = fma(r4.y, r3.y, cb3_3.tint_symbol_2[45u].w); + let v_58 = (r0.xy * vec2(0.5f)); + r0 = vec4(v_58.xy, r0.zw); + let v_59 = sqrt(r0.xy); + o3 = vec4(v_59.xy, o3.zw); + o2.x = sqrt(r1.x); + o2.y = sqrt(r0.z); + r0.x = fma(r0.w, 1.33000004291534423828f, -0.50196081399917602539f); + o0.w = clamp(fma(r0.xxxx, vec4(2.23194742202758789062f), vec4(0.0078431377187371254f)).w, 0.0f, 1.0f); + o2.z = cb10_10.tint_symbol_5[3u].y; + o2.w = 1.0f; + o3 = vec4(o3.xy, vec2(0.0f, 1.00188386440277099609f)); +} + +fn v_8(v_60 : bool) { + if (v_60) { + discard; + return; + } +} + +struct tint_symbol_7 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@builtin(position) v_61 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @location(7u) v7 : vec4) -> tint_symbol_7 { + main_inner(v_61, v1, v2, v3, v4, v5, v6, v7); + return tint_symbol_7(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/010379dc47445f90.consts.json b/b/8b0b5899ed/shaders/010379dc47445f90.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..9c27df027d15db715744502f6c2271644a23c98e --- /dev/null +++ b/b/8b0b5899ed/shaders/010379dc47445f90.consts.json @@ -0,0 +1 @@ +[2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/010379dc47445f90.wgsl b/b/8b0b5899ed/shaders/010379dc47445f90.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..991c9d754234f0f9c3406d319b6ef2901333c682 --- /dev/null +++ b/b/8b0b5899ed/shaders/010379dc47445f90.wgsl @@ -0,0 +1,276 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb17_struct { + tint_symbol_1 : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb60_struct { + tint_symbol_2 : array, 60u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb60_struct; + +struct cb4_struct { + tint_symbol_3 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb11_struct { + tint_symbol_4 : array, 11u>, +} + +@group(1u) @binding(11u) var cb11_11 : cb11_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v5 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 3u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4) { + x1[0u].x = v5[0u]; + x1[0u].y = v5[1u]; + x1[0u].z = v5[2u]; + x1[0u].w = v5[3u]; + let v_1 = (v2.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r0 = vec4(v_1.xyz, r0.w); + let v_2 = (r0.yyy * cb6_6.tint_symbol_5[1u].xyz); + r1 = vec4(v_2.xyz, r1.w); + let v_3 = fma(r0.xxx, cb6_6.tint_symbol_5[0u].xyz, r1.xyz); + r0 = vec4(v_3.xy, r0.z, v_3.z); + let v_4 = fma(r0.zzz, cb6_6.tint_symbol_5[2u].xyz, r0.xyw); + r0 = vec4(v_4.xyz, r0.w); + let v_5 = fma(r0.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r1 = vec4(v_5.xyz, r1.w); + let v_6 = &(x0[0u]); + let v_7 = r1; + *(v_6) = vec4(v_7.xyz, (*(v_6)).w); + let v_8 = abs(r1.yyyy); + r0.w = max(v_8.w, abs(r1.xxxx).w); + let v_9 = fma(r0.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r1 = vec4(v_9.xyz, r1.w); + let v_10 = &(x0[1u]); + let v_11 = r1; + *(v_10) = vec4(v_11.xyz, (*(v_10)).w); + let v_12 = abs(r1.yyyy); + r1.x = max(v_12.x, abs(r1.xxxx).x); + let v_13 = fma(r0.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r1 = vec4(r1.x, v_13.xyz); + let v_14 = fma(r0.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r0 = vec4(v_14.xyz, r0.w); + let v_15 = &(x0[2u]); + let v_16 = r1; + *(v_15) = vec4(v_16.yzw, (*(v_15)).w); + let v_17 = abs(r1.zzzz); + r1.y = max(v_17.y, abs(r1.yyyy).y); + let v_18 = &(x0[3u]); + let v_19 = r0; + *(v_18) = vec4(v_19.xyz, (*(v_18)).w); + let v_20 = abs(r0.yyyy); + r0.x = max(v_20.x, abs(r0.xxxx).x); + r0.x = clamp(fma(r0.xxxx, vec4(15.0f), vec4(-6.30000019073486328125f)).x, 0.0f, 1.0f); + r0.y = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).y, 1.5f, 1.0f); + r0.y = (r0.y * 0.5f); + r0.z = bitcast(select(0u, 4294967295u, (r1.y < r0.y))); + let v_21 = (bitcast(r0.z) != 0u); + let v_22 = bitcast(v.tint_symbol_6[0i].x); + r0.z = select(bitcast(v.tint_symbol_6[1i].x), v_22, v_21); + r1.x = bitcast(select(0u, 4294967295u, (r1.x < r0.y))); + r0.y = bitcast(select(0u, 4294967295u, (r0.w < r0.y))); + let v_23 = bitcast(r1.x); + r0.z = select(r0.z, bitcast(v.tint_symbol_6[2i].x), (v_23 != 0u)); + let v_24 = bitcast(r0.y); + r0.y = select(r0.z, 0.0f, (v_24 != 0u)); + r0.z = f32(bitcast(r0.y)); + let v_25 = x0[bitcast(r0.y)]; + r1 = vec4(v_25.xyz, r1.w); + r0.y = (r0.z + 0.5f); + r2 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r0.zzzz))); + r2 = bitcast>((bitcast>(r2) & vec4(1065353216u))); + r0.y = (r0.y * 0.25f); + r3.y = fma(r1.y, 0.25f, r0.y); + r3.x = (r1.x + 0.5f); + let v_26 = dpdx(r3.xyy); + r4 = vec4(v_26.xy, r4.z, v_26.z); + r0.y = dot(r2, cb6_6.tint_symbol_5[12u]); + r0.z = dot(r2, cb6_6.tint_symbol_5[13u]); + r0.w = ((-(r0.yyyy)).w + r1.z); + r0.y = bitcast(select(0u, 4294967295u, !((r0.y == 0.0f)))); + r4.z = dpdx(r0.w); + let v_27 = dpdy(r3.yxy); + r2 = vec4(v_27.xyz, r2.w); + r2.w = dpdy(r0.w); + let v_28 = (r2.yw * r4.yw); + r1 = vec4(v_28.xy, r1.zw); + let v_29 = -(r1.xyxx); + let v_30 = fma(r4.xz, r2.xz, v_29.xy); + r5 = vec4(v_30.xy, r5.zw); + r1.x = (r2.y * r4.z); + let v_31 = -(r1.xxxx); + r5.z = fma(r4.x, r2.w, v_31.z); + r1.x = (1.0f / r5.x); + let v_32 = (r1.xx * r5.yz); + r1 = vec4(v_32.xy, r1.zw); + let v_33 = max(r1.xy, vec2()); + r1 = vec4(v_33.xy, r1.zw); + let v_34 = min(r1.xy, vec2(0.5f)); + r1 = vec4(v_34.xy, r1.zw); + r0.w = fma((-(r0.zzzz)).w, r1.x, r0.w); + r0.z = fma((-(r0.zzzz)).z, r1.y, r0.w); + let v_35 = bitcast(r0.y); + let v_36 = r0.z; + r0.y = select(r1.z, v_36, (v_35 != 0u)); + let v_37 = r3.xyxx; + r0.y = textureSampleCompareLevel(t15, s15, v_37.xy, r0.y); + let v_38 = ((-(v2.xyz.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r1 = vec4(v_38.xyz, r1.w); + r0.z = dot(r1.xyz, cb1_1.tint_symbol[14u].xyz); + r0.z = clamp(fma(r0.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f); + r0.z = ((-(r0.zzzz)).z + 1.0f); + r0.x = fma(r0.z, r0.x, r0.y); + r0.x = (r0.x * r0.x); + r0.x = min(r0.x, 1.0f); + r0.y = clamp(fma(v2.xyz.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).y, 0.0f, 1.0f); + r0.y = sqrt(r0.y); + r0.y = (r0.y * cb6_6.tint_symbol_5[3u].z); + let v_39 = -(r0.xxxx); + r0.x = fma(r0.y, v_39.x, r0.x); + r0.y = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).y, 0.0f, 1.0f); + r0.y = (r0.y * cb2_2.tint_symbol_1[15u].y); + r0.y = (r0.y * r0.y); + r0.z = ((-(cb2_2.tint_symbol_1[16u].zzzz)).z + 1.0f); + r0.w = dot(v1.xyz, v1.xyz); + r0.w = inverseSqrt(r0.w); + r1.x = fma(v1.z, r0.w, cb3_3.tint_symbol_2[43u].w); + let v_40 = (r0.www * v1.xyz); + r1 = vec4(r1.x, v_40.xyz); + r0.w = (r1.x * cb3_3.tint_symbol_2[44u].w); + r0.w = max(r0.w, 0.0f); + let v_41 = fma(cb3_3.tint_symbol_2[45u].xyz, r0.www, cb3_3.tint_symbol_2[46u].xyz); + r2 = vec4(v_41.xyz, r2.w); + let v_42 = (r2.xyz * cb2_2.tint_symbol_1[16u].zzz); + r2 = vec4(v_42.xyz, r2.w); + let v_43 = fma(cb3_3.tint_symbol_2[47u].xyz, r0.www, cb3_3.tint_symbol_2[48u].xyz); + r3 = vec4(v_43.xyz, r3.w); + let v_44 = fma(cb3_3.tint_symbol_2[43u].xyz, r0.www, cb3_3.tint_symbol_2[44u].xyz); + r4 = vec4(v_44.xyz, r4.w); + let v_45 = fma(r3.xyz, r0.zzz, r2.xyz); + r2 = vec4(v_45.xyz, r2.w); + let v_46 = (r0.yyy * r2.xyz); + r0 = vec4(r0.x, v_46.xyz); + r2.x = cb3_3.tint_symbol_2[46u].w; + r2.y = cb3_3.tint_symbol_2[47u].w; + r2.z = cb3_3.tint_symbol_2[48u].w; + let v_47 = dot(r2.xyz, r1.yzw); + r1.x = clamp(vec4(v_47, v_47, v_47, v_47).x, 0.0f, 1.0f); + let v_48 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_49 = dot(r1.yzw, v_48.xyz); + r1.y = clamp(vec4(v_49, v_49, v_49, v_49).y, 0.0f, 1.0f); + let v_50 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r4.xyz); + r1 = vec4(v_50.x, r1.y, v_50.yz); + r2.x = (cb2_2.tint_symbol_1[15u].z * cb2_2.tint_symbol_1[15u].z); + let v_51 = fma(r1.xzw, r2.xxx, r0.yzw); + r0 = vec4(r0.x, v_51.xyz); + r1.x = (cb5_5.tint_symbol_3[3u].z * cb11_11.tint_symbol_4[9u].z); + let v_52 = ((-(cb11_11.tint_symbol_4[9u].zzzz)).zw + vec2(1.0f, 2.0f)); + r1 = vec4(r1.xy, v_52.xy); + let v_53 = (r1.ww * v0.zw); + r2 = vec4(v_53.xy, r2.zw); + r2 = textureSample(t3, s3, r2.xyxx.xy); + r1.w = ((-(r2.xxxx)).w + r2.z); + r1.x = fma(r1.x, r1.w, r2.x); + r1.w = fma(v3.z, r1.z, -1.0f); + r1.w = fma(r1.z, r1.w, 1.0f); + r1.z = (r1.z * v3.z); + let v_54 = (r1.xz * cb11_11.tint_symbol_4[9u].xx); + let v_55 = r1; + r1 = vec4(v_54.x, v_55.y, v_54.y, v_55.w); + r1.x = (r1.w * r1.x); + r1.w = fma((-(cb2_2.tint_symbol_1[16u].yyyy)).w, 100.0f, 1.0f); + r1.x = clamp(((r1.wwww * r1.xxxx)).x, 0.0f, 1.0f); + r1.w = clamp(((v3.wwww + vec4(-2.0f))).w, 0.0f, 1.0f); + r1.w = fma((-(r1.wwww)).w, 0.75f, 1.0f); + r1.x = (r1.w * r1.x); + r3 = textureSample(t0, s0, v0.xyxx.xy); + let v_56 = (r3.xyz * cb11_11.tint_symbol_4[0u].xyz); + r2 = vec4(v_56.xy, r2.z, v_56.z); + r1.w = (r3.w * v3.w); + o0.w = (r1.w * cb2_2.tint_symbol_1[15u].x); + let v_57 = (r2.xyw * r2.xyw); + r2 = vec4(v_57.xy, r2.z, v_57.z); + let v_58 = -(r2.xywx); + let v_59 = fma(cb11_11.tint_symbol_4[10u].xyz, cb11_11.tint_symbol_4[9u].yyy, v_58.xyz); + r3 = vec4(v_59.xyz, r3.w); + let v_60 = fma(r1.xxx, r3.xyz, r2.xyw); + r2 = vec4(v_60.xy, r2.z, v_60.z); + let v_61 = ((-(r2.xywx)).xyz + r2.zzz); + r3 = vec4(v_61.xyz, r3.w); + let v_62 = fma(r1.zzz, r3.xyz, r2.xyw); + r1 = vec4(v_62.x, r1.y, v_62.yz); + let v_63 = (r0.yzw * r1.xzw); + r0 = vec4(r0.x, v_63.xyz); + let v_64 = (r1.yyy * r1.xzw); + r2 = vec4(v_64.xyz, r2.w); + let v_65 = (r2.xyz * cb3_3.tint_symbol_2[1u].xyz); + r2 = vec4(v_65.xyz, r2.w); + let v_66 = fma(r2.xyz, r0.xxx, r0.yzw); + r0 = vec4(v_66.xyz, r0.w); + r0.w = (v3.x * cb11_11.tint_symbol_4[2u].x); + r0.w = (r0.w * cb11_11.tint_symbol_4[9u].z); + r0.w = (r0.w * cb3_3.tint_symbol_2[59u].w); + let v_67 = fma(r1.xzw, r0.www, r0.xyz); + o0 = vec4(v_67.xyz, o0.w); +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3); + return o0; +} diff --git a/b/8b0b5899ed/shaders/0105421a564158db.wgsl b/b/8b0b5899ed/shaders/0105421a564158db.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..7c967fa9457bd5e3459b4617d38d4751257fc63a --- /dev/null +++ b/b/8b0b5899ed/shaders/0105421a564158db.wgsl @@ -0,0 +1,147 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb76_struct { + tint_symbol : array, 76u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb76_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +var o0 : f32; + +fn main_inner(v1 : vec4) { + let v = fma((-(cb5_5.tint_symbol[75u].zwzz)).xy, vec2(0.5f), v1.xy); + r0 = vec4(v.xy, r0.zw); + let v_1 = fma(cb5_5.tint_symbol[75u].xy, vec2(0.5f), r0.xy); + r0 = vec4(r0.xy, v_1.xy); + r1 = textureSample(t0, s0, r0.zwzz.xy); + r0.z = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r0.w = bitcast((bitcast(r0.z) & 2147483647u)); + r0.w = bitcast(select(0u, 4294967295u, (bitcast(r0.w) == 2139095040i))); + r1.x = bitcast(select(0u, 4294967295u, !((r0.z == r0.z)))); + r0.w = bitcast((bitcast(r0.w) | bitcast(r1.x))); + let v_2 = bitcast(r0.w); + r0.z = select(r0.z, 0.0f, (v_2 != 0u)); + r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4(1.5f, 0.5f, 2.5f, 0.5f), r0.xyxy); + r2 = textureSample(t0, s0, r1.xyxx.xy); + r1 = textureSample(t0, s0, r1.zwzz.xy); + r0.w = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.x = dot(r2.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.y = bitcast((bitcast(r1.x) & 2147483647u)); + r1.y = bitcast(select(0u, 4294967295u, (bitcast(r1.y) == 2139095040i))); + r1.z = bitcast(select(0u, 4294967295u, !((r1.x == r1.x)))); + r1.y = bitcast((bitcast(r1.y) | bitcast(r1.z))); + let v_3 = bitcast(r1.y); + r1.x = select(r1.x, 0.0f, (v_3 != 0u)); + r0.z = (r0.z + r1.x); + r1.x = bitcast((bitcast(r0.w) & 2147483647u)); + r1.x = bitcast(select(0u, 4294967295u, (bitcast(r1.x) == 2139095040i))); + r1.y = bitcast(select(0u, 4294967295u, !((r0.w == r0.w)))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r1.y))); + let v_4 = bitcast(r1.x); + r0.w = select(r0.w, 0.0f, (v_4 != 0u)); + r0.z = (r0.w + r0.z); + r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4(3.5f, 0.5f, 0.5f, 1.5f), r0.xyxy); + r2 = textureSample(t0, s0, r1.xyxx.xy); + r1 = textureSample(t0, s0, r1.zwzz.xy); + r0.w = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.x = dot(r2.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.y = bitcast((bitcast(r1.x) & 2147483647u)); + r1.y = bitcast(select(0u, 4294967295u, (bitcast(r1.y) == 2139095040i))); + r1.z = bitcast(select(0u, 4294967295u, !((r1.x == r1.x)))); + r1.y = bitcast((bitcast(r1.y) | bitcast(r1.z))); + let v_5 = bitcast(r1.y); + r1.x = select(r1.x, 0.0f, (v_5 != 0u)); + r0.z = (r0.z + r1.x); + r1.x = bitcast((bitcast(r0.w) & 2147483647u)); + r1.x = bitcast(select(0u, 4294967295u, (bitcast(r1.x) == 2139095040i))); + r1.y = bitcast(select(0u, 4294967295u, !((r0.w == r0.w)))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r1.y))); + let v_6 = bitcast(r1.x); + r0.w = select(r0.w, 0.0f, (v_6 != 0u)); + r0.z = (r0.w + r0.z); + r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4(1.5f, 1.5f, 2.5f, 1.5f), r0.xyxy); + r2 = textureSample(t0, s0, r1.xyxx.xy); + r1 = textureSample(t0, s0, r1.zwzz.xy); + r0.w = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.x = dot(r2.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.y = bitcast((bitcast(r1.x) & 2147483647u)); + r1.y = bitcast(select(0u, 4294967295u, (bitcast(r1.y) == 2139095040i))); + r1.z = bitcast(select(0u, 4294967295u, !((r1.x == r1.x)))); + r1.y = bitcast((bitcast(r1.y) | bitcast(r1.z))); + let v_7 = bitcast(r1.y); + r1.x = select(r1.x, 0.0f, (v_7 != 0u)); + r0.z = (r0.z + r1.x); + r1.x = bitcast((bitcast(r0.w) & 2147483647u)); + r1.x = bitcast(select(0u, 4294967295u, (bitcast(r1.x) == 2139095040i))); + r1.y = bitcast(select(0u, 4294967295u, !((r0.w == r0.w)))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r1.y))); + let v_8 = bitcast(r1.x); + r0.w = select(r0.w, 0.0f, (v_8 != 0u)); + r0.z = (r0.w + r0.z); + r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4(3.5f, 1.5f, 0.5f, 2.5f), r0.xyxy); + r2 = textureSample(t0, s0, r1.xyxx.xy); + r1 = textureSample(t0, s0, r1.zwzz.xy); + r0.w = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.x = dot(r2.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.y = bitcast((bitcast(r1.x) & 2147483647u)); + r1.y = bitcast(select(0u, 4294967295u, (bitcast(r1.y) == 2139095040i))); + r1.z = bitcast(select(0u, 4294967295u, !((r1.x == r1.x)))); + r1.y = bitcast((bitcast(r1.y) | bitcast(r1.z))); + let v_9 = bitcast(r1.y); + r1.x = select(r1.x, 0.0f, (v_9 != 0u)); + r0.z = (r0.z + r1.x); + r1.x = bitcast((bitcast(r0.w) & 2147483647u)); + r1.x = bitcast(select(0u, 4294967295u, (bitcast(r1.x) == 2139095040i))); + r1.y = bitcast(select(0u, 4294967295u, !((r0.w == r0.w)))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r1.y))); + let v_10 = bitcast(r1.x); + r0.w = select(r0.w, 0.0f, (v_10 != 0u)); + r0.z = (r0.w + r0.z); + r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4(1.5f, 2.5f, 2.5f, 2.5f), r0.xyxy); + let v_11 = fma(cb5_5.tint_symbol[75u].xy, vec2(3.5f, 2.5f), r0.xy); + r0 = vec4(v_11.xy, r0.zw); + r2 = textureSample(t0, s0, r0.xyxx.xy); + r0.x = dot(r2.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r2 = textureSample(t0, s0, r1.xyxx.xy); + r1 = textureSample(t0, s0, r1.zwzz.xy); + r0.y = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r0.w = dot(r2.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r1.x = bitcast((bitcast(r0.w) & 2147483647u)); + r1.x = bitcast(select(0u, 4294967295u, (bitcast(r1.x) == 2139095040i))); + r1.y = bitcast(select(0u, 4294967295u, !((r0.w == r0.w)))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r1.y))); + let v_12 = bitcast(r1.x); + r0.w = select(r0.w, 0.0f, (v_12 != 0u)); + r0.z = (r0.w + r0.z); + r0.w = bitcast((bitcast(r0.y) & 2147483647u)); + r0.w = bitcast(select(0u, 4294967295u, (bitcast(r0.w) == 2139095040i))); + r1.x = bitcast(select(0u, 4294967295u, !((r0.y == r0.y)))); + r0.w = bitcast((bitcast(r0.w) | bitcast(r1.x))); + let v_13 = bitcast(r0.w); + r0.y = select(r0.y, 0.0f, (v_13 != 0u)); + r0.y = (r0.y + r0.z); + r0.z = bitcast((bitcast(r0.x) & 2147483647u)); + r0.z = bitcast(select(0u, 4294967295u, (bitcast(r0.z) == 2139095040i))); + r0.w = bitcast(select(0u, 4294967295u, !((r0.x == r0.x)))); + r0.z = bitcast((bitcast(r0.z) | bitcast(r0.w))); + let v_14 = bitcast(r0.z); + r0.x = select(r0.x, 0.0f, (v_14 != 0u)); + r0.x = (r0.x + r0.y); + o0 = (r0.x * 0.08333333581686019897f); +} + +@fragment +fn main(@location(1u) v1 : vec4) -> @location(0u) f32 { + main_inner(v1); + return o0; +} diff --git a/b/8b0b5899ed/shaders/010e1159a3a24d20.wgsl b/b/8b0b5899ed/shaders/010e1159a3a24d20.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..e4384a47697eb8a45f3695b0b5ec416ea6321b28 --- /dev/null +++ b/b/8b0b5899ed/shaders/010e1159a3a24d20.wgsl @@ -0,0 +1,56 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb16_struct; + +struct cb5_struct { + tint_symbol_1 : array, 5u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb5_struct; + +struct cb1_struct { + tint_symbol_2 : array, 1u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb1_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +var o0 : vec4; + +fn main_inner(v2 : vec4) { + r0 = textureSample(t0, s0, v2.xy.xyxx.xy); + r0.x = (r0.w * cb2_2.tint_symbol[15u].x); + let v = -(cb5_5.tint_symbol_1[4u].xxxx); + r0.y = fma(r0.w, cb2_2.tint_symbol[15u].x, v.y); + r0.z = (v.z + 1.0f); + r0.z = (r0.z * 0.10000000149011611938f); + r0.y = (r0.y / r0.z); + r0.y = fma((-(r0.wwww)).y, cb2_2.tint_symbol[15u].x, r0.y); + r0.x = fma(cb12_12.tint_symbol_2[0u].z, r0.y, r0.x); + r0.y = bitcast(select(0u, 4294967295u, (0.0039215688593685627f >= r0.x))); + v_1((bitcast(r0.y) != 0u)); + o0 = vec4(vec3(), o0.w); + o0.w = r0.x; +} + +fn v_1(v_2 : bool) { + if (v_2) { + discard; + return; + } +} + +@fragment +fn main(@location(2u) v2 : vec4) -> @location(0u) vec4 { + main_inner(v2); + return o0; +} diff --git a/b/8b0b5899ed/shaders/01175517e8e0e635.consts.json b/b/8b0b5899ed/shaders/01175517e8e0e635.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/01175517e8e0e635.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/01175517e8e0e635.wgsl b/b/8b0b5899ed/shaders/01175517e8e0e635.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..b5ae6223cb8c9b9940b8b668ec2c6fe6bb64812d --- /dev/null +++ b/b/8b0b5899ed/shaders/01175517e8e0e635.wgsl @@ -0,0 +1,927 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v6 : vec4; + +var v7 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v6 = v_2; + x1[0u].x = v7[0u]; + x1[0u].y = v7[1u]; + x1[0u].z = v7[2u]; + x1[0u].w = v7[3u]; + r0 = textureSample(t0, s0, v1.xy.xyxx.xy); + r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x))); + v_3((bitcast(r1.x) != 0u)); + r1 = textureSample(t2, s2, v1.xy.xyxx.xy); + let v_4 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_4.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[1u].w, 0.00100000004749745131f); + let v_5 = (r1.ww * r1.xy); + r1 = vec4(v_5.xy, r1.zw); + let v_6 = (r1.yyy * v4.xyz); + r2 = vec4(v_6.xyz, r2.w); + let v_7 = fma(r1.xxx, v3.xyz, r2.xyz); + r1 = vec4(v_7.xy, r1.z, v_7.z); + let v_8 = fma(r1.zzz, v2.xyz, r1.xyw); + r1 = vec4(v_8.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_9 = (r1.www * r1.xyz); + r2 = vec4(v_9.xyz, r2.w); + r3 = textureSample(t3, s3, v1.xy.xyxx.xy); + let v_10 = (r3.xy * r3.xy); + r3 = vec4(v_10.xy, r3.zw); + r1.x = dot(r3.xyz, cb12_12.tint_symbol_4[1u].xyz); + r1.x = clamp(((r1.xxxx * cb12_12.tint_symbol_4[0u].zzzz)).x, 0.0f, 1.0f); + r0.w = (r0.w * v0.w); + let v_11 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r3 = vec4(v_11.xy, r3.zw); + let v_12 = (r0.xyz * r0.xyz); + r0 = vec4(v_12.xyz, r0.w); + let v_13 = -(v5.xyzx); + let v_14 = (v_13.xyz + cb1_1.tint_symbol[15u].xyz); + r4 = vec4(v_14.xyz, r4.w); + r1.y = dot(r4.xyz, r4.xyz); + r1.y = inverseSqrt(r1.y); + let v_15 = (r1.yyy * r4.xyz); + r5 = vec4(v_15.xyz, r5.w); + let v_16 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_17 = fma(r4.xyz, r1.yyy, v_16.xyz); + r6 = vec4(v_17.xyz, r6.w); + r2.w = dot(r6.xyz, r6.xyz); + r2.w = inverseSqrt(r2.w); + let v_18 = (r2.www * r6.xyz); + r6 = vec4(v_18.xyz, r6.w); + r2.w = fma(r3.w, cb12_12.tint_symbol_4[0u].y, -500.0f); + r2.w = max(r2.w, 0.0f); + let v_19 = -(r2.wwww); + r3.z = fma(r3.w, cb12_12.tint_symbol_4[0u].y, v_19.z); + r2.w = (r2.w * 558.0f); + r2.w = fma(r3.z, 3.0f, r2.w); + r3.z = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz); + let v_20 = (v5.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r7 = vec4(v_20.xyz, r7.w); + let v_21 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_21.xyz, r8.w); + let v_22 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_22.xyz, r8.w); + let v_23 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_23.xyz, r8.w); + let v_24 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_24.xyz, r9.w); + let v_25 = &(x0[0u]); + let v_26 = r9; + *(v_25) = vec4(v_26.xyz, (*(v_25)).w); + let v_27 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_27.xyz, r10.w); + let v_28 = &(x0[1u]); + let v_29 = r10; + *(v_28) = vec4(v_29.xyz, (*(v_28)).w); + let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_30.xyz, r11.w); + let v_31 = &(x0[2u]); + let v_32 = r11; + *(v_31) = vec4(v_32.xyz, (*(v_31)).w); + let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_33.xyz, r8.w); + let v_34 = &(x0[3u]); + let v_35 = r8; + *(v_34) = vec4(v_35.xyz, (*(v_34)).w); + let v_36 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_37 = r12; + r12 = vec4(v_37.x, v_36.x, v_37.z, v_36.y); + r3.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r3.w = (r3.w * 0.5f); + let v_38 = abs(r11.yyyy); + r4.w = max(v_38.w, abs(r11.xxxx).w); + r4.w = bitcast(select(0u, 4294967295u, (r4.w < r3.w))); + let v_39 = (bitcast(r4.w) != 0u); + let v_40 = bitcast(v.tint_symbol_6[0i].x); + r4.w = select(bitcast(v.tint_symbol_6[1i].x), v_40, v_39); + let v_41 = abs(r10.yyyy); + r5.w = max(v_41.w, abs(r10.xxxx).w); + r5.w = bitcast(select(0u, 4294967295u, (r5.w < r3.w))); + let v_42 = bitcast(r5.w); + r4.w = select(r4.w, bitcast(v.tint_symbol_6[2i].x), (v_42 != 0u)); + let v_43 = abs(r9.yyyy); + r5.w = max(v_43.w, abs(r9.xxxx).w); + r3.w = bitcast(select(0u, 4294967295u, (r5.w < r3.w))); + let v_44 = bitcast(r3.w); + r3.w = select(r4.w, 0.0f, (v_44 != 0u)); + let v_45 = x0[bitcast(r3.w)]; + r9 = vec4(v_45.xyz, r9.w); + r3.w = f32(bitcast(r3.w)); + r4.w = (r3.w + 0.5f); + r4.w = (r4.w * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r3.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r3.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r5.w = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r4.w); + r4.w = bitcast(select(0u, 4294967295u, !((r3.w == 0.0f)))); + r3.w = ((-(r3.wwww)).w + r9.z); + let v_46 = dpdx(r10.xyy); + r11 = vec4(v_46.xy, r11.z, v_46.z); + r11.z = dpdx(r3.w); + let v_47 = dpdy(r10.yxy); + r13 = vec4(v_47.xyz, r13.w); + r13.w = dpdy(r3.w); + let v_48 = (r11.yw * r13.yw); + r8 = vec4(r8.xy, v_48.xy); + let v_49 = -(r8.zwzz); + let v_50 = fma(r11.xz, r13.xz, v_49.xy); + r14 = vec4(v_50.xy, r14.zw); + r6.w = (1.0f / r14.x); + r7.w = (r11.z * r13.y); + let v_51 = -(r7.wwww); + r14.z = fma(r11.x, r13.w, v_51.z); + let v_52 = (r6.ww * r14.yz); + r8 = vec4(r8.xy, v_52.xy); + let v_53 = max(r8.zw, vec2()); + r8 = vec4(r8.xy, v_53.xy); + let v_54 = min(r8.zw, vec2(0.5f)); + r8 = vec4(r8.xy, v_54.xy); + r3.w = fma((-(r5.wwww)).w, r8.z, r3.w); + r3.w = fma((-(r5.wwww)).w, r8.w, r3.w); + let v_55 = bitcast(r4.w); + let v_56 = r3.w; + r12.z = select(r9.z, v_56, (v_55 != 0u)); + r10.z = 0.0f; + let v_57 = (r10.xyz + r12.ywz); + r9 = vec4(v_57.xyz, r9.w); + let v_58 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_58.xy, r12.zw); + let v_59 = (r10.xyz + r12.xyz); + r11 = vec4(v_59.xyz, r11.w); + let v_60 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_60.xy, r12.zw); + let v_61 = (r10.xyz + r12.xyz); + r13 = vec4(v_61.xyz, r13.w); + let v_62 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_62.xy, r12.zw); + let v_63 = (r10.xyz + r12.xyz); + r14 = vec4(v_63.xyz, r14.w); + let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_64.xy, r12.zw); + let v_65 = (r10.xyz + r12.xyz); + r15 = vec4(v_65.xyz, r15.w); + let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_66.xy, r12.zw); + let v_67 = (r10.xyz + r12.xyz); + r16 = vec4(v_67.xyz, r16.w); + let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_68.xy, r12.zw); + let v_69 = (r10.xyz + r12.xyz); + r17 = vec4(v_69.xyz, r17.w); + let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_70.xy, r12.zw); + let v_71 = (r10.xyz + r12.xyz); + r18 = vec4(v_71.xyz, r18.w); + let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_72.xy, r12.zw); + let v_73 = (r10.xyz + r12.xyz); + r19 = vec4(v_73.xyz, r19.w); + let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_74.xy, r12.zw); + let v_75 = (r10.xyz + r12.xyz); + r20 = vec4(v_75.xyz, r20.w); + let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_76.xy, r12.zw); + let v_77 = (r10.xyz + r12.xyz); + r21 = vec4(v_77.xyz, r21.w); + let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_78.xy, r12.zw); + let v_79 = (r10.xyz + r12.xyz); + r22 = vec4(v_79.xyz, r22.w); + let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_80.xy, r12.zw); + let v_81 = (r10.xyz + r12.xyz); + r23 = vec4(v_81.xyz, r23.w); + let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_82.xy, r12.zw); + let v_83 = (r10.xyz + r12.xyz); + r24 = vec4(v_83.xyz, r24.w); + let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_84.xy, r12.zw); + let v_85 = (r10.xyz + r12.xyz); + r25 = vec4(v_85.xyz, r25.w); + let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_86.xy, r12.zw); + let v_87 = (r10.xyz + r12.xyz); + r10 = vec4(v_87.xyz, r10.w); + let v_88 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_88.xy, r9.z); + let v_89 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_89.xy, r11.z); + let v_90 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_90.xy, r13.z); + let v_91 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_91.xy, r14.z); + let v_92 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_92.xy, r15.z); + let v_93 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_93.xy, r16.z); + let v_94 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_94.xy, r17.z); + let v_95 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_95.xy, r18.z); + let v_96 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_96.xy, r19.z); + let v_97 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_97.xy, r20.z); + let v_98 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_98.xy, r21.z); + let v_99 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_99.xy, r22.z); + let v_100 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_100.xy, r23.z); + let v_101 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_101.xy, r24.z); + let v_102 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_102.xy, r25.z); + let v_103 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_103.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r3.w = dot(r9, vec4(1.0f)); + r3.z = clamp(fma(r3.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f); + let v_104 = abs(r8.yyyy); + r4.w = max(v_104.w, abs(r8.xxxx).w); + r4.w = clamp(fma(r4.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r3.z = ((-(r3.zzzz)).z + 1.0f); + r3.z = (r4.w * r3.z); + r3.z = fma(r3.w, 0.0625f, r3.z); + let v_105 = (r3.xyz * r3.xyz); + r3 = vec4(v_105.xyz, r3.w); + r3.z = min(r3.z, 1.0f); + r3.w = clamp(fma(v5.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r3.w = sqrt(r3.w); + r3.w = (r3.w * cb6_6.tint_symbol_5[3u].z); + let v_106 = -(r3.zzzz); + r3.z = fma(r3.w, v_106.z, r3.z); + let v_107 = dot(r2.xyz, v_16.xyz); + r3.w = clamp(vec4(v_107, v_107, v_107, v_107).w, 0.0f, 1.0f); + let v_108 = dot(r5.xyz, r2.xyz); + r8.x = clamp(vec4(v_108, v_108, v_108, v_108).x, 0.0f, 1.0f); + let v_109 = dot(r6.xyz, v_16.xyz); + r8.y = clamp(vec4(v_109, v_109, v_109, v_109).y, 0.0f, 1.0f); + let v_110 = ((-(r8.xyxx)).xy + vec2(1.0f)); + r8 = vec4(v_110.xy, r8.zw); + let v_111 = (r8.xy * r8.xy); + r8 = vec4(r8.xy, v_111.xy); + let v_112 = (r8.zw * r8.zw); + r8 = vec4(r8.xy, v_112.xy); + let v_113 = (r8.xy * r8.zw); + r8 = vec4(v_113.xy, r8.zw); + r4.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f); + let v_114 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r4.ww); + r8 = vec4(v_114.xy, r8.zw); + let v_115 = (r2.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(r8.xy, v_115.xy); + r2.w = (r8.z * 0.125f); + r5.w = fma((-(r1.xxxx)).w, r8.x, 1.0f); + r6.x = dot(r2.xyz, r6.xyz); + r6.x = clamp(((r6.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r6.x = log2(r6.x); + r6.x = (r6.x * r8.w); + r6.x = exp2(r6.x); + r6.x = (r8.y * r6.x); + r6.x = (r2.w * r6.x); + r6.x = (r1.x * r6.x); + r6.x = (r3.w * r6.x); + r3.w = (r3.w * r5.w); + let v_116 = fma(r0.xyz, r3.www, r6.xxx); + r6 = vec4(v_116.xyz, r6.w); + let v_117 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz); + r6 = vec4(v_117.xyz, r6.w); + r3.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r3.w) != 0u)) { + r9 = vec4(vec3(), r9.w); + r8 = vec4(vec3(), r8.w); + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_118 = (v_13.xyz + cb3_3.tint_symbol_2[3u].xyz); + r8 = vec4(v_118.xyz, r8.w); + let v_119 = (v5.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r9 = vec4(v_119.xyz, r9.w); + r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w); + let v_120 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_120.xyz, r9.w); + let v_121 = (r9.xyz + v_13.xyz); + r9 = vec4(v_121.xyz, r9.w); + let v_122 = bitcast>(r6.www); + let v_123 = r8.xyz; + let v_124 = select(r9.xyz, v_123, (v_122 != vec3())); + r8 = vec4(v_124.xyz, r8.w); + r6.w = dot(r8.xyz, r8.xyz); + let v_125 = (r8.xyz + vec3(0.00000099999999747524f)); + r8 = vec4(v_125.xyz, r8.w); + r7.w = dot(r8.xyz, r8.xyz); + r7.w = inverseSqrt(r7.w); + let v_126 = (r7.www * r8.xyz); + r8 = vec4(v_126.xyz, r8.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[11u].w); + r6.w = (r6.w / r7.w); + let v_127 = -(cb3_3.tint_symbol_2[11u].xyzx); + r7.w = dot(r8.xyz, v_127.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_128 = dot(r8.xyz, r2.xyz); + r9.x = clamp(vec4(v_128, v_128, v_128, v_128).x, 0.0f, 1.0f); + r7.w = (r7.w * r9.x); + r9.x = (r6.w * r7.w); + let v_129 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_129.xyz, r9.w); + let v_130 = (r0.xyz * r9.xyz); + r9 = vec4(v_130.xyz, r9.w); + let v_131 = fma(r4.xyz, r1.yyy, r8.xyz); + r8 = vec4(v_131.xyz, r8.w); + r9.w = dot(r8.xyz, r8.xyz); + r9.w = inverseSqrt(r9.w); + let v_132 = (r8.xyz * r9.www); + r8 = vec4(v_132.xyz, r8.w); + let v_133 = dot(r8.xyz, r5.xyz); + r9.w = clamp(vec4(v_133, v_133, v_133, v_133).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.x = (r9.w * r9.w); + r10.x = (r10.x * r10.x); + r9.w = (r9.w * r10.x); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_134 = dot(r8.xyz, r2.xyz); + r8.x = clamp(vec4(v_134, v_134, v_134, v_134).x, 0.0f, 1.0f); + r8.x = log2(r8.x); + r8.x = (r8.x * r8.w); + r8.x = exp2(r8.x); + r8.x = (r8.x * r9.w); + r7.w = (r7.w * r8.x); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_135 = (r6.www * cb3_3.tint_symbol_2[19u].xyz); + r8 = vec4(v_135.xyz, r8.w); + } + r6.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r7.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + let v_136 = bitcast(r7.w); + let v_137 = r6.w; + r3.w = select(r3.w, v_137, (v_136 != 0u)); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_138 = (v_13.xyz + cb3_3.tint_symbol_2[4u].xyz); + r10 = vec4(v_138.xyz, r10.w); + let v_139 = (v5.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r11 = vec4(v_139.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w); + let v_140 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_140.xyz, r11.w); + let v_141 = (r11.xyz + v_13.xyz); + r11 = vec4(v_141.xyz, r11.w); + let v_142 = bitcast>(r6.www); + let v_143 = r10.xyz; + let v_144 = select(r11.xyz, v_143, (v_142 != vec3())); + r10 = vec4(v_144.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_145 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_145.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_146 = (r7.www * r10.xyz); + r10 = vec4(v_146.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[12u].w); + r6.w = (r6.w / r7.w); + let v_147 = -(cb3_3.tint_symbol_2[12u].xyzx); + r7.w = dot(r10.xyz, v_147.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_148 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_148, v_148, v_148, v_148).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_149 = (r9.www * cb3_3.tint_symbol_2[20u].xyz); + r11 = vec4(v_149.xyz, r11.w); + let v_150 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_150.xyz, r9.w); + let v_151 = fma(r4.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_151.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_152 = (r9.www * r10.xyz); + r10 = vec4(v_152.xyz, r10.w); + let v_153 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_153, v_153, v_153, v_153).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_154 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_154, v_154, v_154, v_154).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_155 = fma(r6.www, cb3_3.tint_symbol_2[20u].xyz, r8.xyz); + r8 = vec4(v_155.xyz, r8.w); + } + } else { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_156 = (v_13.xyz + cb3_3.tint_symbol_2[5u].xyz); + r10 = vec4(v_156.xyz, r10.w); + let v_157 = (v5.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r11 = vec4(v_157.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w); + let v_158 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_158.xyz, r11.w); + let v_159 = (r11.xyz + v_13.xyz); + r11 = vec4(v_159.xyz, r11.w); + let v_160 = bitcast>(r6.www); + let v_161 = r10.xyz; + let v_162 = select(r11.xyz, v_161, (v_160 != vec3())); + r10 = vec4(v_162.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_163 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_163.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_164 = (r7.www * r10.xyz); + r10 = vec4(v_164.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[13u].w); + r6.w = (r6.w / r7.w); + let v_165 = -(cb3_3.tint_symbol_2[13u].xyzx); + r7.w = dot(r10.xyz, v_165.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_166 = dot(r10.xyz, r2.xyz); + r9.w = clamp(vec4(v_166, v_166, v_166, v_166).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_167 = (r9.www * cb3_3.tint_symbol_2[21u].xyz); + r11 = vec4(v_167.xyz, r11.w); + let v_168 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_168.xyz, r9.w); + let v_169 = fma(r4.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_169.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_170 = (r9.www * r10.xyz); + r10 = vec4(v_170.xyz, r10.w); + let v_171 = dot(r10.xyz, r5.xyz); + r9.w = clamp(vec4(v_171, v_171, v_171, v_171).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w); + let v_172 = dot(r10.xyz, r2.xyz); + r10.x = clamp(vec4(v_172, v_172, v_172, v_172).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.w * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_173 = fma(r6.www, cb3_3.tint_symbol_2[21u].xyz, r8.xyz); + r8 = vec4(v_173.xyz, r8.w); + } + } + if ((bitcast(r3.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast((bitcast(r3.w) | bitcast(r6.w))); + if ((bitcast(r3.w) != 0u)) { + } else { + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_174 = (v_13.xyz + cb3_3.tint_symbol_2[6u].xyz); + r10 = vec4(v_174.xyz, r10.w); + let v_175 = (v5.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r11 = vec4(v_175.xyz, r11.w); + r6.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz); + r6.w = clamp(((r6.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r6.w = (r6.w * cb3_3.tint_symbol_2[22u].w); + let v_176 = fma(cb3_3.tint_symbol_2[14u].xyz, r6.www, cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_176.xyz, r11.w); + let v_177 = (r11.xyz + v_13.xyz); + r11 = vec4(v_177.xyz, r11.w); + let v_178 = bitcast>(r3.www); + let v_179 = r10.xyz; + let v_180 = select(r11.xyz, v_179, (v_178 != vec3())); + r10 = vec4(v_180.xyz, r10.w); + r3.w = dot(r10.xyz, r10.xyz); + let v_181 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_181.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + r6.w = inverseSqrt(r6.w); + let v_182 = (r6.www * r10.xyz); + r10 = vec4(v_182.xyz, r10.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r6.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r6.w = fma(r6.w, r3.w, cb3_3.tint_symbol_2[14u].w); + r3.w = (r3.w / r6.w); + let v_183 = -(cb3_3.tint_symbol_2[14u].xyzx); + r6.w = dot(r10.xyz, v_183.xyz); + r6.w = clamp(fma(r6.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_184 = dot(r10.xyz, r2.xyz); + r7.w = clamp(vec4(v_184, v_184, v_184, v_184).w, 0.0f, 1.0f); + r6.w = (r6.w * r7.w); + r7.w = (r3.w * r6.w); + let v_185 = (r7.www * cb3_3.tint_symbol_2[22u].xyz); + r11 = vec4(v_185.xyz, r11.w); + let v_186 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_186.xyz, r9.w); + let v_187 = fma(r4.xyz, r1.yyy, r10.xyz); + r4 = vec4(v_187.xyz, r4.w); + r1.y = dot(r4.xyz, r4.xyz); + r1.y = inverseSqrt(r1.y); + let v_188 = (r1.yyy * r4.xyz); + r4 = vec4(v_188.xyz, r4.w); + let v_189 = dot(r4.xyz, r5.xyz); + r1.y = clamp(vec4(v_189, v_189, v_189, v_189).y, 0.0f, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r5.x = (r1.y * r1.y); + r5.x = (r5.x * r5.x); + r1.y = (r1.y * r5.x); + r1.y = fma(cb12_12.tint_symbol_4[0u].x, r1.y, r4.w); + let v_190 = dot(r4.xyz, r2.xyz); + r4.x = clamp(vec4(v_190, v_190, v_190, v_190).x, 0.0f, 1.0f); + r4.x = log2(r4.x); + r4.x = (r4.x * r8.w); + r4.x = exp2(r4.x); + r1.y = (r1.y * r4.x); + r1.y = (r6.w * r1.y); + r1.y = (r3.w * r1.y); + r1.y = (r2.w * r1.y); + let v_191 = fma(r1.yyy, cb3_3.tint_symbol_2[22u].xyz, r8.xyz); + r8 = vec4(v_191.xyz, r8.w); + } + } + r1.y = (r5.w * r5.w); + r1.x = (r1.x * r1.x); + let v_192 = (r8.xyz * r1.xxx); + r4 = vec4(v_192.xyz, r4.w); + let v_193 = fma(r1.yyy, r9.xyz, r4.xyz); + r4 = vec4(v_193.xyz, r4.w); + let v_194 = fma(r6.xyz, r3.zzz, r4.xyz); + r4 = vec4(v_194.xyz, r4.w); + r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_195 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r1 = vec4(r1.x, v_195.xyz); + r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_196 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r5 = vec4(v_196.xyz, r5.w); + let v_197 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz); + r5 = vec4(v_197.xyz, r5.w); + let v_198 = fma(r1.yzw, r2.www, r5.xyz); + r1 = vec4(r1.x, v_198.xyz); + let v_199 = (r3.yyy * r1.yzw); + r1 = vec4(r1.x, v_199.xyz); + let v_200 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r3 = vec4(r3.x, v_200.xyz); + r5.x = cb3_3.tint_symbol_2[46u].w; + r5.y = cb3_3.tint_symbol_2[47u].w; + r5.z = cb3_3.tint_symbol_2[48u].w; + let v_201 = dot(r5.xyz, r2.xyz); + r1.x = clamp(vec4(v_201, v_201, v_201, v_201).x, 0.0f, 1.0f); + let v_202 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r3.yzw); + r2 = vec4(v_202.xyz, r2.w); + let v_203 = fma(r2.xyz, r3.xxx, r1.yzw); + r1 = vec4(v_203.xyz, r1.w); + let v_204 = (r5.www * r1.xyz); + r1 = vec4(v_204.xyz, r1.w); + let v_205 = fma(r1.xyz, r0.xyz, r4.xyz); + r0 = vec4(v_205.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r7.xyz, r7.xyz); + r1.x = sqrt(r0.w); + let v_206 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_206.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r7.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_207 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_207 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_208 = (r0.www * r7.xyz); + r2 = vec4(v_208.xyz, r2.w); + let v_209 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_209, v_209, v_209, v_209).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_210 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_210, v_210, v_210, v_210).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_211 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_211.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_212 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_212.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_213 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_213.xyz, r2.w); + let v_214 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_214.xyz, r2.w); + let v_215 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_215.xyz, r3.w); + let v_216 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_216.xyz, r2.w); + let v_217 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_218 = (r2.xyz + v_217.xyz); + r2 = vec4(v_218.xyz, r2.w); + let v_219 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_219.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_220 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_220.xyz, r3.w); + let v_221 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_221.xy, r1.z, v_221.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_222 = (v6.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_222.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_223 = -(r0.xyxz); + let v_224 = fma(r1.xyw, r0.www, v_223.xyw); + r1 = vec4(v_224.xy, r1.z, v_224.z); + let v_225 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_225.xyz, r1.w); + } else { + r0.w = dot(r7.xyz, r7.xyz); + r1.w = sqrt(r0.w); + let v_226 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_226.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r7.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_227 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_227 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_228 = (r0.www * r7.xyz); + r3 = vec4(v_228.xyz, r3.w); + let v_229 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_229, v_229, v_229, v_229).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_230 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_230, v_230, v_230, v_230).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_231 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_231.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_232 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_232.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_233 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_233.xyz, r3.w); + let v_234 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_234.xyz, r3.w); + let v_235 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_235.xyz, r4.w); + let v_236 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_236.xyz, r3.w); + let v_237 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_238 = (r3.xyz + v_237.xyz); + r3 = vec4(v_238.xyz, r3.w); + let v_239 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_239.x, r2.y, v_239.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_240 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_240.xyz, r3.w); + let v_241 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_241.x, r2.y, v_241.yz); + let v_242 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_242.x, r2.y, v_242.yz); + let v_243 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_243.xyz, r1.w); + } + let v_244 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_244.xyz, o0.w); +} + +fn v_3(v_245 : bool) { + if (v_245) { + discard; + return; + } +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @builtin(position) v_246 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3, v4, v5, v_246); + return o0; +} diff --git a/b/8b0b5899ed/shaders/01179bc0ec7d3e35.wgsl b/b/8b0b5899ed/shaders/01179bc0ec7d3e35.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..7391ffbe32f4ec72ea5b9f03463a7a21cf4b678e --- /dev/null +++ b/b/8b0b5899ed/shaders/01179bc0ec7d3e35.wgsl @@ -0,0 +1,132 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb17_struct { + tint_symbol_1 : array, 17u>, +} + +@group(0u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb50_struct { + tint_symbol_2 : array, 50u>, +} + +@group(0u) @binding(3u) var cb3_3 : cb50_struct; + +struct cb2_struct { + tint_symbol_3 : array, 2u>, +} + +@group(0u) @binding(13u) var cb13_13 : cb2_struct; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +var o6 : vec4; + +fn main_inner(v0 : vec3, v1 : vec4, v2 : vec2, v3 : vec2, v4 : vec3, v5 : vec4) { + r0 = (v0.yyyy * cb1_1.tint_symbol[9u]); + r0 = fma(v0.xxxx, cb1_1.tint_symbol[8u], r0); + r0 = fma(v0.zzzz, cb1_1.tint_symbol[10u], r0); + o0 = (r0 + cb1_1.tint_symbol[11u]); + let v = (v0.yyy * cb1_1.tint_symbol[1u].xyz); + r0 = vec4(v.xyz, r0.w); + let v_1 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz); + r0 = vec4(v_1.xyz, r0.w); + let v_2 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz); + r0 = vec4(v_2.xyz, r0.w); + let v_3 = (r0.xyz + cb1_1.tint_symbol[3u].xyz); + r0 = vec4(v_3.xyz, r0.w); + let v_4 = ((-(r0.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r0 = vec4(v_4.xyz, r0.w); + r0.w = dot(r0.xyz, r0.xyz); + o4 = r0.xyz.xyzx; + r0.x = (r0.w * 0.00000399999998990097f); + r0.x = min(r0.x, 1.0f); + r0.y = ((-(r0.xxxx)).y + 1.0f); + let v_5 = -(cb2_2.tint_symbol_1[16u].zzzz); + let v_6 = clamp(((r0.xyxx + v_5)).xy, vec2(), vec2(1.0f)); + r0 = vec4(v_6.xy, r0.zw); + r0.z = (cb3_3.tint_symbol_2[49u].w + -1.0f); + let v_7 = fma(r0.xy, r0.zz, vec2(1.0f)); + r0 = vec4(v_7.xy, r0.zw); + let v_8 = clamp(((r0.xyxx * v1.xyxx)).xy, vec2(), vec2(1.0f)); + o1 = vec4(v_8.xy, o1.zw); + o1 = vec4(o1.xy, v1.zw); + o2 = vec4(o2.xy, v3.xy); + r0 = vec4(v2.xy, r0.zw); + r0.z = 1.0f; + o2.x = dot(cb13_13.tint_symbol_3[0u].xyz, r0.xyz); + o2.y = dot(cb13_13.tint_symbol_3[1u].xyz, r0.xyz); + r0.x = dot(v4, v4); + r0.x = bitcast(select(0u, 4294967295u, (r0.x < 0.10000000149011611938f))); + let v_9 = select(v4, vec3(0.0f, 0.0f, 1.0f), (bitcast>(r0.xxx) != vec3())); + r0 = vec4(v_9.xyz, r0.w); + let v_10 = (r0.yyy * cb1_1.tint_symbol[1u].xyz); + r1 = vec4(v_10.xyz, r1.w); + let v_11 = fma(r0.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz); + r0 = vec4(v_11.xy, r0.z, v_11.z); + let v_12 = fma(r0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyw); + r0 = vec4(v_12.xyz, r0.w); + r0.w = dot(r0.xyz, r0.xyz); + r0.w = inverseSqrt(r0.w); + let v_13 = (r0.www * r0.xyz); + r0 = vec4(v_13.xyz, r0.w); + o3 = r0.xyz.xyzx; + let v_14 = (v5.yyy * cb1_1.tint_symbol[1u].xyz); + r1 = vec4(v_14.xyz, r1.w); + let v_15 = fma(v5.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz); + r1 = vec4(v_15.xyz, r1.w); + let v_16 = fma(v5.zzz, cb1_1.tint_symbol[2u].xyz, r1.xyz); + r1 = vec4(v_16.xyz, r1.w); + o5 = r1.xyz.xyzx; + let v_17 = (r0.yzx * r1.zxy); + r2 = vec4(v_17.xyz, r2.w); + let v_18 = -(r2.xyzx); + let v_19 = fma(r1.yzx, r0.zxy, v_18.xyz); + r0 = vec4(v_19.xyz, r0.w); + o6 = ((r0.xyz * v5.www)).xyzx; +} + +struct tint_symbol_4 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, + @location(6u) + o6 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(2u) v2 : vec2, @location(3u) v3 : vec2, @location(4u) v4 : vec3, @location(5u) v5 : vec4) -> tint_symbol_4 { + main_inner(v0, v1, v2, v3, v4, v5); + return tint_symbol_4(o0, o1, o2, o3, o4, o5, o6); +} diff --git a/b/8b0b5899ed/shaders/011e02044e8ffb82.consts.json b/b/8b0b5899ed/shaders/011e02044e8ffb82.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/011e02044e8ffb82.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/011e02044e8ffb82.wgsl b/b/8b0b5899ed/shaders/011e02044e8ffb82.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..88b7b837d388cdee2c37ca7cce6362bf000e5a62 --- /dev/null +++ b/b/8b0b5899ed/shaders/011e02044e8ffb82.wgsl @@ -0,0 +1,1233 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb1_struct { + tint_symbol_5 : array, 1u>, +} + +@group(1u) @binding(11u) var cb11_11 : cb1_struct; + +struct cb15_struct { + tint_symbol_6 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(21u) var s5 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(37u) var t5 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v7 : vec4; + +var v8 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_8 { + tint_symbol_7 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_8; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v7 = v_2; + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t0, s0, v2.xy.xyxx.xy); + r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x))); + v_3((bitcast(r1.x) != 0u)); + let v_4 = (v2.xy * cb11_11.tint_symbol_5[0u].zw); + r1 = vec4(v_4.xy, r1.zw); + r2 = textureSample(t3, s3, r1.xyxx.xy); + let v_5 = fma(r2.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(r1.xy, v_5.xy); + let v_6 = (r1.xy * vec2(3.1700000762939453125f)); + r1 = vec4(v_6.xy, r1.zw); + r2 = textureSample(t3, s3, r1.xyxx.xy); + let v_7 = fma(r2.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_7.xy, r1.zw); + let v_8 = (r1.xy * vec2(0.5f)); + r1 = vec4(v_8.xy, r1.zw); + let v_9 = fma(r1.zw, vec2(0.5f), r1.xy); + r1 = vec4(v_9.xy, r1.zw); + r1.z = fma((-(r1.xxxx)).z, cb11_11.tint_symbol_5[0u].x, 1.0f); + r0 = (r0 * r1.zzzz); + r2 = textureSample(t5, s5, v2.xy.xyxx.xy); + let v_10 = fma(r1.xy, cb11_11.tint_symbol_5[0u].yy, r2.xy); + r1 = vec4(v_10.xy, r1.zw); + let v_11 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_11.xy, r1.zw); + r1.w = dot(r1.xy, r1.xy); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.w = sqrt(abs(r1.wwww).w); + r2.x = max(cb12_12.tint_symbol_4[1u].x, 0.00100000004749745131f); + let v_12 = (r1.xy * r2.xx); + r1 = vec4(v_12.xy, r1.zw); + let v_13 = (r1.yyy * v5.xyz); + r2 = vec4(v_13.xyz, r2.w); + let v_14 = fma(r1.xxx, v4.xyz, r2.xyz); + r2 = vec4(v_14.xyz, r2.w); + let v_15 = fma(r1.www, v3.xyz, r2.xyz); + r1 = vec4(v_15.xy, r1.z, v_15.z); + r2.x = dot(r1.xyw, r1.xyw); + r2.x = inverseSqrt(r2.x); + let v_16 = (r1.xyw * r2.xxx); + r2 = vec4(r2.x, v_16.xyz); + r1.x = clamp(((r1.zzzz * cb12_12.tint_symbol_4[0u].wwww)).x, 0.0f, 1.0f); + let v_17 = (r0.xyz * v1.xyz); + r0 = vec4(v_17.xyz, r0.w); + r0.w = (r0.w * v0.w); + let v_18 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + let v_19 = r1; + r1 = vec4(v_19.x, v_18.xy, v_19.w); + let v_20 = (r0.xyz * r0.xyz); + r0 = vec4(v_20.xyz, r0.w); + let v_21 = -(v6.xyzx); + let v_22 = (v_21.xyz + cb1_1.tint_symbol[15u].xyz); + r3 = vec4(v_22.xyz, r3.w); + r3.w = dot(r3.xyz, r3.xyz); + r3.w = inverseSqrt(r3.w); + let v_23 = (r3.www * r3.xyz); + r4 = vec4(v_23.xyz, r4.w); + let v_24 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_25 = fma(r3.xyz, r3.www, v_24.xyz); + r5 = vec4(v_25.xyz, r5.w); + r4.w = dot(r5.xyz, r5.xyz); + r4.w = inverseSqrt(r4.w); + let v_26 = (r4.www * r5.xyz); + r5 = vec4(v_26.xyz, r5.w); + let v_27 = (r1.yz * r1.yz); + let v_28 = r1; + r1 = vec4(v_28.x, v_27.xy, v_28.w); + r4.w = (cb12_12.tint_symbol_4[0u].z + -500.0f); + r4.w = max(r4.w, 0.0f); + r5.w = ((-(r4.wwww)).w + cb12_12.tint_symbol_4[0u].z); + r4.w = (r4.w * 558.0f); + r4.w = fma(r5.w, 3.0f, r4.w); + r5.w = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz); + let v_29 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r6 = vec4(v_29.xyz, r6.w); + let v_30 = (r6.yyy * cb6_6.tint_symbol_6[1u].xyz); + r7 = vec4(v_30.xyz, r7.w); + let v_31 = fma(r6.xxx, cb6_6.tint_symbol_6[0u].xyz, r7.xyz); + r7 = vec4(v_31.xyz, r7.w); + let v_32 = fma(r6.zzz, cb6_6.tint_symbol_6[2u].xyz, r7.xyz); + r7 = vec4(v_32.xyz, r7.w); + let v_33 = fma(r7.xyz, cb6_6.tint_symbol_6[4u].xyz, cb6_6.tint_symbol_6[8u].xyz); + r8 = vec4(v_33.xyz, r8.w); + let v_34 = &(x0[0u]); + let v_35 = r8; + *(v_34) = vec4(v_35.xyz, (*(v_34)).w); + let v_36 = fma(r7.xyz, cb6_6.tint_symbol_6[5u].xyz, cb6_6.tint_symbol_6[9u].xyz); + r9 = vec4(v_36.xyz, r9.w); + let v_37 = &(x0[1u]); + let v_38 = r9; + *(v_37) = vec4(v_38.xyz, (*(v_37)).w); + let v_39 = fma(r7.xyz, cb6_6.tint_symbol_6[6u].xyz, cb6_6.tint_symbol_6[10u].xyz); + r10 = vec4(v_39.xyz, r10.w); + let v_40 = &(x0[2u]); + let v_41 = r10; + *(v_40) = vec4(v_41.xyz, (*(v_40)).w); + let v_42 = fma(r7.xyz, cb6_6.tint_symbol_6[7u].xyz, cb6_6.tint_symbol_6[11u].xyz); + r7 = vec4(v_42.xyz, r7.w); + let v_43 = &(x0[3u]); + let v_44 = r7; + *(v_43) = vec4(v_44.xyz, (*(v_43)).w); + let v_45 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_46 = r11; + r11 = vec4(v_46.x, v_45.x, v_46.z, v_45.y); + r6.w = fma((-(cb6_6.tint_symbol_6[14u].zzzz)).w, 1.5f, 1.0f); + r6.w = (r6.w * 0.5f); + let v_47 = abs(r10.yyyy); + r7.z = max(v_47.z, abs(r10.xxxx).z); + r7.z = bitcast(select(0u, 4294967295u, (r7.z < r6.w))); + let v_48 = (bitcast(r7.z) != 0u); + let v_49 = bitcast(v.tint_symbol_7[0i].x); + r7.z = select(bitcast(v.tint_symbol_7[1i].x), v_49, v_48); + let v_50 = abs(r9.yyyy); + r7.w = max(v_50.w, abs(r9.xxxx).w); + r7.w = bitcast(select(0u, 4294967295u, (r7.w < r6.w))); + let v_51 = bitcast(r7.w); + r7.z = select(r7.z, bitcast(v.tint_symbol_7[2i].x), (v_51 != 0u)); + let v_52 = abs(r8.yyyy); + r7.w = max(v_52.w, abs(r8.xxxx).w); + r6.w = bitcast(select(0u, 4294967295u, (r7.w < r6.w))); + let v_53 = bitcast(r6.w); + r6.w = select(r7.z, 0.0f, (v_53 != 0u)); + let v_54 = x0[bitcast(r6.w)]; + r8 = vec4(v_54.xyz, r8.w); + r6.w = f32(bitcast(r6.w)); + r7.z = (r6.w + 0.5f); + r7.z = (r7.z * 0.25f); + r9 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r6.wwww))); + r9 = bitcast>((bitcast>(r9) & vec4(1065353216u))); + r6.w = dot(r9, cb6_6.tint_symbol_6[12u]); + r7.w = dot(r9, cb6_6.tint_symbol_6[13u]); + r9.x = (r8.x + 0.5f); + r9.y = fma(r8.y, 0.25f, r7.z); + r7.z = bitcast(select(0u, 4294967295u, !((r6.w == 0.0f)))); + r6.w = ((-(r6.wwww)).w + r8.z); + let v_55 = dpdx(r9.xyy); + r10 = vec4(v_55.xy, r10.z, v_55.z); + r10.z = dpdx(r6.w); + let v_56 = dpdy(r9.yxy); + r12 = vec4(v_56.xyz, r12.w); + r12.w = dpdy(r6.w); + let v_57 = (r10.yw * r12.yw); + r8 = vec4(v_57.xy, r8.zw); + let v_58 = -(r8.xyxx); + let v_59 = fma(r10.xz, r12.xz, v_58.xy); + r13 = vec4(v_59.xy, r13.zw); + r8.x = (1.0f / r13.x); + r8.y = (r10.z * r12.y); + let v_60 = -(r8.yyyy); + r13.z = fma(r10.x, r12.w, v_60.z); + let v_61 = (r8.xx * r13.yz); + r8 = vec4(v_61.xy, r8.zw); + let v_62 = max(r8.xy, vec2()); + r8 = vec4(v_62.xy, r8.zw); + let v_63 = min(r8.xy, vec2(0.5f)); + r8 = vec4(v_63.xy, r8.zw); + r6.w = fma((-(r7.wwww)).w, r8.x, r6.w); + r6.w = fma((-(r7.wwww)).w, r8.y, r6.w); + let v_64 = bitcast(r7.z); + let v_65 = r6.w; + r11.z = select(r8.z, v_65, (v_64 != 0u)); + r9.z = 0.0f; + let v_66 = (r9.xyz + r11.ywz); + r8 = vec4(v_66.xyz, r8.w); + let v_67 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r11 = vec4(v_67.xy, r11.zw); + let v_68 = (r9.xyz + r11.xyz); + r10 = vec4(v_68.xyz, r10.w); + let v_69 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r11 = vec4(v_69.xy, r11.zw); + let v_70 = (r9.xyz + r11.xyz); + r12 = vec4(v_70.xyz, r12.w); + let v_71 = (cb6_6.tint_symbol_6[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r11 = vec4(v_71.xy, r11.zw); + let v_72 = (r9.xyz + r11.xyz); + r13 = vec4(v_72.xyz, r13.w); + let v_73 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r11 = vec4(v_73.xy, r11.zw); + let v_74 = (r9.xyz + r11.xyz); + r14 = vec4(v_74.xyz, r14.w); + let v_75 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r11 = vec4(v_75.xy, r11.zw); + let v_76 = (r9.xyz + r11.xyz); + r15 = vec4(v_76.xyz, r15.w); + let v_77 = (cb6_6.tint_symbol_6[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r11 = vec4(v_77.xy, r11.zw); + let v_78 = (r9.xyz + r11.xyz); + r16 = vec4(v_78.xyz, r16.w); + let v_79 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r11 = vec4(v_79.xy, r11.zw); + let v_80 = (r9.xyz + r11.xyz); + r17 = vec4(v_80.xyz, r17.w); + let v_81 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r11 = vec4(v_81.xy, r11.zw); + let v_82 = (r9.xyz + r11.xyz); + r18 = vec4(v_82.xyz, r18.w); + let v_83 = (cb6_6.tint_symbol_6[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r11 = vec4(v_83.xy, r11.zw); + let v_84 = (r9.xyz + r11.xyz); + r19 = vec4(v_84.xyz, r19.w); + let v_85 = (cb6_6.tint_symbol_6[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r11 = vec4(v_85.xy, r11.zw); + let v_86 = (r9.xyz + r11.xyz); + r20 = vec4(v_86.xyz, r20.w); + let v_87 = (cb6_6.tint_symbol_6[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r11 = vec4(v_87.xy, r11.zw); + let v_88 = (r9.xyz + r11.xyz); + r21 = vec4(v_88.xyz, r21.w); + let v_89 = (cb6_6.tint_symbol_6[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r11 = vec4(v_89.xy, r11.zw); + let v_90 = (r9.xyz + r11.xyz); + r22 = vec4(v_90.xyz, r22.w); + let v_91 = (cb6_6.tint_symbol_6[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r11 = vec4(v_91.xy, r11.zw); + let v_92 = (r9.xyz + r11.xyz); + r23 = vec4(v_92.xyz, r23.w); + let v_93 = (cb6_6.tint_symbol_6[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r11 = vec4(v_93.xy, r11.zw); + let v_94 = (r9.xyz + r11.xyz); + r24 = vec4(v_94.xyz, r24.w); + let v_95 = (cb6_6.tint_symbol_6[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r11 = vec4(v_95.xy, r11.zw); + let v_96 = (r9.xyz + r11.xyz); + r9 = vec4(v_96.xyz, r9.w); + let v_97 = r8.xyxx; + r8.x = textureSampleCompareLevel(t15, s15, v_97.xy, r8.z); + let v_98 = r10.xyxx; + r8.y = textureSampleCompareLevel(t15, s15, v_98.xy, r10.z); + let v_99 = r12.xyxx; + r8.z = textureSampleCompareLevel(t15, s15, v_99.xy, r12.z); + let v_100 = r13.xyxx; + r8.w = textureSampleCompareLevel(t15, s15, v_100.xy, r13.z); + let v_101 = r14.xyxx; + r10.x = textureSampleCompareLevel(t15, s15, v_101.xy, r14.z); + let v_102 = r15.xyxx; + r10.y = textureSampleCompareLevel(t15, s15, v_102.xy, r15.z); + let v_103 = r16.xyxx; + r10.z = textureSampleCompareLevel(t15, s15, v_103.xy, r16.z); + let v_104 = r17.xyxx; + r10.w = textureSampleCompareLevel(t15, s15, v_104.xy, r17.z); + let v_105 = r18.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_105.xy, r18.z); + let v_106 = r19.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_106.xy, r19.z); + let v_107 = r20.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_107.xy, r20.z); + let v_108 = r21.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_108.xy, r21.z); + let v_109 = r22.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_109.xy, r22.z); + let v_110 = r23.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_110.xy, r23.z); + let v_111 = r24.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_111.xy, r24.z); + let v_112 = r9.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_112.xy, r9.z); + r8 = (r8 + r10); + r8 = (r11 + r8); + r8 = (r12 + r8); + r6.w = dot(r8, vec4(1.0f)); + r5.w = clamp(fma(r5.wwww, cb6_6.tint_symbol_6[0u].wwww, cb6_6.tint_symbol_6[1u].wwww).w, 0.0f, 1.0f); + let v_113 = abs(r7.yyyy); + r7.x = max(v_113.x, abs(r7.xxxx).x); + r7.x = clamp(fma(r7.xxxx, vec4(15.0f), vec4(-6.30000019073486328125f)).x, 0.0f, 1.0f); + r5.w = ((-(r5.wwww)).w + 1.0f); + r5.w = (r7.x * r5.w); + r5.w = fma(r6.w, 0.0625f, r5.w); + r5.w = (r5.w * r5.w); + r5.w = min(r5.w, 1.0f); + r6.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_6[3u].xxxx, cb6_6.tint_symbol_6[3u].yyyy).w, 0.0f, 1.0f); + r6.w = sqrt(r6.w); + r6.w = (r6.w * cb6_6.tint_symbol_6[3u].z); + let v_114 = -(r5.wwww); + r5.w = fma(r6.w, v_114.w, r5.w); + let v_115 = dot(r2.yzw, v_24.xyz); + r6.w = clamp(vec4(v_115, v_115, v_115, v_115).w, 0.0f, 1.0f); + let v_116 = dot(r4.xyz, r2.yzw); + r7.x = clamp(vec4(v_116, v_116, v_116, v_116).x, 0.0f, 1.0f); + let v_117 = dot(r5.xyz, v_24.xyz); + r7.y = clamp(vec4(v_117, v_117, v_117, v_117).y, 0.0f, 1.0f); + let v_118 = ((-(r7.xyxx)).xy + vec2(1.0f)); + r7 = vec4(v_118.xy, r7.zw); + let v_119 = (r7.xy * r7.xy); + r7 = vec4(r7.xy, v_119.xy); + let v_120 = (r7.zw * r7.zw); + r7 = vec4(r7.xy, v_120.xy); + let v_121 = (r7.xy * r7.zw); + r7 = vec4(v_121.xy, r7.zw); + r7.z = ((-(cb12_12.tint_symbol_4[0u].yyyy)).z + 1.0f); + let v_122 = fma(cb12_12.tint_symbol_4[0u].yy, r7.xy, r7.zz); + r7 = vec4(v_122.xy, r7.zw); + let v_123 = (r4.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(v_123.xy, r8.zw); + r4.w = (r8.x * 0.125f); + r7.x = fma((-(r1.xxxx)).x, r7.x, 1.0f); + r5.x = dot(r2.yzw, r5.xyz); + r5.x = clamp(((r5.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r5.x = log2(r5.x); + r5.x = (r5.x * r8.y); + r5.x = exp2(r5.x); + r5.x = (r7.y * r5.x); + r5.x = (r4.w * r5.x); + r5.x = (r1.x * r5.x); + r5.x = (r6.w * r5.x); + r5.y = (r6.w * r7.x); + let v_124 = fma(r0.xyz, r5.yyy, r5.xxx); + r5 = vec4(v_124.xyz, r5.w); + let v_125 = (r5.xyz * cb3_3.tint_symbol_2[1u].xyz); + r5 = vec4(v_125.xyz, r5.w); + r6.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r9 = vec4(vec3(), r9.w); + r8 = vec4(0.0f, r8.y, vec2()); + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_126 = ((-(v6.xxyz)).xzw + cb3_3.tint_symbol_2[3u].xyz); + r8 = vec4(v_126.x, r8.y, v_126.yz); + let v_127 = (v6.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r9 = vec4(v_127.xyz, r9.w); + r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w); + let v_128 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_128.xyz, r9.w); + let v_129 = (r9.xyz + v_21.xyz); + r9 = vec4(v_129.xyz, r9.w); + let v_130 = bitcast>(r7.yyy); + let v_131 = r8.xzw; + let v_132 = select(r9.xyz, v_131, (v_130 != vec3())); + r8 = vec4(v_132.x, r8.y, v_132.yz); + r7.y = dot(r8.xzw, r8.xzw); + let v_133 = (r8.xzw + vec3(0.00000099999999747524f)); + r8 = vec4(v_133.x, r8.y, v_133.yz); + r7.w = dot(r8.xzw, r8.xzw); + r7.w = inverseSqrt(r7.w); + let v_134 = (r7.www * r8.xzw); + r8 = vec4(v_134.x, r8.y, v_134.yz); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[11u].w); + r7.y = (r7.y / r7.w); + let v_135 = -(cb3_3.tint_symbol_2[11u].xyzx); + r7.w = dot(r8.xzw, v_135.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_136 = dot(r8.xzw, r2.yzw); + r9.x = clamp(vec4(v_136, v_136, v_136, v_136).x, 0.0f, 1.0f); + r7.w = (r7.w * r9.x); + r9.x = (r7.y * r7.w); + let v_137 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_137.xyz, r9.w); + let v_138 = (r0.xyz * r9.xyz); + r9 = vec4(v_138.xyz, r9.w); + let v_139 = fma(r3.xyz, r3.www, r8.xzw); + r8 = vec4(v_139.x, r8.y, v_139.yz); + r9.w = dot(r8.xzw, r8.xzw); + r9.w = inverseSqrt(r9.w); + let v_140 = (r8.xzw * r9.www); + r8 = vec4(v_140.x, r8.y, v_140.yz); + let v_141 = dot(r8.xzw, r4.xyz); + r9.w = clamp(vec4(v_141, v_141, v_141, v_141).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.x = (r9.w * r9.w); + r10.x = (r10.x * r10.x); + r9.w = (r9.w * r10.x); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_142 = dot(r8.xzw, r2.yzw); + r8.x = clamp(vec4(v_142, v_142, v_142, v_142).x, 0.0f, 1.0f); + r8.x = log2(r8.x); + r8.x = (r8.x * r8.y); + r8.x = exp2(r8.x); + r8.x = (r8.x * r9.w); + r7.w = (r7.w * r8.x); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_143 = (r7.yyy * cb3_3.tint_symbol_2[19u].xyz); + r8 = vec4(v_143.x, r8.y, v_143.yz); + } + r7.y = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r7.y) != 0u)) { + r7.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r7.y = bitcast((bitcast(r6.w) | bitcast(r7.y))); + let v_144 = bitcast(r7.w); + let v_145 = r7.y; + r6.w = select(r6.w, v_145, (v_144 != 0u)); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_146 = (v_21.xyz + cb3_3.tint_symbol_2[4u].xyz); + r10 = vec4(v_146.xyz, r10.w); + let v_147 = (v6.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r11 = vec4(v_147.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w); + let v_148 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_148.xyz, r11.w); + let v_149 = (r11.xyz + v_21.xyz); + r11 = vec4(v_149.xyz, r11.w); + let v_150 = bitcast>(r7.yyy); + let v_151 = r10.xyz; + let v_152 = select(r11.xyz, v_151, (v_150 != vec3())); + r10 = vec4(v_152.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_153 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_153.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_154 = (r7.www * r10.xyz); + r10 = vec4(v_154.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[12u].w); + r7.y = (r7.y / r7.w); + let v_155 = -(cb3_3.tint_symbol_2[12u].xyzx); + r7.w = dot(r10.xyz, v_155.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_156 = dot(r10.xyz, r2.yzw); + r9.w = clamp(vec4(v_156, v_156, v_156, v_156).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r7.y * r7.w); + let v_157 = (r9.www * cb3_3.tint_symbol_2[20u].xyz); + r11 = vec4(v_157.xyz, r11.w); + let v_158 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_158.xyz, r9.w); + let v_159 = fma(r3.xyz, r3.www, r10.xyz); + r10 = vec4(v_159.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_160 = (r9.www * r10.xyz); + r10 = vec4(v_160.xyz, r10.w); + let v_161 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_161, v_161, v_161, v_161).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_162 = dot(r10.xyz, r2.yzw); + r10.x = clamp(vec4(v_162, v_162, v_162, v_162).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_163 = fma(r7.yyy, cb3_3.tint_symbol_2[20u].xyz, r8.xzw); + r8 = vec4(v_163.x, r8.y, v_163.yz); + } + } else { + r6.w = bitcast(v.tint_symbol_7[3i].x); + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_7[3i].x); + } else { + r7.y = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_164 = (v_21.xyz + cb3_3.tint_symbol_2[5u].xyz); + r10 = vec4(v_164.xyz, r10.w); + let v_165 = (v6.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r11 = vec4(v_165.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w); + let v_166 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_166.xyz, r11.w); + let v_167 = (r11.xyz + v_21.xyz); + r11 = vec4(v_167.xyz, r11.w); + let v_168 = bitcast>(r7.yyy); + let v_169 = r10.xyz; + let v_170 = select(r11.xyz, v_169, (v_168 != vec3())); + r10 = vec4(v_170.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_171 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_171.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_172 = (r7.www * r10.xyz); + r10 = vec4(v_172.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[13u].w); + r7.y = (r7.y / r7.w); + let v_173 = -(cb3_3.tint_symbol_2[13u].xyzx); + r7.w = dot(r10.xyz, v_173.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_174 = dot(r10.xyz, r2.yzw); + r9.w = clamp(vec4(v_174, v_174, v_174, v_174).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r7.y * r7.w); + let v_175 = (r9.www * cb3_3.tint_symbol_2[21u].xyz); + r11 = vec4(v_175.xyz, r11.w); + let v_176 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_176.xyz, r9.w); + let v_177 = fma(r3.xyz, r3.www, r10.xyz); + r10 = vec4(v_177.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_178 = (r9.www * r10.xyz); + r10 = vec4(v_178.xyz, r10.w); + let v_179 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_179, v_179, v_179, v_179).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_180 = dot(r10.xyz, r2.yzw); + r10.x = clamp(vec4(v_180, v_180, v_180, v_180).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_181 = fma(r7.yyy, cb3_3.tint_symbol_2[21u].xyz, r8.xzw); + r8 = vec4(v_181.x, r8.y, v_181.yz); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_7[3i].x); + } else { + r7.y = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_182 = (v_21.xyz + cb3_3.tint_symbol_2[6u].xyz); + r10 = vec4(v_182.xyz, r10.w); + let v_183 = (v6.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r11 = vec4(v_183.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[22u].w); + let v_184 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.www, cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_184.xyz, r11.w); + let v_185 = (r11.xyz + v_21.xyz); + r11 = vec4(v_185.xyz, r11.w); + let v_186 = bitcast>(r7.yyy); + let v_187 = r10.xyz; + let v_188 = select(r11.xyz, v_187, (v_186 != vec3())); + r10 = vec4(v_188.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_189 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_189.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_190 = (r7.www * r10.xyz); + r10 = vec4(v_190.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[14u].w); + r7.y = (r7.y / r7.w); + let v_191 = -(cb3_3.tint_symbol_2[14u].xyzx); + r7.w = dot(r10.xyz, v_191.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_192 = dot(r10.xyz, r2.yzw); + r9.w = clamp(vec4(v_192, v_192, v_192, v_192).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r7.y * r7.w); + let v_193 = (r9.www * cb3_3.tint_symbol_2[22u].xyz); + r11 = vec4(v_193.xyz, r11.w); + let v_194 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_194.xyz, r9.w); + let v_195 = fma(r3.xyz, r3.www, r10.xyz); + r10 = vec4(v_195.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_196 = (r9.www * r10.xyz); + r10 = vec4(v_196.xyz, r10.w); + let v_197 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_197, v_197, v_197, v_197).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_198 = dot(r10.xyz, r2.yzw); + r10.x = clamp(vec4(v_198, v_198, v_198, v_198).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_199 = fma(r7.yyy, cb3_3.tint_symbol_2[22u].xyz, r8.xzw); + r8 = vec4(v_199.x, r8.y, v_199.yz); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_7[3i].x); + } else { + r7.y = bitcast(select(0u, 4294967295u, (4i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f))); + let v_200 = (v_21.xyz + cb3_3.tint_symbol_2[7u].xyz); + r10 = vec4(v_200.xyz, r10.w); + let v_201 = (v6.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz); + r11 = vec4(v_201.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[15u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[23u].w); + let v_202 = fma(cb3_3.tint_symbol_2[15u].xyz, r7.www, cb3_3.tint_symbol_2[7u].xyz); + r11 = vec4(v_202.xyz, r11.w); + let v_203 = (r11.xyz + v_21.xyz); + r11 = vec4(v_203.xyz, r11.w); + let v_204 = bitcast>(r7.yyy); + let v_205 = r10.xyz; + let v_206 = select(r11.xyz, v_205, (v_204 != vec3())); + r10 = vec4(v_206.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_207 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_207.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_208 = (r7.www * r10.xyz); + r10 = vec4(v_208.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[7u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[15u].w); + r7.y = (r7.y / r7.w); + let v_209 = -(cb3_3.tint_symbol_2[15u].xyzx); + r7.w = dot(r10.xyz, v_209.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f); + let v_210 = dot(r10.xyz, r2.yzw); + r9.w = clamp(vec4(v_210, v_210, v_210, v_210).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r7.y * r7.w); + let v_211 = (r9.www * cb3_3.tint_symbol_2[23u].xyz); + r11 = vec4(v_211.xyz, r11.w); + let v_212 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_212.xyz, r9.w); + let v_213 = fma(r3.xyz, r3.www, r10.xyz); + r10 = vec4(v_213.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_214 = (r9.www * r10.xyz); + r10 = vec4(v_214.xyz, r10.w); + let v_215 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_215, v_215, v_215, v_215).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_216 = dot(r10.xyz, r2.yzw); + r10.x = clamp(vec4(v_216, v_216, v_216, v_216).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_217 = fma(r7.yyy, cb3_3.tint_symbol_2[23u].xyz, r8.xzw); + r8 = vec4(v_217.x, r8.y, v_217.yz); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_7[3i].x); + } else { + r7.y = bitcast(select(0u, 4294967295u, (5i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f))); + let v_218 = (v_21.xyz + cb3_3.tint_symbol_2[8u].xyz); + r10 = vec4(v_218.xyz, r10.w); + let v_219 = (v6.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz); + r11 = vec4(v_219.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[16u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[24u].w); + let v_220 = fma(cb3_3.tint_symbol_2[16u].xyz, r7.www, cb3_3.tint_symbol_2[8u].xyz); + r11 = vec4(v_220.xyz, r11.w); + let v_221 = (r11.xyz + v_21.xyz); + r11 = vec4(v_221.xyz, r11.w); + let v_222 = bitcast>(r7.yyy); + let v_223 = r10.xyz; + let v_224 = select(r11.xyz, v_223, (v_222 != vec3())); + r10 = vec4(v_224.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_225 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_225.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_226 = (r7.www * r10.xyz); + r10 = vec4(v_226.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[8u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[16u].w); + r7.y = (r7.y / r7.w); + let v_227 = -(cb3_3.tint_symbol_2[16u].xyzx); + r7.w = dot(r10.xyz, v_227.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f); + let v_228 = dot(r10.xyz, r2.yzw); + r9.w = clamp(vec4(v_228, v_228, v_228, v_228).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r7.y * r7.w); + let v_229 = (r9.www * cb3_3.tint_symbol_2[24u].xyz); + r11 = vec4(v_229.xyz, r11.w); + let v_230 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_230.xyz, r9.w); + let v_231 = fma(r3.xyz, r3.www, r10.xyz); + r10 = vec4(v_231.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_232 = (r9.www * r10.xyz); + r10 = vec4(v_232.xyz, r10.w); + let v_233 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_233, v_233, v_233, v_233).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_234 = dot(r10.xyz, r2.yzw); + r10.x = clamp(vec4(v_234, v_234, v_234, v_234).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_235 = fma(r7.yyy, cb3_3.tint_symbol_2[24u].xyz, r8.xzw); + r8 = vec4(v_235.x, r8.y, v_235.yz); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_7[3i].x); + } else { + r7.y = bitcast(select(0u, 4294967295u, (6i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f))); + let v_236 = (v_21.xyz + cb3_3.tint_symbol_2[9u].xyz); + r10 = vec4(v_236.xyz, r10.w); + let v_237 = (v6.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz); + r11 = vec4(v_237.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[17u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[25u].w); + let v_238 = fma(cb3_3.tint_symbol_2[17u].xyz, r7.www, cb3_3.tint_symbol_2[9u].xyz); + r11 = vec4(v_238.xyz, r11.w); + let v_239 = (r11.xyz + v_21.xyz); + r11 = vec4(v_239.xyz, r11.w); + let v_240 = bitcast>(r7.yyy); + let v_241 = r10.xyz; + let v_242 = select(r11.xyz, v_241, (v_240 != vec3())); + r10 = vec4(v_242.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + let v_243 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_243.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_244 = (r7.www * r10.xyz); + r10 = vec4(v_244.xyz, r10.w); + r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[9u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[17u].w); + r7.y = (r7.y / r7.w); + let v_245 = -(cb3_3.tint_symbol_2[17u].xyzx); + r7.w = dot(r10.xyz, v_245.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f); + let v_246 = dot(r10.xyz, r2.yzw); + r9.w = clamp(vec4(v_246, v_246, v_246, v_246).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r7.y * r7.w); + let v_247 = (r9.www * cb3_3.tint_symbol_2[25u].xyz); + r11 = vec4(v_247.xyz, r11.w); + let v_248 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_248.xyz, r9.w); + let v_249 = fma(r3.xyz, r3.www, r10.xyz); + r10 = vec4(v_249.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_250 = (r9.www * r10.xyz); + r10 = vec4(v_250.xyz, r10.w); + let v_251 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_251, v_251, v_251, v_251).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z); + let v_252 = dot(r10.xyz, r2.yzw); + r10.x = clamp(vec4(v_252, v_252, v_252, v_252).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r7.y = (r7.y * r7.w); + r7.y = (r4.w * r7.y); + let v_253 = fma(r7.yyy, cb3_3.tint_symbol_2[25u].xyz, r8.xzw); + r8 = vec4(v_253.x, r8.y, v_253.yz); + } + } + if ((bitcast(r6.w) != 0u)) { + } else { + r7.y = bitcast(select(0u, 4294967295u, (7i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r7.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f))); + let v_254 = (v_21.xyz + cb3_3.tint_symbol_2[10u].xyz); + r10 = vec4(v_254.xyz, r10.w); + let v_255 = (v6.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz); + r11 = vec4(v_255.xyz, r11.w); + r7.y = dot(r11.xyz, cb3_3.tint_symbol_2[18u].xyz); + r7.y = clamp(((r7.yyyy / cb3_3.tint_symbol_2[26u].wwww)).y, 0.0f, 1.0f); + r7.y = (r7.y * cb3_3.tint_symbol_2[26u].w); + let v_256 = fma(cb3_3.tint_symbol_2[18u].xyz, r7.yyy, cb3_3.tint_symbol_2[10u].xyz); + r11 = vec4(v_256.xyz, r11.w); + let v_257 = (r11.xyz + v_21.xyz); + r11 = vec4(v_257.xyz, r11.w); + let v_258 = bitcast>(r6.www); + let v_259 = r10.xyz; + let v_260 = select(r11.xyz, v_259, (v_258 != vec3())); + r10 = vec4(v_260.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_261 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_261.xyz, r10.w); + r7.y = dot(r10.xyz, r10.xyz); + r7.y = inverseSqrt(r7.y); + let v_262 = (r7.yyy * r10.xyz); + r10 = vec4(v_262.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.y = ((-(cb3_3.tint_symbol_2[18u].wwww)).y + 1.0f); + r7.y = fma(r7.y, r6.w, cb3_3.tint_symbol_2[18u].w); + r6.w = (r6.w / r7.y); + let v_263 = -(cb3_3.tint_symbol_2[18u].xyzx); + r7.y = dot(r10.xyz, v_263.xyz); + r7.y = clamp(fma(r7.yyyy, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).y, 0.0f, 1.0f); + let v_264 = dot(r10.xyz, r2.yzw); + r7.w = clamp(vec4(v_264, v_264, v_264, v_264).w, 0.0f, 1.0f); + r7.y = (r7.y * r7.w); + r7.w = (r6.w * r7.y); + let v_265 = (r7.www * cb3_3.tint_symbol_2[26u].xyz); + r11 = vec4(v_265.xyz, r11.w); + let v_266 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_266.xyz, r9.w); + let v_267 = fma(r3.xyz, r3.www, r10.xyz); + r3 = vec4(v_267.xyz, r3.w); + r3.w = dot(r3.xyz, r3.xyz); + r3.w = inverseSqrt(r3.w); + let v_268 = (r3.www * r3.xyz); + r3 = vec4(v_268.xyz, r3.w); + let v_269 = dot(r3.xyz, r4.xyz); + r3.w = clamp(vec4(v_269, v_269, v_269, v_269).w, 0.0f, 1.0f); + r3.w = ((-(r3.wwww)).w + 1.0f); + r4.x = (r3.w * r3.w); + r4.x = (r4.x * r4.x); + r3.w = (r3.w * r4.x); + r3.w = fma(cb12_12.tint_symbol_4[0u].y, r3.w, r7.z); + let v_270 = dot(r3.xyz, r2.yzw); + r3.x = clamp(vec4(v_270, v_270, v_270, v_270).x, 0.0f, 1.0f); + r3.x = log2(r3.x); + r3.x = (r3.x * r8.y); + r3.x = exp2(r3.x); + r3.x = (r3.x * r3.w); + r3.x = (r7.y * r3.x); + r3.x = (r6.w * r3.x); + r3.x = (r4.w * r3.x); + let v_271 = fma(r3.xxx, cb3_3.tint_symbol_2[26u].xyz, r8.xzw); + r8 = vec4(v_271.x, r8.y, v_271.yz); + } + } + r3.x = (r7.x * r7.x); + r1.x = (r1.x * r1.x); + let v_272 = (r8.xzw * r1.xxx); + r3 = vec4(r3.x, v_272.xyz); + let v_273 = fma(r3.xxx, r9.xyz, r3.yzw); + r3 = vec4(v_273.xyz, r3.w); + let v_274 = fma(r5.xyz, r5.www, r3.xyz); + r3 = vec4(v_274.xyz, r3.w); + r1.x = fma(r1.w, r2.x, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_275 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r4 = vec4(v_275.xyz, r4.w); + r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_276 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r5 = vec4(v_276.xyz, r5.w); + let v_277 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz); + r5 = vec4(v_277.xyz, r5.w); + let v_278 = fma(r4.xyz, r1.www, r5.xyz); + r4 = vec4(v_278.xyz, r4.w); + let v_279 = (r1.zzz * r4.xyz); + r4 = vec4(v_279.xyz, r4.w); + let v_280 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r1 = vec4(v_280.x, r1.y, v_280.yz); + r5.x = cb3_3.tint_symbol_2[46u].w; + r5.y = cb3_3.tint_symbol_2[47u].w; + r5.z = cb3_3.tint_symbol_2[48u].w; + let v_281 = dot(r5.xyz, r2.yzw); + r2.x = clamp(vec4(v_281, v_281, v_281, v_281).x, 0.0f, 1.0f); + let v_282 = fma(cb3_3.tint_symbol_2[49u].xyz, r2.xxx, r1.xzw); + r1 = vec4(v_282.x, r1.y, v_282.yz); + let v_283 = fma(r1.xzw, r1.yyy, r4.xyz); + r1 = vec4(v_283.xyz, r1.w); + let v_284 = (r7.xxx * r1.xyz); + r1 = vec4(v_284.xyz, r1.w); + let v_285 = fma(r1.xyz, r0.xyz, r3.xyz); + r0 = vec4(v_285.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r6.xyz, r6.xyz); + r1.x = sqrt(r0.w); + let v_286 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_286.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r6.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_287 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_287 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_288 = (r0.www * r6.xyz); + r2 = vec4(v_288.xyz, r2.w); + let v_289 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_289, v_289, v_289, v_289).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_290 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_290, v_290, v_290, v_290).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_291 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_291.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_292 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_292.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_293 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_293.xyz, r2.w); + let v_294 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_294.xyz, r2.w); + let v_295 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_295.xyz, r3.w); + let v_296 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_296.xyz, r2.w); + let v_297 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_298 = (r2.xyz + v_297.xyz); + r2 = vec4(v_298.xyz, r2.w); + let v_299 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_299.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_300 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_300.xyz, r3.w); + let v_301 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_301.xy, r1.z, v_301.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_302 = (v7.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_302.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_303 = -(r0.xyxz); + let v_304 = fma(r1.xyw, r0.www, v_303.xyw); + r1 = vec4(v_304.xy, r1.z, v_304.z); + let v_305 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_305.xyz, r1.w); + } else { + r0.w = dot(r6.xyz, r6.xyz); + r1.w = sqrt(r0.w); + let v_306 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_306.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r6.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_307 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_307 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_308 = (r0.www * r6.xyz); + r3 = vec4(v_308.xyz, r3.w); + let v_309 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_309, v_309, v_309, v_309).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_310 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_310, v_310, v_310, v_310).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_311 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_311.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_312 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_312.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_313 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_313.xyz, r3.w); + let v_314 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_314.xyz, r3.w); + let v_315 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_315.xyz, r4.w); + let v_316 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_316.xyz, r3.w); + let v_317 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_318 = (r3.xyz + v_317.xyz); + r3 = vec4(v_318.xyz, r3.w); + let v_319 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_319.x, r2.y, v_319.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_320 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_320.xyz, r3.w); + let v_321 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_321.x, r2.y, v_321.yz); + let v_322 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_322.x, r2.y, v_322.yz); + let v_323 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_323.xyz, r1.w); + } + let v_324 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_324.xyz, o0.w); +} + +fn v_3(v_325 : bool) { + if (v_325) { + discard; + return; + } +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @builtin(position) v_326 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v_326); + return o0; +} diff --git a/b/8b0b5899ed/shaders/011f3f3fcac784b6.consts.json b/b/8b0b5899ed/shaders/011f3f3fcac784b6.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..bace2a0be1726eefc636c304f3af9621039df6fa --- /dev/null +++ b/b/8b0b5899ed/shaders/011f3f3fcac784b6.consts.json @@ -0,0 +1 @@ +[1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/011f3f3fcac784b6.wgsl b/b/8b0b5899ed/shaders/011f3f3fcac784b6.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..08a0df1425a21dfd8146dc04490cfc1112ec24ea --- /dev/null +++ b/b/8b0b5899ed/shaders/011f3f3fcac784b6.wgsl @@ -0,0 +1,428 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb19_struct { + tint_symbol_1 : array, 19u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb19_struct; + +struct cb92_struct { + tint_symbol_2 : array, 92u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb92_struct; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(21u) var s5 : sampler; + +@group(1u) @binding(23u) var s7 : sampler; + +@group(1u) @binding(25u) var s9 : sampler; + +@group(1u) @binding(26u) var s10 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(28u) var s12 : sampler; + +@group(1u) @binding(31u) var s15 : sampler; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(36u) var t4 : texture_2d; + +@group(1u) @binding(37u) var t5 : texture_2d; + +@group(1u) @binding(39u) var t7 : texture_2d; + +@group(1u) @binding(40u) var t8 : texture_2d; + +@group(1u) @binding(41u) var t9 : texture_2d; + +@group(1u) @binding(42u) var t10 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(44u) var t12 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_2d; + +var o0 : vec4; + +struct tint_symbol_4 { + tint_symbol_3 : array, 1u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_4; + +fn main_inner(v1 : vec4, v2 : vec4) { + r0 = textureSample(t3, s3, v1.xyxx.xy); + r0.x = ((-(r0.xxxx)).x + cb5_5.tint_symbol_2[0u].w); + r0.x = (r0.x + 1.0f); + r0.x = (cb5_5.tint_symbol_2[0u].z / r0.x); + r1 = textureSample(t5, s5, v1.xyxx.xy); + let v_1 = (r1.xyz * cb2_2.tint_symbol_1[17u].www); + r0 = vec4(r0.x, v_1.xyz); + r1.x = bitcast(select(0u, 4294967295u, (0.0f < cb5_5.tint_symbol_2[91u].w))); + if ((bitcast(r1.x) != 0u)) { + } else { + r1 = fma(cb5_5.tint_symbol_2[72u].xyxy, vec4(-1.0f, -0.5f, 0.5f, -1.0f), v1.xyxy); + r2 = textureSample(t4, s4, r1.xyxx.xy); + r3 = textureSample(t4, s4, r1.zwzz.xy); + r4 = fma(cb5_5.tint_symbol_2[72u].xyxy, vec4(-0.5f, 1.0f, 1.0f, 0.5f), v1.xyxy); + r5 = textureSample(t4, s4, r4.xyxx.xy); + r6 = textureSample(t4, s4, r4.zwzz.xy); + r7 = textureSample(t4, s4, v1.xyxx.xy); + let v_2 = (r2.xyz + r3.xyz); + r2 = vec4(v_2.xyz, r2.w); + let v_3 = (r5.xyz + r2.xyz); + r2 = vec4(v_3.xyz, r2.w); + let v_4 = (r6.xyz + r2.xyz); + r2 = vec4(v_4.xyz, r2.w); + let v_5 = (r7.xyz * vec3(0.5f)); + r3 = vec4(v_5.xyz, r3.w); + let v_6 = fma(r7.xyz, vec3(0.5f), r2.xyz); + r2 = vec4(v_6.xyz, r2.w); + r5 = textureSample(t9, s9, r1.xyxx.xy); + r1 = textureSample(t9, s9, r1.zwzz.xy); + r6 = textureSample(t9, s9, r4.xyxx.xy); + r4 = textureSample(t9, s9, r4.zwzz.xy); + r7 = textureSample(t9, s9, v1.xyxx.xy); + let v_7 = (r1.xyz + r5.xyz); + r1 = vec4(v_7.xyz, r1.w); + let v_8 = (r6.xyz + r1.xyz); + r1 = vec4(v_8.xyz, r1.w); + let v_9 = (r4.xyz + r1.xyz); + r1 = vec4(v_9.xyz, r1.w); + let v_10 = fma(r7.xyz, vec3(0.5f), r1.xyz); + r1 = vec4(v_10.xyz, r1.w); + let v_11 = fma(r7.xyz, vec3(0.5f), r3.xyz); + r3 = vec4(v_11.xyz, r3.w); + let v_12 = (r2.xyz * vec3(0.11111111193895339966f)); + r2 = vec4(v_12.xyz, r2.w); + let v_13 = fma(r1.xyz, vec3(0.11111111193895339966f), r2.xyz); + r1 = vec4(v_13.xyz, r1.w); + r1.w = bitcast(select(0u, 4294967295u, !((cb5_5.tint_symbol_2[4u].x == 0.0f)))); + let v_14 = bitcast>(r1.www); + let v_15 = r7.xyz; + let v_16 = select(r3.xyz, v_15, (v_14 != vec3())); + r2 = vec4(v_16.xyz, r2.w); + let v_17 = bitcast>(r1.www); + let v_18 = r7.xyz; + let v_19 = select(r1.xyz, v_18, (v_17 != vec3())); + r1 = vec4(v_19.xyz, r1.w); + let v_20 = -(cb5_5.tint_symbol_2[3u].xzxx); + let v_21 = (r0.xx + v_20.xy); + r3 = vec4(v_21.xy, r3.zw); + r4.x = (r3.y * cb5_5.tint_symbol_2[3u].w); + r1.w = clamp(fma(-(r3.xxxx), cb5_5.tint_symbol_2[3u].yyyy, vec4(1.0f)).w, 0.0f, 1.0f); + r4.x = clamp(r4.xxxx.x, 0.0f, 1.0f); + r1.w = max(r1.w, r4.x); + let v_22 = clamp(fma(r1.wwww, vec4(-2.00400805473327636719f, -2.00400805473327636719f, -1000.0f, 0.0f), vec4(1.0f, 2.00200390815734863281f, 1000.0f, 0.0f)).xyz, vec3(), vec3(1.0f)); + r3 = vec4(v_22.xyz, r3.w); + r1.w = ((-(r3.xxxx)).w + 1.0f); + r1.w = min(r1.w, r3.y); + r2.w = (r1.w + r3.x); + r3.y = ((-(r2.wwww)).y + 1.0f); + r3.y = min(r3.y, r3.z); + r2.w = (r2.w + r3.y); + r2.w = ((-(r2.wwww)).w + 1.0f); + let v_23 = (r1.www * r7.xyz); + r4 = vec4(v_23.xyz, r4.w); + let v_24 = fma(r0.yzw, r3.xxx, r4.xyz); + r3 = vec4(v_24.x, r3.y, v_24.yz); + let v_25 = fma(r2.xyz, r3.yyy, r3.xzw); + r2 = vec4(v_25.xyz, r2.w); + let v_26 = fma(r1.xyz, r2.www, r2.xyz); + r0 = vec4(r0.x, v_26.xyz); + } + if ((bitcast(cb5_5.tint_symbol_2[90u].z) != 0u)) { + r1 = textureSample(t11, s11, v1.xyxx.xy); + let v_27 = ((-(r0.yzwy)).xyz + r1.xyz); + r1 = vec4(v_27.xyz, r1.w); + let v_28 = fma(r1.www, r1.xyz, r0.yzw); + r0 = vec4(r0.x, v_28.xyz); + } + let v_29 = (v1.xy * cb2_2.tint_symbol_1[18u].xy); + r1 = vec4(v_29.xy, r1.zw); + let v_30 = r1.xy; + let v_31 = max(v_30, vec2(-2147483648.0f)); + let v_32 = bitcast>(select(select(vec2(v_31), vec2(2147483647i), (v_31 >= vec2(2147483648.0f))), vec2(), !((v_30 == v_30)))); + r1 = vec4(v_32.xy, r1.zw); + r1 = vec4(r1.xy, vec2()); + r1 = bitcast>(textureLoad(t8, bitcast>(r1.xy), bitcast(r1.w))); + r1.x = f32(bitcast(r1.y)); + r1.x = (r1.x * 0.0039215688593685627f); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_2[56u].x < r1.x))); + r1.x = select(1.0f, 0.0f, (bitcast(r1.x) != 0u)); + let v_33 = r1; + r1 = vec4(v_33.x, ((v1.xy * vec2(58.16400146484375f, 47.130001068115234375f))).xy, v_33.w); + let v_34 = fma(v1.xy, vec2(2.0f, -2.0f), vec2(-1.0f, 1.0f)); + r2 = vec4(v_34.xy, r2.zw); + let v_35 = fma(v1.xy, vec2(2.0f, -2.0f), vec2(-1.0f, 1.0f)); + r3 = vec4(v_35.xy, r3.zw); + r3 = vec4(r3.xy, vec2(1.0f)); + r4.x = dot(r3.xyz, cb5_5.tint_symbol_2[21u].xyz); + r4.y = dot(r3.xyz, cb5_5.tint_symbol_2[22u].xyz); + r4.z = dot(r3.xyz, cb5_5.tint_symbol_2[23u].xyz); + let v_36 = fma(r4.xyz, r0.xxx, cb1_1.tint_symbol[15u].xyz); + r3 = vec4(v_36.xyz, r3.w); + r4.x = dot(r3, cb5_5.tint_symbol_2[18u]); + r4.y = dot(r3, cb5_5.tint_symbol_2[19u]); + r0.x = dot(r3, cb5_5.tint_symbol_2[20u]); + r1.w = bitcast(select(0u, 4294967295u, (r0.x == 0.0f))); + let v_37 = bitcast(r1.w); + r0.x = select(r0.x, 0.00000999999974737875f, (v_37 != 0u)); + let v_38 = (r4.xy / r0.xx); + r2 = vec4(r2.xy, v_38.xy); + let v_39 = ((-(r2.zwzz)).xy + r2.xy); + r2 = vec4(v_39.xy, r2.zw); + let v_40 = (r2.xy * vec2(40.0f, -22.5f)); + r2 = vec4(v_40.xy, r2.zw); + r0.x = dot(r2.xy, r2.xy); + r1.w = bitcast(select(0u, 4294967295u, (1.0f < r0.x))); + r0.x = inverseSqrt(r0.x); + let v_41 = (r0.xx * r2.xy); + r2 = vec4(r2.xy, v_41.xy); + let v_42 = bitcast>(r1.ww); + let v_43 = r2.zw; + let v_44 = select(r2.xy, v_43, (v_42 != vec2())); + r2 = vec4(v_44.xy, r2.zw); + let v_45 = (r2.xy * cb5_5.tint_symbol_2[16u].xx); + r2 = vec4(v_45.xy, r2.zw); + let v_46 = (r2.xy * vec2(0.01250000018626451492f, 0.02222222276031970978f)); + r2 = vec4(v_46.xy, r2.zw); + let v_47 = (r0.yzw * r1.xxx); + r3 = vec4(v_47.xyz, r3.w); + let v_48 = (r2.xy * cb5_5.tint_symbol_2[17u].yy); + r2 = vec4(r2.xy, v_48.xy); + let v_49 = fma(r0.yz, vec2(8.0f), r1.yz); + let v_50 = r1; + r1 = vec4(v_50.x, v_49.xy, v_50.w); + r4 = textureSample(t12, s12, r1.yzyy.xy); + r0.x = (r4.x + -0.5f); + let v_51 = (r0.xx * r2.zw); + let v_52 = r1; + r1 = vec4(v_52.x, v_51.xy, v_52.w); + let v_53 = fma(r1.yz, vec2(0.5f), v1.xy); + let v_54 = r1; + r1 = vec4(v_54.x, v_53.xy, v_54.w); + let v_55 = cb5_5.tint_symbol_2[17u].x; + let v_56 = max(v_55, -2147483648.0f); + r0.x = bitcast(select(select(i32(v_56), 2147483647i, (v_56 >= 2147483648.0f)), 0i, !((v_55 == v_55)))); + r4 = vec4(r4.xy, vec2()); + let v_57 = r3; + r5 = vec4(v_57.xyz, r5.w); + r1.w = r1.x; + r3.w = bitcast(v.tint_symbol_3[0i].x); + loop { + r5.w = bitcast(select(0u, 4294967295u, (bitcast(r3.w) >= bitcast(r0.x)))); + if ((bitcast(r5.w) != 0u)) { + break; + } + r5.w = f32(bitcast(r3.w)); + let v_58 = fma(r2.zw, r5.ww, r1.yz); + r6 = vec4(v_58.xy, r6.zw); + let v_59 = (r6.xy * cb2_2.tint_symbol_1[18u].xy); + r6 = vec4(v_59.xy, r6.zw); + let v_60 = round(r6.xy); + r6 = vec4(v_60.xy, r6.zw); + let v_61 = (r6.xy + vec2(0.5f)); + r6 = vec4(v_61.xy, r6.zw); + let v_62 = (r6.xy / cb2_2.tint_symbol_1[18u].xy); + r6 = vec4(r6.xy, v_62.xy); + let v_63 = r6.xy; + let v_64 = max(v_63, vec2(-2147483648.0f)); + let v_65 = bitcast>(select(select(vec2(v_64), vec2(2147483647i), (v_64 >= vec2(2147483648.0f))), vec2(), !((v_63 == v_63)))); + r4 = vec4(v_65.xy, r4.zw); + r7 = bitcast>(textureLoad(t8, bitcast>(r4.xy), bitcast(r4.w))); + r4.x = f32(bitcast(r7.y)); + r4.x = (r4.x * 0.0039215688593685627f); + r4.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_2[56u].x < r4.x))); + r4.x = select(1.0f, 0.0f, (bitcast(r4.x) != 0u)); + r6 = textureSampleLevel(t9, s9, r6.zwzz.xy, 0.0f); + let v_66 = fma(r6.xyz, r4.xxx, r5.xyz); + r5 = vec4(v_66.xyz, r5.w); + r1.w = (r1.w + r4.x); + r3.w = bitcast((bitcast(r3.w) + 1i)); + } + r0.x = max(r1.w, 0.10000000149011611938f); + let v_67 = (r5.xyz / r0.xxx); + r1 = vec4(r1.x, v_67.xyz); + r0.x = dot(r2.xy, r2.xy); + r0.x = (r0.x * 100000.0f); + r0.x = min(r0.x, 1.0f); + r0.x = (r0.x * r1.x); + let v_68 = ((-(r0.yzwy)).xyz + r1.yzw); + r1 = vec4(v_68.xyz, r1.w); + let v_69 = fma(r0.xxx, r1.xyz, r0.yzw); + r0 = vec4(v_69.xyz, r0.w); + r1 = textureSample(t10, s10, v1.xyxx.xy); + let v_70 = (r1.xyz * v1.www); + r1 = vec4(v_70.xyz, r1.w); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb5_5.tint_symbol_2[75u].z))); + if ((bitcast(r0.w) != 0u)) { + r2 = textureSample(t15, s15, v1.xyxx.xy); + r0.w = (r2.x * r2.x); + r0.w = (r0.w * r0.w); + r0.w = (r0.w * r0.w); + let v_71 = fma(cb5_5.tint_symbol_2[46u].xyz, r0.www, r0.xyz); + r0 = vec4(v_71.xyz, r0.w); + } + let v_72 = min(r0.xyz, vec3(65504.0f)); + r0 = vec4(v_72.xyz, r0.w); + let v_73 = v2.x; + r0.w = clamp(fma(vec4(v_73, v_73, v_73, v_73), cb5_5.tint_symbol_2[14u].xxxx, cb5_5.tint_symbol_2[14u].yyyy).w, 0.0f, 1.0f); + r2 = (-(cb5_5.tint_symbol_2[10u]) + cb5_5.tint_symbol_2[12u]); + r2 = fma(r0.wwww, r2, cb5_5.tint_symbol_2[10u]); + let v_74 = ((-(cb5_5.tint_symbol_2[11u].zxyz)).xyz + cb5_5.tint_symbol_2[13u].zxy); + r3 = vec4(v_74.xyz, r3.w); + let v_75 = fma(r0.www, r3.xyz, cb5_5.tint_symbol_2[11u].zxy); + r3 = vec4(v_75.xyz, r3.w); + let v_76 = (r2.ww * r3.yz); + r4 = vec4(v_76.xy, r4.zw); + r0.w = (r2.y * r2.z); + r1.w = fma(r2.x, r3.x, r0.w); + r1.w = fma(r3.x, r1.w, r4.x); + r2.z = fma(r2.x, r3.x, r2.y); + r2.z = fma(r3.x, r2.z, r4.y); + r1.w = (r1.w / r2.z); + r2.z = (r3.y / r3.z); + let v_77 = -(r2.zzzz); + r1.w = (r1.w + v_77.w); + r1.w = (1.0f / r1.w); + let v_78 = (r0.xyz * v1.zzz); + r0 = vec4(v_78.xyz, r0.w); + let v_79 = max(r0.xyz, vec3()); + r0 = vec4(v_79.xyz, r0.w); + let v_80 = fma(r2.xxx, r0.xyz, r0.www); + r3 = vec4(v_80.xyz, r3.w); + let v_81 = fma(r0.xyz, r3.xyz, r4.xxx); + r3 = vec4(v_81.xyz, r3.w); + let v_82 = fma(r2.xxx, r0.xyz, r2.yyy); + r5 = vec4(v_82.xyz, r5.w); + let v_83 = fma(r0.xyz, r5.xyz, r4.yyy); + r0 = vec4(v_83.xyz, r0.w); + let v_84 = (r3.xyz / r0.xyz); + r0 = vec4(v_84.xyz, r0.w); + let v_85 = ((-(r2.zzzz)).xyz + r0.xyz); + r0 = vec4(v_85.xyz, r0.w); + let v_86 = clamp(((r1.wwww * r0.xyzx)).xyz, vec3(), vec3(1.0f)); + r0 = vec4(v_86.xyz, r0.w); + r2.w = dot(r0.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + let v_87 = -(r2.wwww); + let v_88 = (r0.xyz + v_87.xyz); + r0 = vec4(v_88.xyz, r0.w); + let v_89 = fma(cb5_5.tint_symbol_2[67u].xxx, r0.xyz, r2.www); + r0 = vec4(v_89.xyz, r0.w); + r3.x = clamp(((r2.wwww / cb5_5.tint_symbol_2[66u].wwww)).x, 0.0f, 1.0f); + let v_90 = -(cb5_5.tint_symbol_2[66u].xxyz); + let v_91 = (cb5_5.tint_symbol_2[65u].xyz + v_90.yzw); + r3 = vec4(r3.x, v_91.xyz); + let v_92 = fma(r3.xxx, r3.yzw, cb5_5.tint_symbol_2[66u].xyz); + r3 = vec4(v_92.xyz, r3.w); + let v_93 = (r0.xyz * r3.xyz); + r5 = vec4(v_93.xyz, r5.w); + r3.w = ((-(cb5_5.tint_symbol_2[65u].wwww)).w + 1.0f); + let v_94 = -(r3.wwww); + r2.w = (r2.w + v_94.w); + r3.w = ((-(r3.wwww)).w + 1.0f); + r3.w = max(r3.w, 0.00999999977648258209f); + r2.w = clamp(((r2.wwww / r3.wwww)).w, 0.0f, 1.0f); + let v_95 = fma((-(r0.xyzx)).xyz, r3.xyz, r0.xyz); + r0 = vec4(v_95.xyz, r0.w); + let v_96 = clamp(fma(r2.wwww, r0.xyzx, r5.xyzx).xyz, vec3(), vec3(1.0f)); + r0 = vec4(v_96.xyz, r0.w); + r0.x = dot(r0.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r0.y = (r0.x * cb5_5.tint_symbol_2[24u].z); + r0.y = clamp(((r0.yyyy / cb5_5.tint_symbol_2[23u].wwww)).y, 0.0f, 1.0f); + r0.y = ((-(r0.yyyy)).y + 1.0f); + let v_97 = -(cb5_5.tint_symbol_2[24u].xxxx); + r0.z = fma(r0.x, cb5_5.tint_symbol_2[24u].z, v_97.z); + r2.w = (v_97.w + cb5_5.tint_symbol_2[24u].y); + r0.z = clamp(((r0.zzzz / r2.wwww)).z, 0.0f, 1.0f); + r2.w = (r0.z + r0.y); + r2.w = ((-(r2.wwww)).w + 1.0f); + let v_98 = (r0.yy * cb5_5.tint_symbol_2[25u].xw); + r3 = vec4(v_98.xy, r3.zw); + r3.x = fma(r0.z, cb5_5.tint_symbol_2[25u].y, r3.x); + r3.x = fma(r2.w, cb5_5.tint_symbol_2[24u].w, r3.x); + r0.x = fma(r0.x, cb5_5.tint_symbol_2[24u].z, r3.x); + let v_99 = fma(v1.xy, vec2(2.40000009536743164062f, 1.35000002384185791016f), cb5_5.tint_symbol_2[15u].xy); + r3 = vec4(r3.xy, v_99.xy); + let v_100 = fract(r3.zw); + r3 = vec4(r3.xy, v_100.xy); + r5 = textureSample(t7, s7, r3.zwzz.xy); + r3.y = fma(r2.w, cb5_5.tint_symbol_2[25u].z, r3.y); + r3.z = (r5.y + -0.5f); + r0.x = fma(r3.z, r3.y, r0.x); + r3.y = (r0.z * cb5_5.tint_symbol_2[26u].x); + r3.y = (r3.y * r3.z); + r3.y = max(r3.y, 0.0f); + r0.x = (r0.x + r3.y); + let v_101 = (r1.xyz * v1.zzz); + r1 = vec4(v_101.xyz, r1.w); + let v_102 = max(r1.xyz, vec3()); + r1 = vec4(v_102.xyz, r1.w); + let v_103 = fma(r2.xxx, r1.xyz, r0.www); + r3 = vec4(r3.x, v_103.xyz); + let v_104 = fma(r1.xyz, r3.yzw, r4.xxx); + r3 = vec4(r3.x, v_104.xyz); + let v_105 = fma(r2.xxx, r1.xyz, r2.yyy); + r4 = vec4(v_105.x, r4.y, v_105.yz); + let v_106 = fma(r1.xyz, r4.xzw, r4.yyy); + r1 = vec4(v_106.xyz, r1.w); + let v_107 = (r3.yzw / r1.xyz); + r1 = vec4(v_107.xyz, r1.w); + let v_108 = ((-(r2.zzzz)).xyz + r1.xyz); + r1 = vec4(v_108.xyz, r1.w); + let v_109 = clamp(((r1.wwww * r1.xyzx)).xyz, vec3(), vec3(1.0f)); + r1 = vec4(v_109.xyz, r1.w); + r0.w = dot(r1.xyz, vec3(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f)); + r0.w = fma(r0.w, cb5_5.tint_symbol_2[24u].z, r3.x); + r0.w = ((-(r0.zzzz)).w + r0.w); + r0.w = max(r0.w, 0.0f); + r0.x = fma(r0.w, cb5_5.tint_symbol_2[26u].y, r0.x); + let v_110 = (r0.zzz * cb5_5.tint_symbol_2[29u].xyz); + r1 = vec4(v_110.xyz, r1.w); + let v_111 = fma(r0.yyy, cb5_5.tint_symbol_2[28u].xyz, r1.xyz); + r0 = vec4(r0.x, v_111.xyz); + let v_112 = fma(r2.www, cb5_5.tint_symbol_2[27u].xyz, r0.yzw); + r0 = vec4(r0.x, v_112.xyz); + let v_113 = clamp(((r0.xxxx * r0.yzwy)).xyz, vec3(), vec3(1.0f)); + r0 = vec4(v_113.xyz, r0.w); + o0.w = dot(r0.xyz, vec3(0.29899999499320983887f, 0.58700001239776611328f, 0.11400000005960464478f)); + let v_114 = r0; + o0 = vec4(v_114.xyz, o0.w); +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4) -> @location(0u) vec4 { + main_inner(v1, v2); + return o0; +} diff --git a/b/8b0b5899ed/shaders/0138abd67681916a.wgsl b/b/8b0b5899ed/shaders/0138abd67681916a.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..3ae3fed185500867daf62819c865593b121d8044 --- /dev/null +++ b/b/8b0b5899ed/shaders/0138abd67681916a.wgsl @@ -0,0 +1,56 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb16_struct; + +struct cb5_struct { + tint_symbol_1 : array, 5u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb5_struct; + +struct cb3_struct { + tint_symbol_2 : array, 3u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb3_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +var o0 : vec4; + +fn main_inner(v3 : vec4) { + r0 = textureSample(t0, s0, v3.xy.xyxx.xy); + r0.x = (r0.w * cb2_2.tint_symbol[15u].x); + let v = -(cb5_5.tint_symbol_1[4u].xxxx); + r0.y = fma(r0.w, cb2_2.tint_symbol[15u].x, v.y); + r0.z = (v.z + 1.0f); + r0.z = (r0.z * 0.10000000149011611938f); + r0.y = (r0.y / r0.z); + r0.y = fma((-(r0.wwww)).y, cb2_2.tint_symbol[15u].x, r0.y); + r0.x = fma(cb12_12.tint_symbol_2[2u].y, r0.y, r0.x); + r0.y = bitcast(select(0u, 4294967295u, (0.0039215688593685627f >= r0.x))); + v_1((bitcast(r0.y) != 0u)); + o0 = vec4(vec3(), o0.w); + o0.w = r0.x; +} + +fn v_1(v_2 : bool) { + if (v_2) { + discard; + return; + } +} + +@fragment +fn main(@location(3u) v3 : vec4) -> @location(0u) vec4 { + main_inner(v3); + return o0; +} diff --git a/b/8b0b5899ed/shaders/0139fe33bda035a7.consts.json b/b/8b0b5899ed/shaders/0139fe33bda035a7.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/0139fe33bda035a7.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/0139fe33bda035a7.wgsl b/b/8b0b5899ed/shaders/0139fe33bda035a7.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..146779219dedde443f60d1192d06956a13fba346 --- /dev/null +++ b/b/8b0b5899ed/shaders/0139fe33bda035a7.wgsl @@ -0,0 +1,742 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb15_struct { + tint_symbol_4 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v4 : vec4; + +var v5 : array; + +var o0 : vec4; + +var o1 : f32; + +var o2 : f32; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_6 { + tint_symbol_5 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_6; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v4 = v_2; + x1[0u].x = v5[0u]; + x1[0u].y = v5[1u]; + x1[0u].z = v5[2u]; + x1[0u].w = v5[3u]; + r0 = textureSample(t0, s0, v1.xyz.xyxx.xy); + r1.x = dot(v2.xyz, v2.xyz); + r1.x = inverseSqrt(r1.x); + let v_3 = (r1.xxx * v2.xyz); + r1 = vec4(r1.x, v_3.xyz); + r0.w = (r0.w * v0.w); + let v_4 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r2 = vec4(v_4.xy, r2.zw); + let v_5 = (r0.xyz * r0.xyz); + r0 = vec4(v_5.xyz, r0.w); + let v_6 = -(v3.xyzx); + let v_7 = (v_6.xyz + cb1_1.tint_symbol[15u].xyz); + r3 = vec4(v_7.xyz, r3.w); + r2.z = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz); + let v_8 = (v3.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r3 = vec4(v_8.xyz, r3.w); + let v_9 = (r3.yyy * cb6_6.tint_symbol_4[1u].xyz); + r4 = vec4(v_9.xyz, r4.w); + let v_10 = fma(r3.xxx, cb6_6.tint_symbol_4[0u].xyz, r4.xyz); + r4 = vec4(v_10.xyz, r4.w); + let v_11 = fma(r3.zzz, cb6_6.tint_symbol_4[2u].xyz, r4.xyz); + r4 = vec4(v_11.xyz, r4.w); + let v_12 = fma(r4.xyz, cb6_6.tint_symbol_4[4u].xyz, cb6_6.tint_symbol_4[8u].xyz); + r5 = vec4(v_12.xyz, r5.w); + let v_13 = &(x0[0u]); + let v_14 = r5; + *(v_13) = vec4(v_14.xyz, (*(v_13)).w); + let v_15 = fma(r4.xyz, cb6_6.tint_symbol_4[5u].xyz, cb6_6.tint_symbol_4[9u].xyz); + r6 = vec4(v_15.xyz, r6.w); + let v_16 = &(x0[1u]); + let v_17 = r6; + *(v_16) = vec4(v_17.xyz, (*(v_16)).w); + let v_18 = fma(r4.xyz, cb6_6.tint_symbol_4[6u].xyz, cb6_6.tint_symbol_4[10u].xyz); + r7 = vec4(v_18.xyz, r7.w); + let v_19 = &(x0[2u]); + let v_20 = r7; + *(v_19) = vec4(v_20.xyz, (*(v_19)).w); + let v_21 = fma(r4.xyz, cb6_6.tint_symbol_4[7u].xyz, cb6_6.tint_symbol_4[11u].xyz); + r4 = vec4(v_21.xyz, r4.w); + let v_22 = &(x0[3u]); + let v_23 = r4; + *(v_22) = vec4(v_23.xyz, (*(v_22)).w); + let v_24 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_25 = r8; + r8 = vec4(v_25.x, v_24.x, v_25.z, v_24.y); + r2.w = fma((-(cb6_6.tint_symbol_4[14u].zzzz)).w, 1.5f, 1.0f); + r2.w = (r2.w * 0.5f); + let v_26 = abs(r7.yyyy); + r3.w = max(v_26.w, abs(r7.xxxx).w); + r3.w = bitcast(select(0u, 4294967295u, (r3.w < r2.w))); + let v_27 = (bitcast(r3.w) != 0u); + let v_28 = bitcast(v.tint_symbol_5[0i].x); + r3.w = select(bitcast(v.tint_symbol_5[1i].x), v_28, v_27); + let v_29 = abs(r6.yyyy); + r4.z = max(v_29.z, abs(r6.xxxx).z); + r4.z = bitcast(select(0u, 4294967295u, (r4.z < r2.w))); + let v_30 = bitcast(r4.z); + r3.w = select(r3.w, bitcast(v.tint_symbol_5[2i].x), (v_30 != 0u)); + let v_31 = abs(r5.yyyy); + r4.z = max(v_31.z, abs(r5.xxxx).z); + r2.w = bitcast(select(0u, 4294967295u, (r4.z < r2.w))); + let v_32 = bitcast(r2.w); + r2.w = select(r3.w, 0.0f, (v_32 != 0u)); + let v_33 = x0[bitcast(r2.w)]; + r5 = vec4(v_33.xyz, r5.w); + r2.w = f32(bitcast(r2.w)); + r3.w = (r2.w + 0.5f); + r3.w = (r3.w * 0.25f); + r6 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r2.wwww))); + r6 = bitcast>((bitcast>(r6) & vec4(1065353216u))); + r2.w = dot(r6, cb6_6.tint_symbol_4[12u]); + r4.z = dot(r6, cb6_6.tint_symbol_4[13u]); + r6.x = (r5.x + 0.5f); + r6.y = fma(r5.y, 0.25f, r3.w); + r3.w = bitcast(select(0u, 4294967295u, !((r2.w == 0.0f)))); + r2.w = ((-(r2.wwww)).w + r5.z); + let v_34 = dpdx(r6.xyy); + r7 = vec4(v_34.xy, r7.z, v_34.z); + r7.z = dpdx(r2.w); + let v_35 = dpdy(r6.yxy); + r9 = vec4(v_35.xyz, r9.w); + r9.w = dpdy(r2.w); + let v_36 = (r7.yw * r9.yw); + r5 = vec4(v_36.xy, r5.zw); + let v_37 = -(r5.xyxx); + let v_38 = fma(r7.xz, r9.xz, v_37.xy); + r10 = vec4(v_38.xy, r10.zw); + r4.w = (1.0f / r10.x); + r5.x = (r7.z * r9.y); + let v_39 = -(r5.xxxx); + r10.z = fma(r7.x, r9.w, v_39.z); + let v_40 = (r4.ww * r10.yz); + r5 = vec4(v_40.xy, r5.zw); + let v_41 = max(r5.xy, vec2()); + r5 = vec4(v_41.xy, r5.zw); + let v_42 = min(r5.xy, vec2(0.5f)); + r5 = vec4(v_42.xy, r5.zw); + r2.w = fma((-(r4.zzzz)).w, r5.x, r2.w); + r2.w = fma((-(r4.zzzz)).w, r5.y, r2.w); + let v_43 = bitcast(r3.w); + let v_44 = r2.w; + r8.z = select(r5.z, v_44, (v_43 != 0u)); + r6.z = 0.0f; + let v_45 = (r6.xyz + r8.ywz); + r5 = vec4(v_45.xyz, r5.w); + let v_46 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r8 = vec4(v_46.xy, r8.zw); + let v_47 = (r6.xyz + r8.xyz); + r7 = vec4(v_47.xyz, r7.w); + let v_48 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r8 = vec4(v_48.xy, r8.zw); + let v_49 = (r6.xyz + r8.xyz); + r9 = vec4(v_49.xyz, r9.w); + let v_50 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r8 = vec4(v_50.xy, r8.zw); + let v_51 = (r6.xyz + r8.xyz); + r10 = vec4(v_51.xyz, r10.w); + let v_52 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r8 = vec4(v_52.xy, r8.zw); + let v_53 = (r6.xyz + r8.xyz); + r11 = vec4(v_53.xyz, r11.w); + let v_54 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r8 = vec4(v_54.xy, r8.zw); + let v_55 = (r6.xyz + r8.xyz); + r12 = vec4(v_55.xyz, r12.w); + let v_56 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r8 = vec4(v_56.xy, r8.zw); + let v_57 = (r6.xyz + r8.xyz); + r13 = vec4(v_57.xyz, r13.w); + let v_58 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r8 = vec4(v_58.xy, r8.zw); + let v_59 = (r6.xyz + r8.xyz); + r14 = vec4(v_59.xyz, r14.w); + let v_60 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r8 = vec4(v_60.xy, r8.zw); + let v_61 = (r6.xyz + r8.xyz); + r15 = vec4(v_61.xyz, r15.w); + let v_62 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r8 = vec4(v_62.xy, r8.zw); + let v_63 = (r6.xyz + r8.xyz); + r16 = vec4(v_63.xyz, r16.w); + let v_64 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r8 = vec4(v_64.xy, r8.zw); + let v_65 = (r6.xyz + r8.xyz); + r17 = vec4(v_65.xyz, r17.w); + let v_66 = (cb6_6.tint_symbol_4[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r8 = vec4(v_66.xy, r8.zw); + let v_67 = (r6.xyz + r8.xyz); + r18 = vec4(v_67.xyz, r18.w); + let v_68 = (cb6_6.tint_symbol_4[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r8 = vec4(v_68.xy, r8.zw); + let v_69 = (r6.xyz + r8.xyz); + r19 = vec4(v_69.xyz, r19.w); + let v_70 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r8 = vec4(v_70.xy, r8.zw); + let v_71 = (r6.xyz + r8.xyz); + r20 = vec4(v_71.xyz, r20.w); + let v_72 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r8 = vec4(v_72.xy, r8.zw); + let v_73 = (r6.xyz + r8.xyz); + r21 = vec4(v_73.xyz, r21.w); + let v_74 = (cb6_6.tint_symbol_4[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r8 = vec4(v_74.xy, r8.zw); + let v_75 = (r6.xyz + r8.xyz); + r6 = vec4(v_75.xyz, r6.w); + let v_76 = r5.xyxx; + r5.x = textureSampleCompareLevel(t15, s15, v_76.xy, r5.z); + let v_77 = r7.xyxx; + r5.y = textureSampleCompareLevel(t15, s15, v_77.xy, r7.z); + let v_78 = r9.xyxx; + r5.z = textureSampleCompareLevel(t15, s15, v_78.xy, r9.z); + let v_79 = r10.xyxx; + r5.w = textureSampleCompareLevel(t15, s15, v_79.xy, r10.z); + let v_80 = r11.xyxx; + r7.x = textureSampleCompareLevel(t15, s15, v_80.xy, r11.z); + let v_81 = r12.xyxx; + r7.y = textureSampleCompareLevel(t15, s15, v_81.xy, r12.z); + let v_82 = r13.xyxx; + r7.z = textureSampleCompareLevel(t15, s15, v_82.xy, r13.z); + let v_83 = r14.xyxx; + r7.w = textureSampleCompareLevel(t15, s15, v_83.xy, r14.z); + let v_84 = r15.xyxx; + r8.x = textureSampleCompareLevel(t15, s15, v_84.xy, r15.z); + let v_85 = r16.xyxx; + r8.y = textureSampleCompareLevel(t15, s15, v_85.xy, r16.z); + let v_86 = r17.xyxx; + r8.z = textureSampleCompareLevel(t15, s15, v_86.xy, r17.z); + let v_87 = r18.xyxx; + r8.w = textureSampleCompareLevel(t15, s15, v_87.xy, r18.z); + let v_88 = r19.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_88.xy, r19.z); + let v_89 = r20.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_89.xy, r20.z); + let v_90 = r21.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_90.xy, r21.z); + let v_91 = r6.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_91.xy, r6.z); + r5 = (r5 + r7); + r5 = (r8 + r5); + r5 = (r9 + r5); + r2.w = dot(r5, vec4(1.0f)); + r2.z = clamp(fma(r2.zzzz, cb6_6.tint_symbol_4[0u].wwww, cb6_6.tint_symbol_4[1u].wwww).z, 0.0f, 1.0f); + let v_92 = abs(r4.yyyy); + r3.w = max(v_92.w, abs(r4.xxxx).w); + r3.w = clamp(fma(r3.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.z = (r3.w * r2.z); + r2.z = fma(r2.w, 0.0625f, r2.z); + let v_93 = (r2.xyz * r2.xyz); + r2 = vec4(v_93.xyz, r2.w); + r2.z = min(r2.z, 1.0f); + r2.w = clamp(fma(v3.zzzz, cb6_6.tint_symbol_4[3u].xxxx, cb6_6.tint_symbol_4[3u].yyyy).w, 0.0f, 1.0f); + r2.w = sqrt(r2.w); + r2.w = (r2.w * cb6_6.tint_symbol_4[3u].z); + let v_94 = -(r2.zzzz); + r2.z = fma(r2.w, v_94.z, r2.z); + let v_95 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_96 = dot(r1.yzw, v_95.xyz); + r2.w = clamp(vec4(v_96, v_96, v_96, v_96).w, 0.0f, 1.0f); + let v_97 = (r0.xyz * r2.www); + r4 = vec4(v_97.xyz, r4.w); + let v_98 = (r4.xyz * cb3_3.tint_symbol_2[1u].xyz); + r4 = vec4(v_98.xyz, r4.w); + r2.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_99 = (v_6.xyz + cb3_3.tint_symbol_2[3u].xyz); + r5 = vec4(v_99.xyz, r5.w); + let v_100 = (v3.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r6 = vec4(v_100.xyz, r6.w); + r4.w = dot(r6.xyz, cb3_3.tint_symbol_2[11u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_2[19u].w); + let v_101 = fma(cb3_3.tint_symbol_2[11u].xyz, r4.www, cb3_3.tint_symbol_2[3u].xyz); + r6 = vec4(v_101.xyz, r6.w); + let v_102 = (r6.xyz + v_6.xyz); + r6 = vec4(v_102.xyz, r6.w); + let v_103 = bitcast>(r3.www); + let v_104 = r5.xyz; + let v_105 = select(r6.xyz, v_104, (v_103 != vec3())); + r5 = vec4(v_105.xyz, r5.w); + r3.w = dot(r5.xyz, r5.xyz); + let v_106 = (r5.xyz + vec3(0.00000099999999747524f)); + r5 = vec4(v_106.xyz, r5.w); + r4.w = dot(r5.xyz, r5.xyz); + r4.w = inverseSqrt(r4.w); + let v_107 = (r4.www * r5.xyz); + r5 = vec4(v_107.xyz, r5.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[11u].w); + r3.w = (r3.w / r4.w); + let v_108 = -(cb3_3.tint_symbol_2[11u].xyzx); + r4.w = dot(r5.xyz, v_108.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_109 = dot(r5.xyz, r1.yzw); + r5.x = clamp(vec4(v_109, v_109, v_109, v_109).x, 0.0f, 1.0f); + r4.w = (r4.w * r5.x); + r3.w = (r3.w * r4.w); + let v_110 = (r3.www * cb3_3.tint_symbol_2[19u].xyz); + r5 = vec4(v_110.xyz, r5.w); + let v_111 = (r0.xyz * r5.xyz); + r5 = vec4(v_111.xyz, r5.w); + let v_112 = bitcast>(r2.www); + let v_113 = select(r5.xyz, vec3(), (v_112 != vec3())); + r5 = vec4(v_113.xyz, r5.w); + r3.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_114 = (v_6.xyz + cb3_3.tint_symbol_2[4u].xyz); + r6 = vec4(v_114.xyz, r6.w); + let v_115 = (v3.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r7 = vec4(v_115.xyz, r7.w); + r4.w = dot(r7.xyz, cb3_3.tint_symbol_2[12u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_2[20u].w); + let v_116 = fma(cb3_3.tint_symbol_2[12u].xyz, r4.www, cb3_3.tint_symbol_2[4u].xyz); + r7 = vec4(v_116.xyz, r7.w); + let v_117 = (r7.xyz + v_6.xyz); + r7 = vec4(v_117.xyz, r7.w); + let v_118 = bitcast>(r3.www); + let v_119 = r6.xyz; + let v_120 = select(r7.xyz, v_119, (v_118 != vec3())); + r6 = vec4(v_120.xyz, r6.w); + r3.w = dot(r6.xyz, r6.xyz); + let v_121 = (r6.xyz + vec3(0.00000099999999747524f)); + r6 = vec4(v_121.xyz, r6.w); + r4.w = dot(r6.xyz, r6.xyz); + r4.w = inverseSqrt(r4.w); + let v_122 = (r4.www * r6.xyz); + r6 = vec4(v_122.xyz, r6.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[12u].w); + r3.w = (r3.w / r4.w); + let v_123 = -(cb3_3.tint_symbol_2[12u].xyzx); + r4.w = dot(r6.xyz, v_123.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_124 = dot(r6.xyz, r1.yzw); + r5.w = clamp(vec4(v_124, v_124, v_124, v_124).w, 0.0f, 1.0f); + r4.w = (r4.w * r5.w); + r3.w = (r3.w * r4.w); + let v_125 = (r3.www * cb3_3.tint_symbol_2[20u].xyz); + r6 = vec4(v_125.xyz, r6.w); + let v_126 = fma(r6.xyz, r0.xyz, r5.xyz); + r6 = vec4(v_126.xyz, r6.w); + let v_127 = bitcast>(r2.www); + let v_128 = r5.xyz; + let v_129 = select(r6.xyz, v_128, (v_127 != vec3())); + r5 = vec4(v_129.xyz, r5.w); + } else { + r2.w = bitcast(v.tint_symbol_5[3i].x); + } + if ((bitcast(r2.w) != 0u)) { + r2.w = bitcast(v.tint_symbol_5[3i].x); + } else { + r3.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_130 = (v_6.xyz + cb3_3.tint_symbol_2[5u].xyz); + r6 = vec4(v_130.xyz, r6.w); + let v_131 = (v3.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r7 = vec4(v_131.xyz, r7.w); + r4.w = dot(r7.xyz, cb3_3.tint_symbol_2[13u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_2[21u].w); + let v_132 = fma(cb3_3.tint_symbol_2[13u].xyz, r4.www, cb3_3.tint_symbol_2[5u].xyz); + r7 = vec4(v_132.xyz, r7.w); + let v_133 = (r7.xyz + v_6.xyz); + r7 = vec4(v_133.xyz, r7.w); + let v_134 = bitcast>(r3.www); + let v_135 = r6.xyz; + let v_136 = select(r7.xyz, v_135, (v_134 != vec3())); + r6 = vec4(v_136.xyz, r6.w); + r3.w = dot(r6.xyz, r6.xyz); + let v_137 = (r6.xyz + vec3(0.00000099999999747524f)); + r6 = vec4(v_137.xyz, r6.w); + r4.w = dot(r6.xyz, r6.xyz); + r4.w = inverseSqrt(r4.w); + let v_138 = (r4.www * r6.xyz); + r6 = vec4(v_138.xyz, r6.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[13u].w); + r3.w = (r3.w / r4.w); + let v_139 = -(cb3_3.tint_symbol_2[13u].xyzx); + r4.w = dot(r6.xyz, v_139.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_140 = dot(r6.xyz, r1.yzw); + r5.w = clamp(vec4(v_140, v_140, v_140, v_140).w, 0.0f, 1.0f); + r4.w = (r4.w * r5.w); + r3.w = (r3.w * r4.w); + let v_141 = (r3.www * cb3_3.tint_symbol_2[21u].xyz); + r6 = vec4(v_141.xyz, r6.w); + let v_142 = fma(r6.xyz, r0.xyz, r5.xyz); + r6 = vec4(v_142.xyz, r6.w); + let v_143 = bitcast>(r2.www); + let v_144 = r5.xyz; + let v_145 = select(r6.xyz, v_144, (v_143 != vec3())); + r5 = vec4(v_145.xyz, r5.w); + } + if ((bitcast(r2.w) != 0u)) { + } else { + r3.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_146 = (v_6.xyz + cb3_3.tint_symbol_2[6u].xyz); + r6 = vec4(v_146.xyz, r6.w); + let v_147 = (v3.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r7 = vec4(v_147.xyz, r7.w); + r4.w = dot(r7.xyz, cb3_3.tint_symbol_2[14u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_2[22u].w); + let v_148 = fma(cb3_3.tint_symbol_2[14u].xyz, r4.www, cb3_3.tint_symbol_2[6u].xyz); + r7 = vec4(v_148.xyz, r7.w); + let v_149 = (r7.xyz + v_6.xyz); + r7 = vec4(v_149.xyz, r7.w); + let v_150 = bitcast>(r3.www); + let v_151 = r6.xyz; + let v_152 = select(r7.xyz, v_151, (v_150 != vec3())); + r6 = vec4(v_152.xyz, r6.w); + r3.w = dot(r6.xyz, r6.xyz); + let v_153 = (r6.xyz + vec3(0.00000099999999747524f)); + r6 = vec4(v_153.xyz, r6.w); + r4.w = dot(r6.xyz, r6.xyz); + r4.w = inverseSqrt(r4.w); + let v_154 = (r4.www * r6.xyz); + r6 = vec4(v_154.xyz, r6.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[14u].w); + r3.w = (r3.w / r4.w); + let v_155 = -(cb3_3.tint_symbol_2[14u].xyzx); + r4.w = dot(r6.xyz, v_155.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_156 = dot(r6.xyz, r1.yzw); + r5.w = clamp(vec4(v_156, v_156, v_156, v_156).w, 0.0f, 1.0f); + r4.w = (r4.w * r5.w); + r3.w = (r3.w * r4.w); + let v_157 = (r3.www * cb3_3.tint_symbol_2[22u].xyz); + r6 = vec4(v_157.xyz, r6.w); + let v_158 = fma(r6.xyz, r0.xyz, r5.xyz); + r6 = vec4(v_158.xyz, r6.w); + let v_159 = bitcast>(r2.www); + let v_160 = r5.xyz; + let v_161 = select(r6.xyz, v_160, (v_159 != vec3())); + r5 = vec4(v_161.xyz, r5.w); + } + let v_162 = fma(r4.xyz, r2.zzz, r5.xyz); + r4 = vec4(v_162.xyz, r4.w); + r1.x = fma(v2.z, r1.x, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_163 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r5 = vec4(v_163.xyz, r5.w); + r2.z = ((-(cb2_2.tint_symbol_1[16u].zzzz)).z + 1.0f); + let v_164 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r6 = vec4(v_164.xyz, r6.w); + let v_165 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz); + r6 = vec4(v_165.xyz, r6.w); + let v_166 = fma(r5.xyz, r2.zzz, r6.xyz); + r5 = vec4(v_166.xyz, r5.w); + let v_167 = (r2.yyy * r5.xyz); + r2 = vec4(r2.x, v_167.xyz); + let v_168 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r5 = vec4(v_168.xyz, r5.w); + r6.x = cb3_3.tint_symbol_2[46u].w; + r6.y = cb3_3.tint_symbol_2[47u].w; + r6.z = cb3_3.tint_symbol_2[48u].w; + let v_169 = dot(r6.xyz, r1.yzw); + r1.x = clamp(vec4(v_169, v_169, v_169, v_169).x, 0.0f, 1.0f); + let v_170 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r5.xyz); + r1 = vec4(v_170.xyz, r1.w); + let v_171 = fma(r1.xyz, r2.xxx, r2.yzw); + r1 = vec4(v_171.xyz, r1.w); + let v_172 = fma(r1.xyz, r0.xyz, r4.xyz); + r0 = vec4(v_172.xyz, r0.w); + r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r1.x = dot(r3.xyz, r3.xyz); + r1.y = sqrt(r1.x); + let v_173 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.z = (r1.y + v_173.z); + r1.z = max(r1.z, 0.0f); + r1.y = (r1.z / r1.y); + r1.y = (r1.y * r3.z); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].z); + r1.y = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.yyyy).y))); + r2.x = (r1.w * -1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.w = (r2.x / r1.w); + let v_174 = bitcast(r1.y); + r1.y = select(1.0f, r1.w, (v_174 != 0u)); + r1.w = (r1.z * cb3_3.tint_symbol_2[51u].w); + r1.y = (r1.y * r1.w); + r1.y = min(r1.y, 1.0f); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = min(r1.y, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].y); + r1.x = inverseSqrt(r1.x); + let v_175 = (r1.xxx * r3.xyz); + r2 = vec4(v_175.xyz, r2.w); + let v_176 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.x = clamp(vec4(v_176, v_176, v_176, v_176).x, 0.0f, 1.0f); + r1.x = log2(r1.x); + r1.x = (r1.x * cb3_3.tint_symbol_2[54u].w); + r1.x = exp2(r1.x); + let v_177 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.x = clamp(vec4(v_177, v_177, v_177, v_177).x, 0.0f, 1.0f); + r2.x = log2(r2.x); + r2.x = (r2.x * cb3_3.tint_symbol_2[53u].w); + r2.x = exp2(r2.x); + r1.y = fma((-(r1.yyyy)).y, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.y = (r1.y * cb3_3.tint_symbol_2[51u].y); + let v_178 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.y = (r1.z + v_178.y); + r2.y = max(r2.y, 0.0f); + r2.y = (r2.y * cb3_3.tint_symbol_2[51u].x); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + r1.w = clamp(fma(r1.yyyy, r2.yyyy, r1.wwww).w, 0.0f, 1.0f); + let v_179 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.z = (r1.z * v_179.z); + r1.z = (r1.z * 1.44269502162933349609f); + r1.z = exp2(r1.z); + r1.z = ((-(r1.zzzz)).z + 1.0f); + let v_180 = ((-(cb3_3.tint_symbol_2[56u].xxyz)).yzw + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(r2.x, v_180.xyz); + let v_181 = fma(r1.xxx, r2.yzw, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(r2.x, v_181.xyz); + let v_182 = ((-(r2.yzwy)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_182.xyz, r4.w); + let v_183 = fma(r2.xxx, r4.xyz, r2.yzw); + r2 = vec4(v_183.xyz, r2.w); + let v_184 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_185 = (r2.xyz + v_184.xyz); + r2 = vec4(v_185.xyz, r2.w); + let v_186 = fma(r1.zzz, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_186.xyz, r2.w); + r4.x = cb3_3.tint_symbol_2[55u].w; + r4.y = cb3_3.tint_symbol_2[56u].w; + r4.z = cb3_3.tint_symbol_2[57u].w; + let v_187 = ((-(r2.xyzx)).xyz + r4.xyz); + r4 = vec4(v_187.xyz, r4.w); + let v_188 = fma(r1.yyy, r4.xyz, r2.xyz); + r1 = vec4(v_188.xyz, r1.w); + r2.x = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r2.x) != 0u)) { + let v_189 = (v4.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_189.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r2.x = (r2.x + -1.0f); + r2.x = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r2.xxxx, vec4(1.0f)).x, 0.0f, 1.0f); + } else { + r2.x = 1.0f; + } + let v_190 = -(r0.xyzx); + let v_191 = fma(r1.xyz, r2.xxx, v_190.xyz); + r1 = vec4(v_191.xyz, r1.w); + let v_192 = fma(r1.www, r1.xyz, r0.xyz); + r1 = vec4(v_192.xyz, r1.w); + } else { + r1.w = dot(r3.xyz, r3.xyz); + r2.x = sqrt(r1.w); + let v_193 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.y = (r2.x + v_193.y); + r2.y = max(r2.y, 0.0f); + r2.x = (r2.y / r2.x); + r2.x = (r2.x * r3.z); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].z); + r2.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r2.xxxx).x))); + r2.w = (r2.z * -1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.z = (r2.w / r2.z); + let v_194 = bitcast(r2.x); + r2.x = select(1.0f, r2.z, (v_194 != 0u)); + r2.z = (r2.y * cb3_3.tint_symbol_2[51u].w); + r2.x = (r2.x * r2.z); + r2.x = min(r2.x, 1.0f); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = min(r2.x, 1.0f); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].y); + r1.w = inverseSqrt(r1.w); + let v_195 = (r1.www * r3.xyz); + r3 = vec4(v_195.xyz, r3.w); + let v_196 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.w = clamp(vec4(v_196, v_196, v_196, v_196).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[54u].w); + r1.w = exp2(r1.w); + let v_197 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.w = clamp(vec4(v_197, v_197, v_197, v_197).w, 0.0f, 1.0f); + r2.w = log2(r2.w); + r2.w = (r2.w * cb3_3.tint_symbol_2[53u].w); + r2.w = exp2(r2.w); + r2.x = fma((-(r2.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].y); + let v_198 = -(cb3_3.tint_symbol_2[52u].xxxx); + r3.x = (r2.y + v_198.x); + r3.x = max(r3.x, 0.0f); + r3.x = (r3.x * cb3_3.tint_symbol_2[51u].x); + r3.x = (r3.x * 1.44269502162933349609f); + r3.x = exp2(r3.x); + r3.x = ((-(r3.xxxx)).x + 1.0f); + r2.z = clamp(fma(r2.xxxx, r3.xxxx, r2.zzzz).z, 0.0f, 1.0f); + let v_199 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.y = (r2.y * v_199.y); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + let v_200 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_200.xyz, r3.w); + let v_201 = fma(r1.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_201.xyz, r3.w); + let v_202 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_202.xyz, r4.w); + let v_203 = fma(r2.www, r4.xyz, r3.xyz); + r3 = vec4(v_203.xyz, r3.w); + let v_204 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_205 = (r3.xyz + v_204.xyz); + r3 = vec4(v_205.xyz, r3.w); + let v_206 = fma(r2.yyy, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r3 = vec4(v_206.xyz, r3.w); + r4.x = cb3_3.tint_symbol_2[55u].w; + r4.y = cb3_3.tint_symbol_2[56u].w; + r4.z = cb3_3.tint_symbol_2[57u].w; + let v_207 = ((-(r3.xyzx)).xyz + r4.xyz); + r4 = vec4(v_207.xyz, r4.w); + let v_208 = fma(r2.xxx, r4.xyz, r3.xyz); + r2 = vec4(v_208.xy, r2.z, v_208.z); + let v_209 = ((-(r0.xyxz)).xyw + r2.xyw); + r2 = vec4(v_209.xy, r2.z, v_209.z); + let v_210 = fma(r2.zzz, r2.xyw, r0.xyz); + r1 = vec4(v_210.xyz, r1.w); + } + let v_211 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_211.xyz, o0.w); + r0.x = bitcast(select(0u, 4294967295u, (0.30000001192092895508f < r0.w))); + r0.x = bitcast((bitcast(r0.x) & 1065353216u)); + o1 = (r0.x * v1.z); + o0.w = r0.w; + o2 = r0.x; +} + +struct tint_symbol_7 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : f32, + @location(2u) + o2 : f32, +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @builtin(position) v_212 : vec4) -> tint_symbol_7 { + main_inner(v0, v1, v2, v3, v_212); + return tint_symbol_7(o0, o1, o2); +} diff --git a/b/8b0b5899ed/shaders/013d56caa6391a99.consts.json b/b/8b0b5899ed/shaders/013d56caa6391a99.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/013d56caa6391a99.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/013d56caa6391a99.wgsl b/b/8b0b5899ed/shaders/013d56caa6391a99.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..19fa03ba91de9ea7c4e33ad5c49f3252f32d9b47 --- /dev/null +++ b/b/8b0b5899ed/shaders/013d56caa6391a99.wgsl @@ -0,0 +1,1239 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v7 : vec4; + +var v8 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v7 = v_2; + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t0, s0, v1.xy.xyxx.xy); + r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x))); + v_3((bitcast(r1.x) != 0u)); + r1 = textureSample(t2, s2, v1.xy.xyxx.xy); + let v_4 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_4.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[0u].w, 0.00100000004749745131f); + let v_5 = (r1.ww * r1.xy); + r1 = vec4(v_5.xy, r1.zw); + let v_6 = (r1.yyy * v5.xyz); + r2 = vec4(v_6.xyz, r2.w); + let v_7 = fma(r1.xxx, v4.xyz, r2.xyz); + r1 = vec4(v_7.xy, r1.z, v_7.z); + let v_8 = fma(r1.zzz, v2.xyz, r1.xyw); + r1 = vec4(v_8.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_9 = (r1.www * r1.xyz); + r2 = vec4(v_9.xyz, r2.w); + r1.x = dot(v3.xyz, v3.xyz); + r1.x = inverseSqrt(r1.x); + let v_10 = (r1.xxx * v3.xyz); + r3 = vec4(v_10.xyz, r3.w); + r1.x = dot((-(r3.xyzx)).xyz, r2.xyz); + r1.x = (r1.x + r1.x); + let v_11 = -(r1.xxxx); + let v_12 = -(r3.xyzx); + let v_13 = fma(r2.xyz, v_11.xyz, v_12.xyz); + r3 = vec4(v_13.xyz, r3.w); + r1.x = dot(r3.xyz, r3.xyz); + r1.x = inverseSqrt(r1.x); + let v_14 = fma(r3.xz, r1.xx, vec2(1.0f)); + r1 = vec4(v_14.xy, r1.zw); + let v_15 = (r1.xy * vec2(-0.5f)); + r1 = vec4(v_15.xy, r1.zw); + r3 = textureSample(t3, s3, r1.xyxx.xy); + let v_16 = (r3.xyz * cb12_12.tint_symbol_4[1u].xxx); + r3 = vec4(v_16.xyz, r3.w); + r0.w = (r0.w * v0.w); + let v_17 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r1 = vec4(v_17.xy, r1.zw); + let v_18 = (r0.xyz * r0.xyz); + r0 = vec4(v_18.xyz, r0.w); + let v_19 = -(v6.xyzx); + let v_20 = (v_19.xyz + cb1_1.tint_symbol[15u].xyz); + r4 = vec4(v_20.xyz, r4.w); + r2.w = dot(r4.xyz, r4.xyz); + r2.w = inverseSqrt(r2.w); + let v_21 = (r2.www * r4.xyz); + r5 = vec4(v_21.xyz, r5.w); + let v_22 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_23 = fma(r4.xyz, r2.www, v_22.xyz); + r6 = vec4(v_23.xyz, r6.w); + r3.w = dot(r6.xyz, r6.xyz); + r3.w = inverseSqrt(r3.w); + let v_24 = (r3.www * r6.xyz); + r6 = vec4(v_24.xyz, r6.w); + r3.w = clamp(cb12_12.tint_symbol_4[0u].z, 0.0f, 1.0f); + let v_25 = (r1.xy * r1.xy); + r1 = vec4(v_25.xy, r1.zw); + r4.w = (cb12_12.tint_symbol_4[0u].y + -500.0f); + r4.w = max(r4.w, 0.0f); + r5.w = ((-(r4.wwww)).w + cb12_12.tint_symbol_4[0u].y); + r4.w = (r4.w * 558.0f); + r4.w = fma(r5.w, 3.0f, r4.w); + r5.w = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz); + let v_26 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r7 = vec4(v_26.xyz, r7.w); + let v_27 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_27.xyz, r8.w); + let v_28 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_28.xyz, r8.w); + let v_29 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_29.xyz, r8.w); + let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_30.xyz, r9.w); + let v_31 = &(x0[0u]); + let v_32 = r9; + *(v_31) = vec4(v_32.xyz, (*(v_31)).w); + let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_33.xyz, r10.w); + let v_34 = &(x0[1u]); + let v_35 = r10; + *(v_34) = vec4(v_35.xyz, (*(v_34)).w); + let v_36 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_36.xyz, r11.w); + let v_37 = &(x0[2u]); + let v_38 = r11; + *(v_37) = vec4(v_38.xyz, (*(v_37)).w); + let v_39 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_39.xyz, r8.w); + let v_40 = &(x0[3u]); + let v_41 = r8; + *(v_40) = vec4(v_41.xyz, (*(v_40)).w); + let v_42 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_43 = r12; + r12 = vec4(v_43.x, v_42.x, v_43.z, v_42.y); + r6.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r6.w = (r6.w * 0.5f); + let v_44 = abs(r11.yyyy); + r7.w = max(v_44.w, abs(r11.xxxx).w); + r7.w = bitcast(select(0u, 4294967295u, (r7.w < r6.w))); + let v_45 = (bitcast(r7.w) != 0u); + let v_46 = bitcast(v.tint_symbol_6[0i].x); + r7.w = select(bitcast(v.tint_symbol_6[1i].x), v_46, v_45); + let v_47 = abs(r10.yyyy); + r8.z = max(v_47.z, abs(r10.xxxx).z); + r8.z = bitcast(select(0u, 4294967295u, (r8.z < r6.w))); + let v_48 = bitcast(r8.z); + r7.w = select(r7.w, bitcast(v.tint_symbol_6[2i].x), (v_48 != 0u)); + let v_49 = abs(r9.yyyy); + r8.z = max(v_49.z, abs(r9.xxxx).z); + r6.w = bitcast(select(0u, 4294967295u, (r8.z < r6.w))); + let v_50 = bitcast(r6.w); + r6.w = select(r7.w, 0.0f, (v_50 != 0u)); + let v_51 = x0[bitcast(r6.w)]; + r9 = vec4(v_51.xyz, r9.w); + r6.w = f32(bitcast(r6.w)); + r7.w = (r6.w + 0.5f); + r7.w = (r7.w * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r6.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r6.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r8.z = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r7.w); + r7.w = bitcast(select(0u, 4294967295u, !((r6.w == 0.0f)))); + r6.w = ((-(r6.wwww)).w + r9.z); + let v_52 = dpdx(r10.xyy); + r11 = vec4(v_52.xy, r11.z, v_52.z); + r11.z = dpdx(r6.w); + let v_53 = dpdy(r10.yxy); + r13 = vec4(v_53.xyz, r13.w); + r13.w = dpdy(r6.w); + let v_54 = (r11.yw * r13.yw); + r9 = vec4(v_54.xy, r9.zw); + let v_55 = -(r9.xyxx); + let v_56 = fma(r11.xz, r13.xz, v_55.xy); + r14 = vec4(v_56.xy, r14.zw); + r8.w = (1.0f / r14.x); + r9.x = (r11.z * r13.y); + let v_57 = -(r9.xxxx); + r14.z = fma(r11.x, r13.w, v_57.z); + let v_58 = (r8.ww * r14.yz); + r9 = vec4(v_58.xy, r9.zw); + let v_59 = max(r9.xy, vec2()); + r9 = vec4(v_59.xy, r9.zw); + let v_60 = min(r9.xy, vec2(0.5f)); + r9 = vec4(v_60.xy, r9.zw); + r6.w = fma((-(r8.zzzz)).w, r9.x, r6.w); + r6.w = fma((-(r8.zzzz)).w, r9.y, r6.w); + let v_61 = bitcast(r7.w); + let v_62 = r6.w; + r12.z = select(r9.z, v_62, (v_61 != 0u)); + r10.z = 0.0f; + let v_63 = (r10.xyz + r12.ywz); + r9 = vec4(v_63.xyz, r9.w); + let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_64.xy, r12.zw); + let v_65 = (r10.xyz + r12.xyz); + r11 = vec4(v_65.xyz, r11.w); + let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_66.xy, r12.zw); + let v_67 = (r10.xyz + r12.xyz); + r13 = vec4(v_67.xyz, r13.w); + let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_68.xy, r12.zw); + let v_69 = (r10.xyz + r12.xyz); + r14 = vec4(v_69.xyz, r14.w); + let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_70.xy, r12.zw); + let v_71 = (r10.xyz + r12.xyz); + r15 = vec4(v_71.xyz, r15.w); + let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_72.xy, r12.zw); + let v_73 = (r10.xyz + r12.xyz); + r16 = vec4(v_73.xyz, r16.w); + let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_74.xy, r12.zw); + let v_75 = (r10.xyz + r12.xyz); + r17 = vec4(v_75.xyz, r17.w); + let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_76.xy, r12.zw); + let v_77 = (r10.xyz + r12.xyz); + r18 = vec4(v_77.xyz, r18.w); + let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_78.xy, r12.zw); + let v_79 = (r10.xyz + r12.xyz); + r19 = vec4(v_79.xyz, r19.w); + let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_80.xy, r12.zw); + let v_81 = (r10.xyz + r12.xyz); + r20 = vec4(v_81.xyz, r20.w); + let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_82.xy, r12.zw); + let v_83 = (r10.xyz + r12.xyz); + r21 = vec4(v_83.xyz, r21.w); + let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_84.xy, r12.zw); + let v_85 = (r10.xyz + r12.xyz); + r22 = vec4(v_85.xyz, r22.w); + let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_86.xy, r12.zw); + let v_87 = (r10.xyz + r12.xyz); + r23 = vec4(v_87.xyz, r23.w); + let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_88.xy, r12.zw); + let v_89 = (r10.xyz + r12.xyz); + r24 = vec4(v_89.xyz, r24.w); + let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_90.xy, r12.zw); + let v_91 = (r10.xyz + r12.xyz); + r25 = vec4(v_91.xyz, r25.w); + let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_92.xy, r12.zw); + let v_93 = (r10.xyz + r12.xyz); + r10 = vec4(v_93.xyz, r10.w); + let v_94 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_94.xy, r9.z); + let v_95 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_95.xy, r11.z); + let v_96 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_96.xy, r13.z); + let v_97 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_97.xy, r14.z); + let v_98 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_98.xy, r15.z); + let v_99 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_99.xy, r16.z); + let v_100 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_100.xy, r17.z); + let v_101 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_101.xy, r18.z); + let v_102 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_102.xy, r19.z); + let v_103 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_103.xy, r20.z); + let v_104 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_104.xy, r21.z); + let v_105 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_105.xy, r22.z); + let v_106 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_106.xy, r23.z); + let v_107 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_107.xy, r24.z); + let v_108 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_108.xy, r25.z); + let v_109 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_109.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r6.w = dot(r9, vec4(1.0f)); + r5.w = clamp(fma(r5.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f); + let v_110 = abs(r8.yyyy); + r7.w = max(v_110.w, abs(r8.xxxx).w); + r7.w = clamp(fma(r7.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r5.w = ((-(r5.wwww)).w + 1.0f); + r5.w = (r7.w * r5.w); + r5.w = fma(r6.w, 0.0625f, r5.w); + r5.w = (r5.w * r5.w); + r5.w = min(r5.w, 1.0f); + r6.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r6.w = sqrt(r6.w); + r6.w = (r6.w * cb6_6.tint_symbol_5[3u].z); + let v_111 = -(r5.wwww); + r5.w = fma(r6.w, v_111.w, r5.w); + let v_112 = dot(r2.xyz, v_22.xyz); + r6.w = clamp(vec4(v_112, v_112, v_112, v_112).w, 0.0f, 1.0f); + let v_113 = dot(r5.xyz, r2.xyz); + r8.x = clamp(vec4(v_113, v_113, v_113, v_113).x, 0.0f, 1.0f); + let v_114 = dot(r6.xyz, v_22.xyz); + r8.y = clamp(vec4(v_114, v_114, v_114, v_114).y, 0.0f, 1.0f); + let v_115 = ((-(r8.xyxx)).xy + vec2(1.0f)); + r8 = vec4(v_115.xy, r8.zw); + let v_116 = (r8.xy * r8.xy); + r8 = vec4(r8.xy, v_116.xy); + let v_117 = (r8.zw * r8.zw); + r8 = vec4(r8.xy, v_117.xy); + let v_118 = (r8.xy * r8.zw); + r8 = vec4(v_118.xy, r8.zw); + r7.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f); + let v_119 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r7.ww); + r8 = vec4(v_119.xy, r8.zw); + let v_120 = (r4.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(r8.xy, v_120.xy); + r8.z = (r8.z * 0.125f); + r8.x = fma((-(r3.wwww)).x, r8.x, 1.0f); + r6.x = dot(r2.xyz, r6.xyz); + r6.x = clamp(((r6.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r6.x = log2(r6.x); + r6.x = (r6.x * r8.w); + r6.x = exp2(r6.x); + r6.x = (r8.y * r6.x); + r6.x = (r8.z * r6.x); + r6.x = (r3.w * r6.x); + r6.x = (r6.w * r6.x); + r6.y = (r6.w * r8.x); + let v_121 = fma(r0.xyz, r6.yyy, r6.xxx); + r6 = vec4(v_121.xyz, r6.w); + let v_122 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz); + r6 = vec4(v_122.xyz, r6.w); + r6.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r10 = vec4(vec3(), r10.w); + r9 = vec4(vec3(), r9.w); + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_123 = (v_19.xyz + cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_123.xyz, r9.w); + let v_124 = (v6.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r10 = vec4(v_124.xyz, r10.w); + r9.w = dot(r10.xyz, cb3_3.tint_symbol_2[11u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[19u].w); + let v_125 = fma(cb3_3.tint_symbol_2[11u].xyz, r9.www, cb3_3.tint_symbol_2[3u].xyz); + r10 = vec4(v_125.xyz, r10.w); + let v_126 = (r10.xyz + v_19.xyz); + r10 = vec4(v_126.xyz, r10.w); + let v_127 = bitcast>(r8.yyy); + let v_128 = r9.xyz; + let v_129 = select(r10.xyz, v_128, (v_127 != vec3())); + r9 = vec4(v_129.xyz, r9.w); + r8.y = dot(r9.xyz, r9.xyz); + let v_130 = (r9.xyz + vec3(0.00000099999999747524f)); + r9 = vec4(v_130.xyz, r9.w); + r9.w = dot(r9.xyz, r9.xyz); + r9.w = inverseSqrt(r9.w); + let v_131 = (r9.www * r9.xyz); + r9 = vec4(v_131.xyz, r9.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[11u].w); + r8.y = (r8.y / r9.w); + let v_132 = -(cb3_3.tint_symbol_2[11u].xyzx); + r9.w = dot(r9.xyz, v_132.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_133 = dot(r9.xyz, r2.xyz); + r10.x = clamp(vec4(v_133, v_133, v_133, v_133).x, 0.0f, 1.0f); + r9.w = (r9.w * r10.x); + r10.x = (r8.y * r9.w); + let v_134 = (r10.xxx * cb3_3.tint_symbol_2[19u].xyz); + r10 = vec4(v_134.xyz, r10.w); + let v_135 = (r0.xyz * r10.xyz); + r10 = vec4(v_135.xyz, r10.w); + let v_136 = fma(r4.xyz, r2.www, r9.xyz); + r9 = vec4(v_136.xyz, r9.w); + r10.w = dot(r9.xyz, r9.xyz); + r10.w = inverseSqrt(r10.w); + let v_137 = (r9.xyz * r10.www); + r9 = vec4(v_137.xyz, r9.w); + let v_138 = dot(r9.xyz, r5.xyz); + r10.w = clamp(vec4(v_138, v_138, v_138, v_138).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.x = (r10.w * r10.w); + r11.x = (r11.x * r11.x); + r10.w = (r10.w * r11.x); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_139 = dot(r9.xyz, r2.xyz); + r9.x = clamp(vec4(v_139, v_139, v_139, v_139).x, 0.0f, 1.0f); + r9.x = log2(r9.x); + r9.x = (r8.w * r9.x); + r9.x = exp2(r9.x); + r9.x = (r9.x * r10.w); + r9.x = (r9.w * r9.x); + r8.y = (r8.y * r9.x); + r8.y = (r8.z * r8.y); + let v_140 = (r8.yyy * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_140.xyz, r9.w); + } + r8.y = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r8.y) != 0u)) { + r9.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r8.y = bitcast((bitcast(r6.w) | bitcast(r8.y))); + let v_141 = bitcast(r9.w); + let v_142 = r8.y; + r6.w = select(r6.w, v_142, (v_141 != 0u)); + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_143 = (v_19.xyz + cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_143.xyz, r11.w); + let v_144 = (v6.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r12 = vec4(v_144.xyz, r12.w); + r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[12u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[20u].w); + let v_145 = fma(cb3_3.tint_symbol_2[12u].xyz, r9.www, cb3_3.tint_symbol_2[4u].xyz); + r12 = vec4(v_145.xyz, r12.w); + let v_146 = (r12.xyz + v_19.xyz); + r12 = vec4(v_146.xyz, r12.w); + let v_147 = bitcast>(r8.yyy); + let v_148 = r11.xyz; + let v_149 = select(r12.xyz, v_148, (v_147 != vec3())); + r11 = vec4(v_149.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_150 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_150.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_151 = (r9.www * r11.xyz); + r11 = vec4(v_151.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[12u].w); + r8.y = (r8.y / r9.w); + let v_152 = -(cb3_3.tint_symbol_2[12u].xyzx); + r9.w = dot(r11.xyz, v_152.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_153 = dot(r11.xyz, r2.xyz); + r10.w = clamp(vec4(v_153, v_153, v_153, v_153).w, 0.0f, 1.0f); + r9.w = (r9.w * r10.w); + r10.w = (r8.y * r9.w); + let v_154 = (r10.www * cb3_3.tint_symbol_2[20u].xyz); + r12 = vec4(v_154.xyz, r12.w); + let v_155 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_155.xyz, r10.w); + let v_156 = fma(r4.xyz, r2.www, r11.xyz); + r11 = vec4(v_156.xyz, r11.w); + r10.w = dot(r11.xyz, r11.xyz); + r10.w = inverseSqrt(r10.w); + let v_157 = (r10.www * r11.xyz); + r11 = vec4(v_157.xyz, r11.w); + let v_158 = dot(r11.xyz, r5.xyz); + r10.w = clamp(vec4(v_158, v_158, v_158, v_158).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.w = (r10.w * r10.w); + r11.w = (r11.w * r11.w); + r10.w = (r10.w * r11.w); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_159 = dot(r11.xyz, r2.xyz); + r11.x = clamp(vec4(v_159, v_159, v_159, v_159).x, 0.0f, 1.0f); + r11.x = log2(r11.x); + r11.x = (r8.w * r11.x); + r11.x = exp2(r11.x); + r10.w = (r10.w * r11.x); + r9.w = (r9.w * r10.w); + r8.y = (r8.y * r9.w); + r8.y = (r8.z * r8.y); + let v_160 = fma(r8.yyy, cb3_3.tint_symbol_2[20u].xyz, r9.xyz); + r9 = vec4(v_160.xyz, r9.w); + } + } else { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r8.y = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r8.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_161 = (v_19.xyz + cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_161.xyz, r11.w); + let v_162 = (v6.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r12 = vec4(v_162.xyz, r12.w); + r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[13u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[21u].w); + let v_163 = fma(cb3_3.tint_symbol_2[13u].xyz, r9.www, cb3_3.tint_symbol_2[5u].xyz); + r12 = vec4(v_163.xyz, r12.w); + let v_164 = (r12.xyz + v_19.xyz); + r12 = vec4(v_164.xyz, r12.w); + let v_165 = bitcast>(r8.yyy); + let v_166 = r11.xyz; + let v_167 = select(r12.xyz, v_166, (v_165 != vec3())); + r11 = vec4(v_167.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_168 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_168.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_169 = (r9.www * r11.xyz); + r11 = vec4(v_169.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[13u].w); + r8.y = (r8.y / r9.w); + let v_170 = -(cb3_3.tint_symbol_2[13u].xyzx); + r9.w = dot(r11.xyz, v_170.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_171 = dot(r11.xyz, r2.xyz); + r10.w = clamp(vec4(v_171, v_171, v_171, v_171).w, 0.0f, 1.0f); + r9.w = (r9.w * r10.w); + r10.w = (r8.y * r9.w); + let v_172 = (r10.www * cb3_3.tint_symbol_2[21u].xyz); + r12 = vec4(v_172.xyz, r12.w); + let v_173 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_173.xyz, r10.w); + let v_174 = fma(r4.xyz, r2.www, r11.xyz); + r11 = vec4(v_174.xyz, r11.w); + r10.w = dot(r11.xyz, r11.xyz); + r10.w = inverseSqrt(r10.w); + let v_175 = (r10.www * r11.xyz); + r11 = vec4(v_175.xyz, r11.w); + let v_176 = dot(r11.xyz, r5.xyz); + r10.w = clamp(vec4(v_176, v_176, v_176, v_176).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.w = (r10.w * r10.w); + r11.w = (r11.w * r11.w); + r10.w = (r10.w * r11.w); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_177 = dot(r11.xyz, r2.xyz); + r11.x = clamp(vec4(v_177, v_177, v_177, v_177).x, 0.0f, 1.0f); + r11.x = log2(r11.x); + r11.x = (r8.w * r11.x); + r11.x = exp2(r11.x); + r10.w = (r10.w * r11.x); + r9.w = (r9.w * r10.w); + r8.y = (r8.y * r9.w); + r8.y = (r8.z * r8.y); + let v_178 = fma(r8.yyy, cb3_3.tint_symbol_2[21u].xyz, r9.xyz); + r9 = vec4(v_178.xyz, r9.w); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r8.y = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r8.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_179 = (v_19.xyz + cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_179.xyz, r11.w); + let v_180 = (v6.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r12 = vec4(v_180.xyz, r12.w); + r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[14u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[22u].w); + let v_181 = fma(cb3_3.tint_symbol_2[14u].xyz, r9.www, cb3_3.tint_symbol_2[6u].xyz); + r12 = vec4(v_181.xyz, r12.w); + let v_182 = (r12.xyz + v_19.xyz); + r12 = vec4(v_182.xyz, r12.w); + let v_183 = bitcast>(r8.yyy); + let v_184 = r11.xyz; + let v_185 = select(r12.xyz, v_184, (v_183 != vec3())); + r11 = vec4(v_185.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_186 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_186.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_187 = (r9.www * r11.xyz); + r11 = vec4(v_187.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[14u].w); + r8.y = (r8.y / r9.w); + let v_188 = -(cb3_3.tint_symbol_2[14u].xyzx); + r9.w = dot(r11.xyz, v_188.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_189 = dot(r11.xyz, r2.xyz); + r10.w = clamp(vec4(v_189, v_189, v_189, v_189).w, 0.0f, 1.0f); + r9.w = (r9.w * r10.w); + r10.w = (r8.y * r9.w); + let v_190 = (r10.www * cb3_3.tint_symbol_2[22u].xyz); + r12 = vec4(v_190.xyz, r12.w); + let v_191 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_191.xyz, r10.w); + let v_192 = fma(r4.xyz, r2.www, r11.xyz); + r11 = vec4(v_192.xyz, r11.w); + r10.w = dot(r11.xyz, r11.xyz); + r10.w = inverseSqrt(r10.w); + let v_193 = (r10.www * r11.xyz); + r11 = vec4(v_193.xyz, r11.w); + let v_194 = dot(r11.xyz, r5.xyz); + r10.w = clamp(vec4(v_194, v_194, v_194, v_194).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.w = (r10.w * r10.w); + r11.w = (r11.w * r11.w); + r10.w = (r10.w * r11.w); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_195 = dot(r11.xyz, r2.xyz); + r11.x = clamp(vec4(v_195, v_195, v_195, v_195).x, 0.0f, 1.0f); + r11.x = log2(r11.x); + r11.x = (r8.w * r11.x); + r11.x = exp2(r11.x); + r10.w = (r10.w * r11.x); + r9.w = (r9.w * r10.w); + r8.y = (r8.y * r9.w); + r8.y = (r8.z * r8.y); + let v_196 = fma(r8.yyy, cb3_3.tint_symbol_2[22u].xyz, r9.xyz); + r9 = vec4(v_196.xyz, r9.w); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r8.y = bitcast(select(0u, 4294967295u, (4i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r8.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f))); + let v_197 = (v_19.xyz + cb3_3.tint_symbol_2[7u].xyz); + r11 = vec4(v_197.xyz, r11.w); + let v_198 = (v6.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz); + r12 = vec4(v_198.xyz, r12.w); + r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[15u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[23u].w); + let v_199 = fma(cb3_3.tint_symbol_2[15u].xyz, r9.www, cb3_3.tint_symbol_2[7u].xyz); + r12 = vec4(v_199.xyz, r12.w); + let v_200 = (r12.xyz + v_19.xyz); + r12 = vec4(v_200.xyz, r12.w); + let v_201 = bitcast>(r8.yyy); + let v_202 = r11.xyz; + let v_203 = select(r12.xyz, v_202, (v_201 != vec3())); + r11 = vec4(v_203.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_204 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_204.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_205 = (r9.www * r11.xyz); + r11 = vec4(v_205.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[7u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[15u].w); + r8.y = (r8.y / r9.w); + let v_206 = -(cb3_3.tint_symbol_2[15u].xyzx); + r9.w = dot(r11.xyz, v_206.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f); + let v_207 = dot(r11.xyz, r2.xyz); + r10.w = clamp(vec4(v_207, v_207, v_207, v_207).w, 0.0f, 1.0f); + r9.w = (r9.w * r10.w); + r10.w = (r8.y * r9.w); + let v_208 = (r10.www * cb3_3.tint_symbol_2[23u].xyz); + r12 = vec4(v_208.xyz, r12.w); + let v_209 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_209.xyz, r10.w); + let v_210 = fma(r4.xyz, r2.www, r11.xyz); + r11 = vec4(v_210.xyz, r11.w); + r10.w = dot(r11.xyz, r11.xyz); + r10.w = inverseSqrt(r10.w); + let v_211 = (r10.www * r11.xyz); + r11 = vec4(v_211.xyz, r11.w); + let v_212 = dot(r11.xyz, r5.xyz); + r10.w = clamp(vec4(v_212, v_212, v_212, v_212).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.w = (r10.w * r10.w); + r11.w = (r11.w * r11.w); + r10.w = (r10.w * r11.w); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_213 = dot(r11.xyz, r2.xyz); + r11.x = clamp(vec4(v_213, v_213, v_213, v_213).x, 0.0f, 1.0f); + r11.x = log2(r11.x); + r11.x = (r8.w * r11.x); + r11.x = exp2(r11.x); + r10.w = (r10.w * r11.x); + r9.w = (r9.w * r10.w); + r8.y = (r8.y * r9.w); + r8.y = (r8.z * r8.y); + let v_214 = fma(r8.yyy, cb3_3.tint_symbol_2[23u].xyz, r9.xyz); + r9 = vec4(v_214.xyz, r9.w); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r8.y = bitcast(select(0u, 4294967295u, (5i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r8.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f))); + let v_215 = (v_19.xyz + cb3_3.tint_symbol_2[8u].xyz); + r11 = vec4(v_215.xyz, r11.w); + let v_216 = (v6.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz); + r12 = vec4(v_216.xyz, r12.w); + r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[16u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[24u].w); + let v_217 = fma(cb3_3.tint_symbol_2[16u].xyz, r9.www, cb3_3.tint_symbol_2[8u].xyz); + r12 = vec4(v_217.xyz, r12.w); + let v_218 = (r12.xyz + v_19.xyz); + r12 = vec4(v_218.xyz, r12.w); + let v_219 = bitcast>(r8.yyy); + let v_220 = r11.xyz; + let v_221 = select(r12.xyz, v_220, (v_219 != vec3())); + r11 = vec4(v_221.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_222 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_222.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_223 = (r9.www * r11.xyz); + r11 = vec4(v_223.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[8u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[16u].w); + r8.y = (r8.y / r9.w); + let v_224 = -(cb3_3.tint_symbol_2[16u].xyzx); + r9.w = dot(r11.xyz, v_224.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f); + let v_225 = dot(r11.xyz, r2.xyz); + r10.w = clamp(vec4(v_225, v_225, v_225, v_225).w, 0.0f, 1.0f); + r9.w = (r9.w * r10.w); + r10.w = (r8.y * r9.w); + let v_226 = (r10.www * cb3_3.tint_symbol_2[24u].xyz); + r12 = vec4(v_226.xyz, r12.w); + let v_227 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_227.xyz, r10.w); + let v_228 = fma(r4.xyz, r2.www, r11.xyz); + r11 = vec4(v_228.xyz, r11.w); + r10.w = dot(r11.xyz, r11.xyz); + r10.w = inverseSqrt(r10.w); + let v_229 = (r10.www * r11.xyz); + r11 = vec4(v_229.xyz, r11.w); + let v_230 = dot(r11.xyz, r5.xyz); + r10.w = clamp(vec4(v_230, v_230, v_230, v_230).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.w = (r10.w * r10.w); + r11.w = (r11.w * r11.w); + r10.w = (r10.w * r11.w); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_231 = dot(r11.xyz, r2.xyz); + r11.x = clamp(vec4(v_231, v_231, v_231, v_231).x, 0.0f, 1.0f); + r11.x = log2(r11.x); + r11.x = (r8.w * r11.x); + r11.x = exp2(r11.x); + r10.w = (r10.w * r11.x); + r9.w = (r9.w * r10.w); + r8.y = (r8.y * r9.w); + r8.y = (r8.z * r8.y); + let v_232 = fma(r8.yyy, cb3_3.tint_symbol_2[24u].xyz, r9.xyz); + r9 = vec4(v_232.xyz, r9.w); + } + } + if ((bitcast(r6.w) != 0u)) { + r6.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r8.y = bitcast(select(0u, 4294967295u, (6i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r8.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f))); + let v_233 = (v_19.xyz + cb3_3.tint_symbol_2[9u].xyz); + r11 = vec4(v_233.xyz, r11.w); + let v_234 = (v6.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz); + r12 = vec4(v_234.xyz, r12.w); + r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[17u].xyz); + r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f); + r9.w = (r9.w * cb3_3.tint_symbol_2[25u].w); + let v_235 = fma(cb3_3.tint_symbol_2[17u].xyz, r9.www, cb3_3.tint_symbol_2[9u].xyz); + r12 = vec4(v_235.xyz, r12.w); + let v_236 = (r12.xyz + v_19.xyz); + r12 = vec4(v_236.xyz, r12.w); + let v_237 = bitcast>(r8.yyy); + let v_238 = r11.xyz; + let v_239 = select(r12.xyz, v_238, (v_237 != vec3())); + r11 = vec4(v_239.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + let v_240 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_240.xyz, r11.w); + r9.w = dot(r11.xyz, r11.xyz); + r9.w = inverseSqrt(r9.w); + let v_241 = (r9.www * r11.xyz); + r11 = vec4(v_241.xyz, r11.w); + r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[9u].wwww, vec4(1.0f)).y, 0.0f, 1.0f); + r9.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f); + r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[17u].w); + r8.y = (r8.y / r9.w); + let v_242 = -(cb3_3.tint_symbol_2[17u].xyzx); + r9.w = dot(r11.xyz, v_242.xyz); + r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f); + let v_243 = dot(r11.xyz, r2.xyz); + r10.w = clamp(vec4(v_243, v_243, v_243, v_243).w, 0.0f, 1.0f); + r9.w = (r9.w * r10.w); + r10.w = (r8.y * r9.w); + let v_244 = (r10.www * cb3_3.tint_symbol_2[25u].xyz); + r12 = vec4(v_244.xyz, r12.w); + let v_245 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_245.xyz, r10.w); + let v_246 = fma(r4.xyz, r2.www, r11.xyz); + r11 = vec4(v_246.xyz, r11.w); + r10.w = dot(r11.xyz, r11.xyz); + r10.w = inverseSqrt(r10.w); + let v_247 = (r10.www * r11.xyz); + r11 = vec4(v_247.xyz, r11.w); + let v_248 = dot(r11.xyz, r5.xyz); + r10.w = clamp(vec4(v_248, v_248, v_248, v_248).w, 0.0f, 1.0f); + r10.w = ((-(r10.wwww)).w + 1.0f); + r11.w = (r10.w * r10.w); + r11.w = (r11.w * r11.w); + r10.w = (r10.w * r11.w); + r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w); + let v_249 = dot(r11.xyz, r2.xyz); + r11.x = clamp(vec4(v_249, v_249, v_249, v_249).x, 0.0f, 1.0f); + r11.x = log2(r11.x); + r11.x = (r8.w * r11.x); + r11.x = exp2(r11.x); + r10.w = (r10.w * r11.x); + r9.w = (r9.w * r10.w); + r8.y = (r8.y * r9.w); + r8.y = (r8.z * r8.y); + let v_250 = fma(r8.yyy, cb3_3.tint_symbol_2[25u].xyz, r9.xyz); + r9 = vec4(v_250.xyz, r9.w); + } + } + if ((bitcast(r6.w) != 0u)) { + } else { + r8.y = bitcast(select(0u, 4294967295u, (7i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r6.w) | bitcast(r8.y))); + if ((bitcast(r6.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f))); + let v_251 = (v_19.xyz + cb3_3.tint_symbol_2[10u].xyz); + r11 = vec4(v_251.xyz, r11.w); + let v_252 = (v6.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz); + r12 = vec4(v_252.xyz, r12.w); + r8.y = dot(r12.xyz, cb3_3.tint_symbol_2[18u].xyz); + r8.y = clamp(((r8.yyyy / cb3_3.tint_symbol_2[26u].wwww)).y, 0.0f, 1.0f); + r8.y = (r8.y * cb3_3.tint_symbol_2[26u].w); + let v_253 = fma(cb3_3.tint_symbol_2[18u].xyz, r8.yyy, cb3_3.tint_symbol_2[10u].xyz); + r12 = vec4(v_253.xyz, r12.w); + let v_254 = (r12.xyz + v_19.xyz); + r12 = vec4(v_254.xyz, r12.w); + let v_255 = bitcast>(r6.www); + let v_256 = r11.xyz; + let v_257 = select(r12.xyz, v_256, (v_255 != vec3())); + r11 = vec4(v_257.xyz, r11.w); + r6.w = dot(r11.xyz, r11.xyz); + let v_258 = (r11.xyz + vec3(0.00000099999999747524f)); + r11 = vec4(v_258.xyz, r11.w); + r8.y = dot(r11.xyz, r11.xyz); + r8.y = inverseSqrt(r8.y); + let v_259 = (r8.yyy * r11.xyz); + r11 = vec4(v_259.xyz, r11.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r8.y = ((-(cb3_3.tint_symbol_2[18u].wwww)).y + 1.0f); + r8.y = fma(r8.y, r6.w, cb3_3.tint_symbol_2[18u].w); + r6.w = (r6.w / r8.y); + let v_260 = -(cb3_3.tint_symbol_2[18u].xyzx); + r8.y = dot(r11.xyz, v_260.xyz); + r8.y = clamp(fma(r8.yyyy, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).y, 0.0f, 1.0f); + let v_261 = dot(r11.xyz, r2.xyz); + r9.w = clamp(vec4(v_261, v_261, v_261, v_261).w, 0.0f, 1.0f); + r8.y = (r8.y * r9.w); + r9.w = (r6.w * r8.y); + let v_262 = (r9.www * cb3_3.tint_symbol_2[26u].xyz); + r12 = vec4(v_262.xyz, r12.w); + let v_263 = fma(r12.xyz, r0.xyz, r10.xyz); + r10 = vec4(v_263.xyz, r10.w); + let v_264 = fma(r4.xyz, r2.www, r11.xyz); + r4 = vec4(v_264.xyz, r4.w); + r2.w = dot(r4.xyz, r4.xyz); + r2.w = inverseSqrt(r2.w); + let v_265 = (r2.www * r4.xyz); + r4 = vec4(v_265.xyz, r4.w); + let v_266 = dot(r4.xyz, r5.xyz); + r2.w = clamp(vec4(v_266, v_266, v_266, v_266).w, 0.0f, 1.0f); + r2.w = ((-(r2.wwww)).w + 1.0f); + r5.x = (r2.w * r2.w); + r5.x = (r5.x * r5.x); + r2.w = (r2.w * r5.x); + r2.w = fma(cb12_12.tint_symbol_4[0u].x, r2.w, r7.w); + let v_267 = dot(r4.xyz, r2.xyz); + r4.x = clamp(vec4(v_267, v_267, v_267, v_267).x, 0.0f, 1.0f); + r4.x = log2(r4.x); + r4.x = (r4.x * r8.w); + r4.x = exp2(r4.x); + r2.w = (r2.w * r4.x); + r2.w = (r8.y * r2.w); + r2.w = (r6.w * r2.w); + r2.w = (r8.z * r2.w); + let v_268 = fma(r2.www, cb3_3.tint_symbol_2[26u].xyz, r9.xyz); + r9 = vec4(v_268.xyz, r9.w); + } + } + r2.w = (r8.x * r8.x); + r3.w = (r3.w * r3.w); + let v_269 = (r9.xyz * r3.www); + r4 = vec4(v_269.xyz, r4.w); + let v_270 = fma(r2.www, r10.xyz, r4.xyz); + r4 = vec4(v_270.xyz, r4.w); + let v_271 = fma(r6.xyz, r5.www, r4.xyz); + r4 = vec4(v_271.xyz, r4.w); + r1.z = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.z = (r1.z * cb3_3.tint_symbol_2[44u].w); + r1.z = max(r1.z, 0.0f); + let v_272 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.zzz, cb3_3.tint_symbol_2[48u].xyz); + r5 = vec4(v_272.xyz, r5.w); + r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_273 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.zzz, cb3_3.tint_symbol_2[46u].xyz); + r6 = vec4(v_273.xyz, r6.w); + let v_274 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz); + r6 = vec4(v_274.xyz, r6.w); + let v_275 = fma(r5.xyz, r1.www, r6.xyz); + r5 = vec4(v_275.xyz, r5.w); + let v_276 = (r1.yyy * r5.xyz); + r5 = vec4(v_276.xyz, r5.w); + let v_277 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.zzz, cb3_3.tint_symbol_2[44u].xyz); + r6 = vec4(v_277.xyz, r6.w); + r9.x = cb3_3.tint_symbol_2[46u].w; + r9.y = cb3_3.tint_symbol_2[47u].w; + r9.z = cb3_3.tint_symbol_2[48u].w; + let v_278 = dot(r9.xyz, r2.xyz); + r1.z = clamp(vec4(v_278, v_278, v_278, v_278).z, 0.0f, 1.0f); + let v_279 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.zzz, r6.xyz); + r2 = vec4(v_279.xyz, r2.w); + let v_280 = fma(r2.xyz, r1.xxx, r5.xyz); + r2 = vec4(v_280.xyz, r2.w); + let v_281 = (r8.xxx * r2.xyz); + r2 = vec4(v_281.xyz, r2.w); + let v_282 = fma(r2.xyz, r0.xyz, r4.xyz); + r0 = vec4(v_282.xyz, r0.w); + r1.z = ((-(r8.xxxx)).z + 1.0f); + r1.x = max(r1.y, r1.x); + let v_283 = (r1.xxx * r3.xyz); + r1 = vec4(v_283.xy, r1.z, v_283.z); + r2.x = clamp(((r4.wwww * vec4(0.00177619897294789553f))).x, 0.0f, 1.0f); + let v_284 = (r1.xyw * r2.xxx); + r2 = vec4(v_284.xyz, r2.w); + let v_285 = (r2.xyz * vec3(0.68169009685516357422f)); + r2 = vec4(v_285.xyz, r2.w); + let v_286 = fma(r1.xyw, vec3(0.31830990314483642578f), r2.xyz); + r1 = vec4(v_286.xy, r1.z, v_286.z); + let v_287 = fma(r1.xyw, r1.zzz, r0.xyz); + r0 = vec4(v_287.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r7.xyz, r7.xyz); + r1.x = sqrt(r0.w); + let v_288 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_288.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r7.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_289 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_289 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_290 = (r0.www * r7.xyz); + r2 = vec4(v_290.xyz, r2.w); + let v_291 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_291, v_291, v_291, v_291).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_292 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_292, v_292, v_292, v_292).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_293 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_293.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_294 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_294.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_295 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_295.xyz, r2.w); + let v_296 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_296.xyz, r2.w); + let v_297 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_297.xyz, r3.w); + let v_298 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_298.xyz, r2.w); + let v_299 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_300 = (r2.xyz + v_299.xyz); + r2 = vec4(v_300.xyz, r2.w); + let v_301 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_301.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_302 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_302.xyz, r3.w); + let v_303 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_303.xy, r1.z, v_303.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_304 = (v7.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_304.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_305 = -(r0.xyxz); + let v_306 = fma(r1.xyw, r0.www, v_305.xyw); + r1 = vec4(v_306.xy, r1.z, v_306.z); + let v_307 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_307.xyz, r1.w); + } else { + r0.w = dot(r7.xyz, r7.xyz); + r1.w = sqrt(r0.w); + let v_308 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_308.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r7.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_309 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_309 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_310 = (r0.www * r7.xyz); + r3 = vec4(v_310.xyz, r3.w); + let v_311 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_311, v_311, v_311, v_311).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_312 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_312, v_312, v_312, v_312).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_313 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_313.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_314 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_314.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_315 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_315.xyz, r3.w); + let v_316 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_316.xyz, r3.w); + let v_317 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_317.xyz, r4.w); + let v_318 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_318.xyz, r3.w); + let v_319 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_320 = (r3.xyz + v_319.xyz); + r3 = vec4(v_320.xyz, r3.w); + let v_321 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_321.x, r2.y, v_321.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_322 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_322.xyz, r3.w); + let v_323 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_323.x, r2.y, v_323.yz); + let v_324 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_324.x, r2.y, v_324.yz); + let v_325 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_325.xyz, r1.w); + } + let v_326 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_326.xyz, o0.w); +} + +fn v_3(v_327 : bool) { + if (v_327) { + discard; + return; + } +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @builtin(position) v_328 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v_328); + return o0; +} diff --git a/b/8b0b5899ed/shaders/01501115438bef35.consts.json b/b/8b0b5899ed/shaders/01501115438bef35.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/01501115438bef35.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/01501115438bef35.wgsl b/b/8b0b5899ed/shaders/01501115438bef35.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..eba7ba9ded7cd18d93dbf6c8e3a03816bc23b02c --- /dev/null +++ b/b/8b0b5899ed/shaders/01501115438bef35.wgsl @@ -0,0 +1,1260 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v7 : vec4; + +var v8 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v7 = v_2; + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t3, s3, v1.xy.xyxx.xy); + r0.z = dot(v6.xyz, v6.xyz); + r0.z = inverseSqrt(r0.z); + let v_3 = (r0.zz * v6.xy); + r1 = vec4(v_3.xy, r1.zw); + let v_4 = ((-(r1.xyxx)).xy * cb12_12.tint_symbol_4[0u].yy); + r1 = vec4(v_4.xy, r1.zw); + r1 = vec4(r1.xy, v1.xy.xy); + let v_5 = r0; + let v_6 = r2; + r2 = vec4(v_6.x, v_5.xy, v_6.w); + r2.x = -1.0f; + r2.w = (-(r0.wwww)).w; + r0.z = 0.0f; + loop { + r3.x = bitcast(select(0u, 4294967295u, (bitcast(r0.z) >= 8i))); + if ((bitcast(r3.x) != 0u)) { + break; + } + let v_7 = fma(r1.xy, vec2(0.125f), r1.zw); + r3 = vec4(v_7.xy, r3.zw); + r4 = textureSample(t3, s3, r3.xyxx.xy); + r3.z = bitcast(select(0u, 4294967295u, (r2.x < r2.w))); + r5.x = (r2.x + 0.125f); + let v_8 = bitcast>(r3.zz); + let v_9 = r3.xy; + let v_10 = select(r1.zw, v_9, (v_8 != vec2())); + r1 = vec4(r1.xy, v_10.xy); + let v_11 = (r4.xyw * vec3(1.0f, 1.0f, -1.0f)); + r5 = vec4(r5.x, v_11.xyz); + let v_12 = bitcast>(r3.zzzz); + let v_13 = r5; + r2 = select(r2, v_13, (v_12 != vec4())); + r0.z = bitcast((bitcast(r0.z) + 1i)); + } + r0 = textureSample(t0, s0, r1.zwzz.xy); + let v_14 = fma(r2.yz, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_14.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[1u].y, 0.00100000004749745131f); + let v_15 = (r1.ww * r1.xy); + r1 = vec4(v_15.xy, r1.zw); + let v_16 = (r1.yyy * v4.xyz); + r3 = vec4(v_16.xyz, r3.w); + let v_17 = fma(r1.xxx, v3.xyz, r3.xyz); + r1 = vec4(v_17.xy, r1.z, v_17.z); + let v_18 = fma(r1.zzz, v2.xyz, r1.xyw); + r1 = vec4(v_18.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_19 = (r1.www * r1.xyz); + r3 = vec4(v_19.xyz, r3.w); + r1.x = dot(r2.yz, r2.yz); + r1.x = bitcast(select(0u, 4294967295u, (r1.x >= 0.00200000009499490261f))); + r1.x = bitcast((bitcast(r1.x) & 1065353216u)); + let v_20 = (r0.xyz * r1.xxx); + r0 = vec4(v_20.xyz, r0.w); + let v_21 = (r1.xxx * v0.xyz); + r2 = vec4(v_21.xyz, r2.w); + r1.x = clamp(((r1.xxxx * cb12_12.tint_symbol_4[1u].xxxx)).x, 0.0f, 1.0f); + r2.w = v0.w; + r0 = (r0 * r2); + let v_22 = (r0.xyz * r0.xyz); + r0 = vec4(v_22.xyz, r0.w); + let v_23 = -(v5.xyzx); + let v_24 = (v_23.xyz + cb1_1.tint_symbol[15u].xyz); + r2 = vec4(v_24.xyz, r2.w); + r1.y = dot(r2.xyz, r2.xyz); + r1.y = inverseSqrt(r1.y); + let v_25 = (r1.yyy * r2.xyz); + r4 = vec4(v_25.xyz, r4.w); + let v_26 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_27 = fma(r2.xyz, r1.yyy, v_26.xyz); + r5 = vec4(v_27.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + r2.w = inverseSqrt(r2.w); + let v_28 = (r2.www * r5.xyz); + r5 = vec4(v_28.xyz, r5.w); + let v_29 = (cb2_2.tint_symbol_1[15u].zy * cb2_2.tint_symbol_1[15u].zy); + r6 = vec4(v_29.xy, r6.zw); + r2.w = (cb12_12.tint_symbol_4[0u].w + -500.0f); + r2.w = max(r2.w, 0.0f); + r3.w = ((-(r2.wwww)).w + cb12_12.tint_symbol_4[0u].w); + r2.w = (r2.w * 558.0f); + r2.w = fma(r3.w, 3.0f, r2.w); + r3.w = dot(r2.xyz, cb1_1.tint_symbol[14u].xyz); + let v_30 = (v5.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r7 = vec4(v_30.xyz, r7.w); + let v_31 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_31.xyz, r8.w); + let v_32 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_32.xyz, r8.w); + let v_33 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_33.xyz, r8.w); + let v_34 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_34.xyz, r9.w); + let v_35 = &(x0[0u]); + let v_36 = r9; + *(v_35) = vec4(v_36.xyz, (*(v_35)).w); + let v_37 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_37.xyz, r10.w); + let v_38 = &(x0[1u]); + let v_39 = r10; + *(v_38) = vec4(v_39.xyz, (*(v_38)).w); + let v_40 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_40.xyz, r11.w); + let v_41 = &(x0[2u]); + let v_42 = r11; + *(v_41) = vec4(v_42.xyz, (*(v_41)).w); + let v_43 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_43.xyz, r8.w); + let v_44 = &(x0[3u]); + let v_45 = r8; + *(v_44) = vec4(v_45.xyz, (*(v_44)).w); + let v_46 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_47 = r12; + r12 = vec4(v_47.x, v_46.x, v_47.z, v_46.y); + r4.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r4.w = (r4.w * 0.5f); + let v_48 = abs(r11.yyyy); + r5.w = max(v_48.w, abs(r11.xxxx).w); + r5.w = bitcast(select(0u, 4294967295u, (r5.w < r4.w))); + let v_49 = (bitcast(r5.w) != 0u); + let v_50 = bitcast(v.tint_symbol_6[0i].x); + r5.w = select(bitcast(v.tint_symbol_6[1i].x), v_50, v_49); + let v_51 = abs(r10.yyyy); + r6.z = max(v_51.z, abs(r10.xxxx).z); + r6.z = bitcast(select(0u, 4294967295u, (r6.z < r4.w))); + let v_52 = bitcast(r6.z); + r5.w = select(r5.w, bitcast(v.tint_symbol_6[2i].x), (v_52 != 0u)); + let v_53 = abs(r9.yyyy); + r6.z = max(v_53.z, abs(r9.xxxx).z); + r4.w = bitcast(select(0u, 4294967295u, (r6.z < r4.w))); + let v_54 = bitcast(r4.w); + r4.w = select(r5.w, 0.0f, (v_54 != 0u)); + let v_55 = x0[bitcast(r4.w)]; + r9 = vec4(v_55.xyz, r9.w); + r4.w = f32(bitcast(r4.w)); + r5.w = (r4.w + 0.5f); + r5.w = (r5.w * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r4.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r4.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r6.z = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r5.w); + r5.w = bitcast(select(0u, 4294967295u, !((r4.w == 0.0f)))); + r4.w = ((-(r4.wwww)).w + r9.z); + let v_56 = dpdx(r10.xyy); + r11 = vec4(v_56.xy, r11.z, v_56.z); + r11.z = dpdx(r4.w); + let v_57 = dpdy(r10.yxy); + r13 = vec4(v_57.xyz, r13.w); + r13.w = dpdy(r4.w); + let v_58 = (r11.yw * r13.yw); + r8 = vec4(r8.xy, v_58.xy); + let v_59 = -(r8.zwzz); + let v_60 = fma(r11.xz, r13.xz, v_59.xy); + r14 = vec4(v_60.xy, r14.zw); + r6.w = (1.0f / r14.x); + r7.w = (r11.z * r13.y); + let v_61 = -(r7.wwww); + r14.z = fma(r11.x, r13.w, v_61.z); + let v_62 = (r6.ww * r14.yz); + r8 = vec4(r8.xy, v_62.xy); + let v_63 = max(r8.zw, vec2()); + r8 = vec4(r8.xy, v_63.xy); + let v_64 = min(r8.zw, vec2(0.5f)); + r8 = vec4(r8.xy, v_64.xy); + r4.w = fma((-(r6.zzzz)).w, r8.z, r4.w); + r4.w = fma((-(r6.zzzz)).w, r8.w, r4.w); + let v_65 = bitcast(r5.w); + let v_66 = r4.w; + r12.z = select(r9.z, v_66, (v_65 != 0u)); + r10.z = 0.0f; + let v_67 = (r10.xyz + r12.ywz); + r9 = vec4(v_67.xyz, r9.w); + let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_68.xy, r12.zw); + let v_69 = (r10.xyz + r12.xyz); + r11 = vec4(v_69.xyz, r11.w); + let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_70.xy, r12.zw); + let v_71 = (r10.xyz + r12.xyz); + r13 = vec4(v_71.xyz, r13.w); + let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_72.xy, r12.zw); + let v_73 = (r10.xyz + r12.xyz); + r14 = vec4(v_73.xyz, r14.w); + let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_74.xy, r12.zw); + let v_75 = (r10.xyz + r12.xyz); + r15 = vec4(v_75.xyz, r15.w); + let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_76.xy, r12.zw); + let v_77 = (r10.xyz + r12.xyz); + r16 = vec4(v_77.xyz, r16.w); + let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_78.xy, r12.zw); + let v_79 = (r10.xyz + r12.xyz); + r17 = vec4(v_79.xyz, r17.w); + let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_80.xy, r12.zw); + let v_81 = (r10.xyz + r12.xyz); + r18 = vec4(v_81.xyz, r18.w); + let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_82.xy, r12.zw); + let v_83 = (r10.xyz + r12.xyz); + r19 = vec4(v_83.xyz, r19.w); + let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_84.xy, r12.zw); + let v_85 = (r10.xyz + r12.xyz); + r20 = vec4(v_85.xyz, r20.w); + let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_86.xy, r12.zw); + let v_87 = (r10.xyz + r12.xyz); + r21 = vec4(v_87.xyz, r21.w); + let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_88.xy, r12.zw); + let v_89 = (r10.xyz + r12.xyz); + r22 = vec4(v_89.xyz, r22.w); + let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_90.xy, r12.zw); + let v_91 = (r10.xyz + r12.xyz); + r23 = vec4(v_91.xyz, r23.w); + let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_92.xy, r12.zw); + let v_93 = (r10.xyz + r12.xyz); + r24 = vec4(v_93.xyz, r24.w); + let v_94 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_94.xy, r12.zw); + let v_95 = (r10.xyz + r12.xyz); + r25 = vec4(v_95.xyz, r25.w); + let v_96 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_96.xy, r12.zw); + let v_97 = (r10.xyz + r12.xyz); + r10 = vec4(v_97.xyz, r10.w); + let v_98 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_98.xy, r9.z); + let v_99 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_99.xy, r11.z); + let v_100 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_100.xy, r13.z); + let v_101 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_101.xy, r14.z); + let v_102 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_102.xy, r15.z); + let v_103 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_103.xy, r16.z); + let v_104 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_104.xy, r17.z); + let v_105 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_105.xy, r18.z); + let v_106 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_106.xy, r19.z); + let v_107 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_107.xy, r20.z); + let v_108 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_108.xy, r21.z); + let v_109 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_109.xy, r22.z); + let v_110 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_110.xy, r23.z); + let v_111 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_111.xy, r24.z); + let v_112 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_112.xy, r25.z); + let v_113 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_113.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r4.w = dot(r9, vec4(1.0f)); + r3.w = clamp(fma(r3.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f); + let v_114 = abs(r8.yyyy); + r5.w = max(v_114.w, abs(r8.xxxx).w); + r5.w = clamp(fma(r5.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r3.w = ((-(r3.wwww)).w + 1.0f); + r3.w = (r5.w * r3.w); + r3.w = fma(r4.w, 0.0625f, r3.w); + r3.w = (r3.w * r3.w); + r3.w = min(r3.w, 1.0f); + r4.w = clamp(fma(v5.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r4.w = sqrt(r4.w); + r4.w = (r4.w * cb6_6.tint_symbol_5[3u].z); + let v_115 = -(r3.wwww); + r3.w = fma(r4.w, v_115.w, r3.w); + r4.w = dot(r3.xyz, v_26.xyz); + r5.w = clamp(r4.wwww.w, 0.0f, 1.0f); + r5.w = ((-(abs(r4.wwww))).w + r5.w); + let v_116 = abs(r4.wwww); + r4.w = fma(r0.w, r5.w, v_116.w); + let v_117 = dot(r4.xyz, r3.xyz); + r8.x = clamp(vec4(v_117, v_117, v_117, v_117).x, 0.0f, 1.0f); + let v_118 = dot(r5.xyz, v_26.xyz); + r8.y = clamp(vec4(v_118, v_118, v_118, v_118).y, 0.0f, 1.0f); + let v_119 = ((-(r8.xxxy)).zw + vec2(1.0f)); + r6 = vec4(r6.xy, v_119.xy); + let v_120 = (r6.zw * r6.zw); + r8 = vec4(v_120.xy, r8.zw); + let v_121 = (r8.xy * r8.xy); + r8 = vec4(v_121.xy, r8.zw); + let v_122 = (r6.zw * r8.xy); + r6 = vec4(r6.xy, v_122.xy); + r5.w = ((-(cb12_12.tint_symbol_4[0u].zzzz)).w + 1.0f); + let v_123 = fma(cb12_12.tint_symbol_4[0u].zz, r6.zw, r5.ww); + r6 = vec4(r6.xy, v_123.xy); + let v_124 = (r2.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(v_124.xy, r8.zw); + r2.w = (r8.x * 0.125f); + r6.z = fma((-(r1.xxxx)).z, r6.z, 1.0f); + r5.x = dot(r3.xyz, r5.xyz); + r5.x = clamp(((r5.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r5.x = log2(r5.x); + r5.x = (r5.x * r8.y); + r5.x = exp2(r5.x); + r5.x = (r6.w * r5.x); + r5.x = (r2.w * r5.x); + r5.x = (r1.x * r5.x); + r5.x = (r4.w * r5.x); + r4.w = (r4.w * r6.z); + let v_125 = fma(r0.xyz, r4.www, r5.xxx); + r5 = vec4(v_125.xyz, r5.w); + let v_126 = (r5.xyz * cb3_3.tint_symbol_2[1u].xyz); + r5 = vec4(v_126.xyz, r5.w); + r4.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r4.w) != 0u)) { + r9 = vec4(vec3(), r9.w); + r8 = vec4(0.0f, r8.y, vec2()); + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_127 = ((-(v5.xxyz)).xzw + cb3_3.tint_symbol_2[3u].xyz); + r8 = vec4(v_127.x, r8.y, v_127.yz); + let v_128 = (v5.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r9 = vec4(v_128.xyz, r9.w); + r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w); + let v_129 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_129.xyz, r9.w); + let v_130 = (r9.xyz + v_23.xyz); + r9 = vec4(v_130.xyz, r9.w); + let v_131 = bitcast>(r6.www); + let v_132 = r8.xzw; + let v_133 = select(r9.xyz, v_132, (v_131 != vec3())); + r8 = vec4(v_133.x, r8.y, v_133.yz); + r6.w = dot(r8.xzw, r8.xzw); + let v_134 = (r8.xzw + vec3(0.00000099999999747524f)); + r8 = vec4(v_134.x, r8.y, v_134.yz); + r7.w = dot(r8.xzw, r8.xzw); + r7.w = inverseSqrt(r7.w); + let v_135 = (r7.www * r8.xzw); + r8 = vec4(v_135.x, r8.y, v_135.yz); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[11u].w); + r6.w = (r6.w / r7.w); + let v_136 = -(cb3_3.tint_symbol_2[11u].xyzx); + r7.w = dot(r8.xzw, v_136.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + r9.x = dot(r8.xzw, r3.xyz); + r9.y = clamp(r9.xxxx.y, 0.0f, 1.0f); + r9.y = ((-(abs(r9.xxxx))).y + r9.y); + let v_137 = abs(r9.xxxx); + r9.x = fma(r0.w, r9.y, v_137.x); + r7.w = (r7.w * r9.x); + r9.x = (r6.w * r7.w); + let v_138 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_138.xyz, r9.w); + let v_139 = (r0.xyz * r9.xyz); + r9 = vec4(v_139.xyz, r9.w); + let v_140 = fma(r2.xyz, r1.yyy, r8.xzw); + r8 = vec4(v_140.x, r8.y, v_140.yz); + r9.w = dot(r8.xzw, r8.xzw); + r9.w = inverseSqrt(r9.w); + let v_141 = (r8.xzw * r9.www); + r8 = vec4(v_141.x, r8.y, v_141.yz); + let v_142 = dot(r8.xzw, r4.xyz); + r9.w = clamp(vec4(v_142, v_142, v_142, v_142).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.x = (r9.w * r9.w); + r10.x = (r10.x * r10.x); + r9.w = (r9.w * r10.x); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_143 = dot(r8.xzw, r3.xyz); + r8.x = clamp(vec4(v_143, v_143, v_143, v_143).x, 0.0f, 1.0f); + r8.x = log2(r8.x); + r8.x = (r8.x * r8.y); + r8.x = exp2(r8.x); + r8.x = (r8.x * r9.w); + r7.w = (r7.w * r8.x); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_144 = (r6.www * cb3_3.tint_symbol_2[19u].xyz); + r8 = vec4(v_144.x, r8.y, v_144.yz); + } + r6.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r7.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + let v_145 = bitcast(r7.w); + let v_146 = r6.w; + r4.w = select(r4.w, v_146, (v_145 != 0u)); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_147 = (v_23.xyz + cb3_3.tint_symbol_2[4u].xyz); + r10 = vec4(v_147.xyz, r10.w); + let v_148 = (v5.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r11 = vec4(v_148.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w); + let v_149 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_149.xyz, r11.w); + let v_150 = (r11.xyz + v_23.xyz); + r11 = vec4(v_150.xyz, r11.w); + let v_151 = bitcast>(r6.www); + let v_152 = r10.xyz; + let v_153 = select(r11.xyz, v_152, (v_151 != vec3())); + r10 = vec4(v_153.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_154 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_154.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_155 = (r7.www * r10.xyz); + r10 = vec4(v_155.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[12u].w); + r6.w = (r6.w / r7.w); + let v_156 = -(cb3_3.tint_symbol_2[12u].xyzx); + r7.w = dot(r10.xyz, v_156.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + r9.w = dot(r10.xyz, r3.xyz); + r10.w = clamp(r9.wwww.w, 0.0f, 1.0f); + r10.w = ((-(abs(r9.wwww))).w + r10.w); + let v_157 = abs(r9.wwww); + r9.w = fma(r0.w, r10.w, v_157.w); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_158 = (r9.www * cb3_3.tint_symbol_2[20u].xyz); + r11 = vec4(v_158.xyz, r11.w); + let v_159 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_159.xyz, r9.w); + let v_160 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_160.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_161 = (r9.www * r10.xyz); + r10 = vec4(v_161.xyz, r10.w); + let v_162 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_162, v_162, v_162, v_162).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_163 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_163, v_163, v_163, v_163).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_164 = fma(r6.www, cb3_3.tint_symbol_2[20u].xyz, r8.xzw); + r8 = vec4(v_164.x, r8.y, v_164.yz); + } + } else { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r4.w) != 0u)) { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_165 = (v_23.xyz + cb3_3.tint_symbol_2[5u].xyz); + r10 = vec4(v_165.xyz, r10.w); + let v_166 = (v5.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r11 = vec4(v_166.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w); + let v_167 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_167.xyz, r11.w); + let v_168 = (r11.xyz + v_23.xyz); + r11 = vec4(v_168.xyz, r11.w); + let v_169 = bitcast>(r6.www); + let v_170 = r10.xyz; + let v_171 = select(r11.xyz, v_170, (v_169 != vec3())); + r10 = vec4(v_171.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_172 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_172.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_173 = (r7.www * r10.xyz); + r10 = vec4(v_173.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[13u].w); + r6.w = (r6.w / r7.w); + let v_174 = -(cb3_3.tint_symbol_2[13u].xyzx); + r7.w = dot(r10.xyz, v_174.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + r9.w = dot(r10.xyz, r3.xyz); + r10.w = clamp(r9.wwww.w, 0.0f, 1.0f); + r10.w = ((-(abs(r9.wwww))).w + r10.w); + let v_175 = abs(r9.wwww); + r9.w = fma(r0.w, r10.w, v_175.w); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_176 = (r9.www * cb3_3.tint_symbol_2[21u].xyz); + r11 = vec4(v_176.xyz, r11.w); + let v_177 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_177.xyz, r9.w); + let v_178 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_178.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_179 = (r9.www * r10.xyz); + r10 = vec4(v_179.xyz, r10.w); + let v_180 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_180, v_180, v_180, v_180).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_181 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_181, v_181, v_181, v_181).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_182 = fma(r6.www, cb3_3.tint_symbol_2[21u].xyz, r8.xzw); + r8 = vec4(v_182.x, r8.y, v_182.yz); + } + } + if ((bitcast(r4.w) != 0u)) { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_183 = (v_23.xyz + cb3_3.tint_symbol_2[6u].xyz); + r10 = vec4(v_183.xyz, r10.w); + let v_184 = (v5.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r11 = vec4(v_184.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[22u].w); + let v_185 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.www, cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_185.xyz, r11.w); + let v_186 = (r11.xyz + v_23.xyz); + r11 = vec4(v_186.xyz, r11.w); + let v_187 = bitcast>(r6.www); + let v_188 = r10.xyz; + let v_189 = select(r11.xyz, v_188, (v_187 != vec3())); + r10 = vec4(v_189.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_190 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_190.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_191 = (r7.www * r10.xyz); + r10 = vec4(v_191.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[14u].w); + r6.w = (r6.w / r7.w); + let v_192 = -(cb3_3.tint_symbol_2[14u].xyzx); + r7.w = dot(r10.xyz, v_192.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + r9.w = dot(r10.xyz, r3.xyz); + r10.w = clamp(r9.wwww.w, 0.0f, 1.0f); + r10.w = ((-(abs(r9.wwww))).w + r10.w); + let v_193 = abs(r9.wwww); + r9.w = fma(r0.w, r10.w, v_193.w); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_194 = (r9.www * cb3_3.tint_symbol_2[22u].xyz); + r11 = vec4(v_194.xyz, r11.w); + let v_195 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_195.xyz, r9.w); + let v_196 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_196.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_197 = (r9.www * r10.xyz); + r10 = vec4(v_197.xyz, r10.w); + let v_198 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_198, v_198, v_198, v_198).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_199 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_199, v_199, v_199, v_199).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_200 = fma(r6.www, cb3_3.tint_symbol_2[22u].xyz, r8.xzw); + r8 = vec4(v_200.x, r8.y, v_200.yz); + } + } + if ((bitcast(r4.w) != 0u)) { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (4i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f))); + let v_201 = (v_23.xyz + cb3_3.tint_symbol_2[7u].xyz); + r10 = vec4(v_201.xyz, r10.w); + let v_202 = (v5.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz); + r11 = vec4(v_202.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[15u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[23u].w); + let v_203 = fma(cb3_3.tint_symbol_2[15u].xyz, r7.www, cb3_3.tint_symbol_2[7u].xyz); + r11 = vec4(v_203.xyz, r11.w); + let v_204 = (r11.xyz + v_23.xyz); + r11 = vec4(v_204.xyz, r11.w); + let v_205 = bitcast>(r6.www); + let v_206 = r10.xyz; + let v_207 = select(r11.xyz, v_206, (v_205 != vec3())); + r10 = vec4(v_207.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_208 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_208.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_209 = (r7.www * r10.xyz); + r10 = vec4(v_209.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[7u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[15u].w); + r6.w = (r6.w / r7.w); + let v_210 = -(cb3_3.tint_symbol_2[15u].xyzx); + r7.w = dot(r10.xyz, v_210.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f); + r9.w = dot(r10.xyz, r3.xyz); + r10.w = clamp(r9.wwww.w, 0.0f, 1.0f); + r10.w = ((-(abs(r9.wwww))).w + r10.w); + let v_211 = abs(r9.wwww); + r9.w = fma(r0.w, r10.w, v_211.w); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_212 = (r9.www * cb3_3.tint_symbol_2[23u].xyz); + r11 = vec4(v_212.xyz, r11.w); + let v_213 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_213.xyz, r9.w); + let v_214 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_214.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_215 = (r9.www * r10.xyz); + r10 = vec4(v_215.xyz, r10.w); + let v_216 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_216, v_216, v_216, v_216).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_217 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_217, v_217, v_217, v_217).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_218 = fma(r6.www, cb3_3.tint_symbol_2[23u].xyz, r8.xzw); + r8 = vec4(v_218.x, r8.y, v_218.yz); + } + } + if ((bitcast(r4.w) != 0u)) { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (5i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f))); + let v_219 = (v_23.xyz + cb3_3.tint_symbol_2[8u].xyz); + r10 = vec4(v_219.xyz, r10.w); + let v_220 = (v5.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz); + r11 = vec4(v_220.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[16u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[24u].w); + let v_221 = fma(cb3_3.tint_symbol_2[16u].xyz, r7.www, cb3_3.tint_symbol_2[8u].xyz); + r11 = vec4(v_221.xyz, r11.w); + let v_222 = (r11.xyz + v_23.xyz); + r11 = vec4(v_222.xyz, r11.w); + let v_223 = bitcast>(r6.www); + let v_224 = r10.xyz; + let v_225 = select(r11.xyz, v_224, (v_223 != vec3())); + r10 = vec4(v_225.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_226 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_226.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_227 = (r7.www * r10.xyz); + r10 = vec4(v_227.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[8u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[16u].w); + r6.w = (r6.w / r7.w); + let v_228 = -(cb3_3.tint_symbol_2[16u].xyzx); + r7.w = dot(r10.xyz, v_228.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f); + r9.w = dot(r10.xyz, r3.xyz); + r10.w = clamp(r9.wwww.w, 0.0f, 1.0f); + r10.w = ((-(abs(r9.wwww))).w + r10.w); + let v_229 = abs(r9.wwww); + r9.w = fma(r0.w, r10.w, v_229.w); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_230 = (r9.www * cb3_3.tint_symbol_2[24u].xyz); + r11 = vec4(v_230.xyz, r11.w); + let v_231 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_231.xyz, r9.w); + let v_232 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_232.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_233 = (r9.www * r10.xyz); + r10 = vec4(v_233.xyz, r10.w); + let v_234 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_234, v_234, v_234, v_234).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_235 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_235, v_235, v_235, v_235).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_236 = fma(r6.www, cb3_3.tint_symbol_2[24u].xyz, r8.xzw); + r8 = vec4(v_236.x, r8.y, v_236.yz); + } + } + if ((bitcast(r4.w) != 0u)) { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (6i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f))); + let v_237 = (v_23.xyz + cb3_3.tint_symbol_2[9u].xyz); + r10 = vec4(v_237.xyz, r10.w); + let v_238 = (v5.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz); + r11 = vec4(v_238.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[17u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[25u].w); + let v_239 = fma(cb3_3.tint_symbol_2[17u].xyz, r7.www, cb3_3.tint_symbol_2[9u].xyz); + r11 = vec4(v_239.xyz, r11.w); + let v_240 = (r11.xyz + v_23.xyz); + r11 = vec4(v_240.xyz, r11.w); + let v_241 = bitcast>(r6.www); + let v_242 = r10.xyz; + let v_243 = select(r11.xyz, v_242, (v_241 != vec3())); + r10 = vec4(v_243.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_244 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_244.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_245 = (r7.www * r10.xyz); + r10 = vec4(v_245.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[9u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[17u].w); + r6.w = (r6.w / r7.w); + let v_246 = -(cb3_3.tint_symbol_2[17u].xyzx); + r7.w = dot(r10.xyz, v_246.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f); + r9.w = dot(r10.xyz, r3.xyz); + r10.w = clamp(r9.wwww.w, 0.0f, 1.0f); + r10.w = ((-(abs(r9.wwww))).w + r10.w); + let v_247 = abs(r9.wwww); + r9.w = fma(r0.w, r10.w, v_247.w); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_248 = (r9.www * cb3_3.tint_symbol_2[25u].xyz); + r11 = vec4(v_248.xyz, r11.w); + let v_249 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_249.xyz, r9.w); + let v_250 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_250.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_251 = (r9.www * r10.xyz); + r10 = vec4(v_251.xyz, r10.w); + let v_252 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_252, v_252, v_252, v_252).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_253 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_253, v_253, v_253, v_253).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_254 = fma(r6.www, cb3_3.tint_symbol_2[25u].xyz, r8.xzw); + r8 = vec4(v_254.x, r8.y, v_254.yz); + } + } + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (7i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r4.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f))); + let v_255 = (v_23.xyz + cb3_3.tint_symbol_2[10u].xyz); + r10 = vec4(v_255.xyz, r10.w); + let v_256 = (v5.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz); + r11 = vec4(v_256.xyz, r11.w); + r6.w = dot(r11.xyz, cb3_3.tint_symbol_2[18u].xyz); + r6.w = clamp(((r6.wwww / cb3_3.tint_symbol_2[26u].wwww)).w, 0.0f, 1.0f); + r6.w = (r6.w * cb3_3.tint_symbol_2[26u].w); + let v_257 = fma(cb3_3.tint_symbol_2[18u].xyz, r6.www, cb3_3.tint_symbol_2[10u].xyz); + r11 = vec4(v_257.xyz, r11.w); + let v_258 = (r11.xyz + v_23.xyz); + r11 = vec4(v_258.xyz, r11.w); + let v_259 = bitcast>(r4.www); + let v_260 = r10.xyz; + let v_261 = select(r11.xyz, v_260, (v_259 != vec3())); + r10 = vec4(v_261.xyz, r10.w); + r4.w = dot(r10.xyz, r10.xyz); + let v_262 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_262.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + r6.w = inverseSqrt(r6.w); + let v_263 = (r6.www * r10.xyz); + r10 = vec4(v_263.xyz, r10.w); + r4.w = clamp(fma(-(r4.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r6.w = ((-(cb3_3.tint_symbol_2[18u].wwww)).w + 1.0f); + r6.w = fma(r6.w, r4.w, cb3_3.tint_symbol_2[18u].w); + r4.w = (r4.w / r6.w); + let v_264 = -(cb3_3.tint_symbol_2[18u].xyzx); + r6.w = dot(r10.xyz, v_264.xyz); + r6.w = clamp(fma(r6.wwww, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).w, 0.0f, 1.0f); + r7.w = dot(r10.xyz, r3.xyz); + r9.w = clamp(r7.wwww.w, 0.0f, 1.0f); + r9.w = ((-(abs(r7.wwww))).w + r9.w); + let v_265 = abs(r7.wwww); + r7.w = fma(r0.w, r9.w, v_265.w); + r6.w = (r6.w * r7.w); + r7.w = (r4.w * r6.w); + let v_266 = (r7.www * cb3_3.tint_symbol_2[26u].xyz); + r11 = vec4(v_266.xyz, r11.w); + let v_267 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_267.xyz, r9.w); + let v_268 = fma(r2.xyz, r1.yyy, r10.xyz); + r2 = vec4(v_268.xyz, r2.w); + r1.y = dot(r2.xyz, r2.xyz); + r1.y = inverseSqrt(r1.y); + let v_269 = (r1.yyy * r2.xyz); + r2 = vec4(v_269.xyz, r2.w); + let v_270 = dot(r2.xyz, r4.xyz); + r1.y = clamp(vec4(v_270, v_270, v_270, v_270).y, 0.0f, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r4.x = (r1.y * r1.y); + r4.x = (r4.x * r4.x); + r1.y = (r1.y * r4.x); + r1.y = fma(cb12_12.tint_symbol_4[0u].z, r1.y, r5.w); + let v_271 = dot(r2.xyz, r3.xyz); + r2.x = clamp(vec4(v_271, v_271, v_271, v_271).x, 0.0f, 1.0f); + r2.x = log2(r2.x); + r2.x = (r2.x * r8.y); + r2.x = exp2(r2.x); + r1.y = (r1.y * r2.x); + r1.y = (r6.w * r1.y); + r1.y = (r4.w * r1.y); + r1.y = (r2.w * r1.y); + let v_272 = fma(r1.yyy, cb3_3.tint_symbol_2[26u].xyz, r8.xzw); + r8 = vec4(v_272.x, r8.y, v_272.yz); + } + } + r1.y = (r6.z * r6.z); + r1.x = (r1.x * r1.x); + let v_273 = (r8.xzw * r1.xxx); + r2 = vec4(v_273.xyz, r2.w); + let v_274 = fma(r1.yyy, r9.xyz, r2.xyz); + r2 = vec4(v_274.xyz, r2.w); + let v_275 = fma(r5.xyz, r3.www, r2.xyz); + r2 = vec4(v_275.xyz, r2.w); + r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_276 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r1 = vec4(r1.x, v_276.xyz); + r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_277 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r4 = vec4(v_277.xyz, r4.w); + let v_278 = (r4.xyz * cb2_2.tint_symbol_1[16u].zzz); + r4 = vec4(v_278.xyz, r4.w); + let v_279 = fma(r1.yzw, r2.www, r4.xyz); + r1 = vec4(r1.x, v_279.xyz); + let v_280 = (r6.yyy * r1.yzw); + r1 = vec4(r1.x, v_280.xyz); + let v_281 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r4 = vec4(v_281.xyz, r4.w); + r5.x = cb3_3.tint_symbol_2[46u].w; + r5.y = cb3_3.tint_symbol_2[47u].w; + r5.z = cb3_3.tint_symbol_2[48u].w; + let v_282 = dot(r5.xyz, r3.xyz); + r1.x = clamp(vec4(v_282, v_282, v_282, v_282).x, 0.0f, 1.0f); + let v_283 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r4.xyz); + r3 = vec4(v_283.xyz, r3.w); + let v_284 = fma(r3.xyz, r6.xxx, r1.yzw); + r1 = vec4(v_284.xyz, r1.w); + let v_285 = (r6.zzz * r1.xyz); + r1 = vec4(v_285.xyz, r1.w); + let v_286 = fma(r1.xyz, r0.xyz, r2.xyz); + r0 = vec4(v_286.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r7.xyz, r7.xyz); + r1.x = sqrt(r0.w); + let v_287 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_287.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r7.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_288 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_288 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_289 = (r0.www * r7.xyz); + r2 = vec4(v_289.xyz, r2.w); + let v_290 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_290, v_290, v_290, v_290).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_291 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_291, v_291, v_291, v_291).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_292 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_292.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_293 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_293.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_294 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_294.xyz, r2.w); + let v_295 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_295.xyz, r2.w); + let v_296 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_296.xyz, r3.w); + let v_297 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_297.xyz, r2.w); + let v_298 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_299 = (r2.xyz + v_298.xyz); + r2 = vec4(v_299.xyz, r2.w); + let v_300 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_300.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_301 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_301.xyz, r3.w); + let v_302 = fma(r1.xxx, r3.xyz, r2.xyz); + r1 = vec4(v_302.xy, r1.z, v_302.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_303 = (v7.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_303.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_304 = -(r0.xyxz); + let v_305 = fma(r1.xyw, r0.www, v_304.xyw); + r1 = vec4(v_305.xy, r1.z, v_305.z); + let v_306 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_306.xyz, r1.w); + } else { + r0.w = dot(r7.xyz, r7.xyz); + r1.w = sqrt(r0.w); + let v_307 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_307.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r7.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_308 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_308 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_309 = (r0.www * r7.xyz); + r3 = vec4(v_309.xyz, r3.w); + let v_310 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_310, v_310, v_310, v_310).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_311 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_311, v_311, v_311, v_311).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_312 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_312.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_313 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_313.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_314 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_314.xyz, r3.w); + let v_315 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_315.xyz, r3.w); + let v_316 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_316.xyz, r4.w); + let v_317 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_317.xyz, r3.w); + let v_318 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_319 = (r3.xyz + v_318.xyz); + r3 = vec4(v_319.xyz, r3.w); + let v_320 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_320.x, r2.y, v_320.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_321 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_321.xyz, r3.w); + let v_322 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_322.x, r2.y, v_322.yz); + let v_323 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_323.x, r2.y, v_323.yz); + let v_324 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_324.xyz, r1.w); + } + let v_325 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_325.xyz, o0.w); +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @builtin(position) v_326 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v_326); + return o0; +} diff --git a/b/8b0b5899ed/shaders/0160fa33200b4988.wgsl b/b/8b0b5899ed/shaders/0160fa33200b4988.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..c871faa5869c2dc8251bae9bb6d0ad922e2e6cfb --- /dev/null +++ b/b/8b0b5899ed/shaders/0160fa33200b4988.wgsl @@ -0,0 +1,188 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +struct cb17_struct { + tint_symbol : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb50_struct { + tint_symbol_1 : array, 50u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb50_struct; + +struct cb4_struct { + tint_symbol_2 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb7_struct { + tint_symbol_3 : array, 7u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb7_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(36u) var t4 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4, v3 : vec4, v5 : vec4, v6 : vec4) { + r0 = textureSample(t0, s0, v1.xyxx.xy); + let v = (r0.xyz * cb12_12.tint_symbol_3[0u].xyz); + r0 = vec4(v.xyz, r0.w); + r0 = (r0 * v3.xxxw); + r0.w = (r0.w * cb2_2.tint_symbol[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (0.0039215688593685627f >= r0.w))); + v_1((bitcast(r1.x) != 0u)); + r1 = textureSample(t3, s3, v1.xyxx.xy); + let v_2 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_2.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_3[6u].w, 0.00100000004749745131f); + let v_3 = (r1.ww * r1.xy); + r1 = vec4(v_3.xy, r1.zw); + let v_4 = (r1.yyy * v6.xyz); + r2 = vec4(v_4.xyz, r2.w); + let v_5 = fma(r1.xxx, v5.xyz, r2.xyz); + r1 = vec4(v_5.xy, r1.z, v_5.z); + let v_6 = fma(r1.zzz, v2.xyz, r1.xyw); + r1 = vec4(v_6.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_7 = (r1.www * r1.xyz); + r2 = vec4(v_7.xyz, r2.w); + r3 = textureSample(t4, s4, v1.xyxx.xy); + let v_8 = (r3.xy * r3.xy); + r3 = vec4(v_8.xy, r3.zw); + r1.x = dot(r3.xyz, cb12_12.tint_symbol_3[6u].xyz); + r1.x = (r1.x * cb12_12.tint_symbol_3[5u].y); + r1.y = (r3.w * cb12_12.tint_symbol_3[5u].x); + let v_9 = (v3.xx * cb2_2.tint_symbol[15u].zy); + r3 = vec4(v_9.xy, r3.zw); + r2.w = clamp(((cb2_2.tint_symbol[16u].zzzz + cb3_3.tint_symbol_1[49u].wwww)).w, 0.0f, 1.0f); + r4.y = (r2.w * r3.y); + r1.x = (r1.x * v3.x); + let v_10 = ((-(cb12_12.tint_symbol_3[3u].zzzz)).yz + vec2(1.0f, 2.0f)); + let v_11 = r3; + r3 = vec4(v_11.x, v_10.xy, v_11.w); + r2.w = (r3.y * v3.z); + let v_12 = (r3.zz * v1.zw); + r3 = vec4(r3.xy, v_12.xy); + r5 = textureSample(t2, s2, r3.zwzz.xy); + r3.z = (cb5_5.tint_symbol_2[3u].z * cb12_12.tint_symbol_3[3u].z); + r3.w = ((-(r5.xxxx)).w + r5.z); + r5.x = fma(r3.z, r3.w, r5.x); + let v_13 = (r5.xy * cb12_12.tint_symbol_3[3u].xx); + r3 = vec4(r3.xy, v_13.xy); + r4.z = fma(v3.z, r3.y, -1.0f); + r3.y = fma(r3.y, r4.z, 1.0f); + r3.z = (r3.y * r3.z); + let v_14 = -(r0.xyxz); + let v_15 = fma(cb12_12.tint_symbol_3[4u].xyz, cb12_12.tint_symbol_3[3u].yyy, v_14.xyw); + r5 = vec4(v_15.xy, r5.z, v_15.z); + let v_16 = fma(r3.zzz, r5.xyw, r0.xyz); + r0 = vec4(v_16.xyz, r0.w); + r2.w = (r2.w * cb12_12.tint_symbol_3[3u].x); + let v_17 = ((-(r0.xyzx)).xyz + r5.zzz); + r5 = vec4(v_17.xyz, r5.w); + let v_18 = fma(r2.www, r5.xyz, r0.xyz); + r0 = vec4(v_18.xyz, r0.w); + r2.w = fma((-(r3.wwww)).w, r3.y, 1.0f); + r5.x = (r1.x * r2.w); + let v_19 = fma(r2.xyz, vec3(0.5f), vec3(0.5f)); + o1 = vec4(v_19.xyz, o1.w); + r5.y = (r1.y * 0.001953125f); + r4.x = fma(v3.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w); + let v_20 = (r4.xy * vec2(0.5f)); + r2 = vec4(v_20.xy, r2.zw); + let v_21 = sqrt(r2.xy); + o3 = vec4(v_21.xy, o3.zw); + r1.y = fma(r1.z, r1.w, -0.34999999403953552246f); + r1.y = clamp(((r1.yyyy * vec4(1.53846156597137451172f))).y, 0.0f, 1.0f); + r1.y = (r1.y * cb5_5.tint_symbol_2[3u].z); + r1.z = ((-(cb2_2.tint_symbol[16u].zzzz)).z + 1.0f); + r1.y = (r1.z * r1.y); + r1.y = (r3.x * r1.y); + r1.z = fma((-(r5.xxxx)).z, 0.5f, 1.0f); + r1.z = (r1.z * r1.y); + r1.z = fma(r1.z, -0.5f, 1.0f); + let v_22 = (r0.xyz * r1.zzz); + o0 = vec4(v_22.xyz, o0.w); + r0.x = clamp(fma(r1.xxxx, r2.wwww, vec4(0.40000000596046447754f)).x, 0.0f, 1.0f); + r5.z = cb12_12.tint_symbol_3[4u].w; + let v_23 = -(r5.xyxx); + let v_24 = fma(r0.xx, vec2(0.5f, 0.48828125f), v_23.xy); + r0 = vec4(v_24.xy, r0.zw); + r0.z = 0.0f; + let v_25 = max(r0.xyz, vec3()); + r0 = vec4(v_25.xyz, r0.w); + let v_26 = fma(r0.xyz, r1.yyy, r5.xyz); + r0 = vec4(v_26.xyz, r0.w); + let v_27 = sqrt(r0.xy); + o2 = vec4(v_27.xy, o2.zw); + o0.w = r0.w; + o1.w = 0.0f; + o2.z = r0.z; + o2.w = 1.0f; + o3 = vec4(o3.xy, vec2(0.0f, 1.00188386440277099609f)); +} + +fn v_1(v_28 : bool) { + if (v_28) { + discard; + return; + } +} + +struct tint_symbol_4 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4) -> tint_symbol_4 { + main_inner(v1, v2, v3, v5, v6); + return tint_symbol_4(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/016af02cde843241.consts.json b/b/8b0b5899ed/shaders/016af02cde843241.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..9c27df027d15db715744502f6c2271644a23c98e --- /dev/null +++ b/b/8b0b5899ed/shaders/016af02cde843241.consts.json @@ -0,0 +1 @@ +[2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/016af02cde843241.wgsl b/b/8b0b5899ed/shaders/016af02cde843241.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..5ef97d4eeeb6957c631818f52c32c100aa09db09 --- /dev/null +++ b/b/8b0b5899ed/shaders/016af02cde843241.wgsl @@ -0,0 +1,681 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb3_struct { + tint_symbol_4 : array, 3u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb3_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(20u) var s4 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(36u) var t4 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v7 : vec4; + +var v8 : array; + +var o0 : vec4; + +var o1 : f32; + +var o2 : f32; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 3u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v7 = v_2; + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t0, s0, v1.xyz.xyxx.xy); + r1 = textureSample(t2, s2, v1.xyz.xyxx.xy); + let v_3 = fma(r1.xy, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_3.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[1u].w, 0.00100000004749745131f); + let v_4 = (r1.ww * r1.xy); + r1 = vec4(v_4.xy, r1.zw); + let v_5 = (r1.yyy * v5.xyz); + r2 = vec4(v_5.xyz, r2.w); + let v_6 = fma(r1.xxx, v4.xyz, r2.xyz); + r1 = vec4(v_6.xy, r1.z, v_6.z); + let v_7 = fma(r1.zzz, v2.xyz, r1.xyw); + r1 = vec4(v_7.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_8 = (r1.www * r1.xyz); + r2 = vec4(v_8.xyz, r2.w); + r3 = textureSample(t3, s3, v1.xyz.xyxx.xy); + let v_9 = (r3.xy * r3.xy); + r3 = vec4(v_9.xy, r3.zw); + r1.x = dot(r3.xyz, cb12_12.tint_symbol_4[1u].xyz); + r1.x = clamp(((r1.xxxx * cb12_12.tint_symbol_4[0u].zzzz)).x, 0.0f, 1.0f); + r1.y = dot(v3.xyz, v3.xyz); + r1.y = inverseSqrt(r1.y); + let v_10 = (r1.yyy * v3.xyz); + r3 = vec4(v_10.xyz, r3.w); + r1.y = dot((-(r3.xyzx)).xyz, r2.xyz); + r1.y = (r1.y + r1.y); + let v_11 = -(r1.yyyy); + let v_12 = -(r3.xyzx); + let v_13 = fma(r2.xyz, v_11.xyz, v_12.xyz); + r3 = vec4(v_13.xyz, r3.w); + r1.y = dot(r3.xyz, r3.xyz); + r1.y = inverseSqrt(r1.y); + let v_14 = fma(r3.xz, r1.yy, vec2(1.0f)); + r3 = vec4(v_14.xy, r3.zw); + let v_15 = (r3.xy * vec2(-0.5f)); + r3 = vec4(v_15.xy, r3.zw); + r4 = textureSample(t4, s4, r3.xyxx.xy); + let v_16 = (r4.xyz * cb12_12.tint_symbol_4[2u].xxx); + r3 = vec4(v_16.xyz, r3.w); + r0.w = (r0.w * v0.w); + let v_17 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r4 = vec4(v_17.xy, r4.zw); + let v_18 = (r0.xyz * r0.xyz); + r0 = vec4(v_18.xyz, r0.w); + let v_19 = ((-(v6.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r5 = vec4(v_19.xyz, r5.w); + r1.y = dot(r5.xyz, r5.xyz); + r1.y = inverseSqrt(r1.y); + let v_20 = (r1.yyy * r5.xyz); + r6 = vec4(v_20.xyz, r6.w); + let v_21 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_22 = fma(r5.xyz, r1.yyy, v_21.xyz); + r7 = vec4(v_22.xyz, r7.w); + r1.y = dot(r7.xyz, r7.xyz); + r1.y = inverseSqrt(r1.y); + let v_23 = (r1.yyy * r7.xyz); + r7 = vec4(v_23.xyz, r7.w); + let v_24 = (r4.xy * r4.xy); + r4 = vec4(v_24.xy, r4.zw); + r1.y = fma(r3.w, cb12_12.tint_symbol_4[0u].y, -500.0f); + r1.y = max(r1.y, 0.0f); + let v_25 = -(r1.yyyy); + r2.w = fma(r3.w, cb12_12.tint_symbol_4[0u].y, v_25.w); + r1.y = (r1.y * 558.0f); + r1.y = fma(r2.w, 3.0f, r1.y); + r2.w = dot(r5.xyz, cb1_1.tint_symbol[14u].xyz); + let v_26 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r5 = vec4(v_26.xyz, r5.w); + let v_27 = (r5.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_27.xyz, r8.w); + let v_28 = fma(r5.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_28.xyz, r8.w); + let v_29 = fma(r5.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_29.xyz, r8.w); + let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_30.xyz, r9.w); + let v_31 = &(x0[0u]); + let v_32 = r9; + *(v_31) = vec4(v_32.xyz, (*(v_31)).w); + let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_33.xyz, r10.w); + let v_34 = &(x0[1u]); + let v_35 = r10; + *(v_34) = vec4(v_35.xyz, (*(v_34)).w); + let v_36 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_36.xyz, r11.w); + let v_37 = &(x0[2u]); + let v_38 = r11; + *(v_37) = vec4(v_38.xyz, (*(v_37)).w); + let v_39 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_39.xyz, r8.w); + let v_40 = &(x0[3u]); + let v_41 = r8; + *(v_40) = vec4(v_41.xyz, (*(v_40)).w); + let v_42 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_43 = r12; + r12 = vec4(v_43.x, v_42.x, v_43.z, v_42.y); + r3.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r3.w = (r3.w * 0.5f); + let v_44 = abs(r11.yyyy); + r4.z = max(v_44.z, abs(r11.xxxx).z); + r4.z = bitcast(select(0u, 4294967295u, (r4.z < r3.w))); + let v_45 = (bitcast(r4.z) != 0u); + let v_46 = bitcast(v.tint_symbol_6[0i].x); + r4.z = select(bitcast(v.tint_symbol_6[1i].x), v_46, v_45); + let v_47 = abs(r10.yyyy); + r4.w = max(v_47.w, abs(r10.xxxx).w); + r4.w = bitcast(select(0u, 4294967295u, (r4.w < r3.w))); + let v_48 = bitcast(r4.w); + r4.z = select(r4.z, bitcast(v.tint_symbol_6[2i].x), (v_48 != 0u)); + let v_49 = abs(r9.yyyy); + r4.w = max(v_49.w, abs(r9.xxxx).w); + r3.w = bitcast(select(0u, 4294967295u, (r4.w < r3.w))); + let v_50 = bitcast(r3.w); + r3.w = select(r4.z, 0.0f, (v_50 != 0u)); + let v_51 = x0[bitcast(r3.w)]; + r9 = vec4(v_51.xyz, r9.w); + r3.w = f32(bitcast(r3.w)); + r4.z = (r3.w + 0.5f); + r4.z = (r4.z * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r3.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r3.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r4.w = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r4.z); + r4.z = bitcast(select(0u, 4294967295u, !((r3.w == 0.0f)))); + r3.w = ((-(r3.wwww)).w + r9.z); + let v_52 = dpdx(r10.xyy); + r11 = vec4(v_52.xy, r11.z, v_52.z); + r11.z = dpdx(r3.w); + let v_53 = dpdy(r10.yxy); + r13 = vec4(v_53.xyz, r13.w); + r13.w = dpdy(r3.w); + let v_54 = (r11.yw * r13.yw); + r8 = vec4(r8.xy, v_54.xy); + let v_55 = -(r8.zwzz); + let v_56 = fma(r11.xz, r13.xz, v_55.xy); + r14 = vec4(v_56.xy, r14.zw); + r5.w = (1.0f / r14.x); + r6.w = (r11.z * r13.y); + let v_57 = -(r6.wwww); + r14.z = fma(r11.x, r13.w, v_57.z); + let v_58 = (r5.ww * r14.yz); + r8 = vec4(r8.xy, v_58.xy); + let v_59 = max(r8.zw, vec2()); + r8 = vec4(r8.xy, v_59.xy); + let v_60 = min(r8.zw, vec2(0.5f)); + r8 = vec4(r8.xy, v_60.xy); + r3.w = fma((-(r4.wwww)).w, r8.z, r3.w); + r3.w = fma((-(r4.wwww)).w, r8.w, r3.w); + let v_61 = bitcast(r4.z); + let v_62 = r3.w; + r12.z = select(r9.z, v_62, (v_61 != 0u)); + r10.z = 0.0f; + let v_63 = (r10.xyz + r12.ywz); + r9 = vec4(v_63.xyz, r9.w); + let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_64.xy, r12.zw); + let v_65 = (r10.xyz + r12.xyz); + r11 = vec4(v_65.xyz, r11.w); + let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_66.xy, r12.zw); + let v_67 = (r10.xyz + r12.xyz); + r13 = vec4(v_67.xyz, r13.w); + let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_68.xy, r12.zw); + let v_69 = (r10.xyz + r12.xyz); + r14 = vec4(v_69.xyz, r14.w); + let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_70.xy, r12.zw); + let v_71 = (r10.xyz + r12.xyz); + r15 = vec4(v_71.xyz, r15.w); + let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_72.xy, r12.zw); + let v_73 = (r10.xyz + r12.xyz); + r16 = vec4(v_73.xyz, r16.w); + let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_74.xy, r12.zw); + let v_75 = (r10.xyz + r12.xyz); + r17 = vec4(v_75.xyz, r17.w); + let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_76.xy, r12.zw); + let v_77 = (r10.xyz + r12.xyz); + r18 = vec4(v_77.xyz, r18.w); + let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_78.xy, r12.zw); + let v_79 = (r10.xyz + r12.xyz); + r19 = vec4(v_79.xyz, r19.w); + let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_80.xy, r12.zw); + let v_81 = (r10.xyz + r12.xyz); + r20 = vec4(v_81.xyz, r20.w); + let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_82.xy, r12.zw); + let v_83 = (r10.xyz + r12.xyz); + r21 = vec4(v_83.xyz, r21.w); + let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_84.xy, r12.zw); + let v_85 = (r10.xyz + r12.xyz); + r22 = vec4(v_85.xyz, r22.w); + let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_86.xy, r12.zw); + let v_87 = (r10.xyz + r12.xyz); + r23 = vec4(v_87.xyz, r23.w); + let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_88.xy, r12.zw); + let v_89 = (r10.xyz + r12.xyz); + r24 = vec4(v_89.xyz, r24.w); + let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_90.xy, r12.zw); + let v_91 = (r10.xyz + r12.xyz); + r25 = vec4(v_91.xyz, r25.w); + let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_92.xy, r12.zw); + let v_93 = (r10.xyz + r12.xyz); + r10 = vec4(v_93.xyz, r10.w); + let v_94 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_94.xy, r9.z); + let v_95 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_95.xy, r11.z); + let v_96 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_96.xy, r13.z); + let v_97 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_97.xy, r14.z); + let v_98 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_98.xy, r15.z); + let v_99 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_99.xy, r16.z); + let v_100 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_100.xy, r17.z); + let v_101 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_101.xy, r18.z); + let v_102 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_102.xy, r19.z); + let v_103 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_103.xy, r20.z); + let v_104 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_104.xy, r21.z); + let v_105 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_105.xy, r22.z); + let v_106 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_106.xy, r23.z); + let v_107 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_107.xy, r24.z); + let v_108 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_108.xy, r25.z); + let v_109 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_109.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r3.w = dot(r9, vec4(1.0f)); + r2.w = clamp(fma(r2.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f); + let v_110 = abs(r8.yyyy); + r4.z = max(v_110.z, abs(r8.xxxx).z); + r4.z = clamp(fma(r4.zzzz, vec4(15.0f), vec4(-6.30000019073486328125f)).z, 0.0f, 1.0f); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.w = (r4.z * r2.w); + r2.w = fma(r3.w, 0.0625f, r2.w); + r2.w = (r2.w * r2.w); + r2.w = min(r2.w, 1.0f); + r3.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r3.w = sqrt(r3.w); + r3.w = (r3.w * cb6_6.tint_symbol_5[3u].z); + let v_111 = -(r2.wwww); + r2.w = fma(r3.w, v_111.w, r2.w); + let v_112 = dot(r2.xyz, v_21.xyz); + r3.w = clamp(vec4(v_112, v_112, v_112, v_112).w, 0.0f, 1.0f); + let v_113 = dot(r6.xyz, r2.xyz); + r6.x = clamp(vec4(v_113, v_113, v_113, v_113).x, 0.0f, 1.0f); + let v_114 = dot(r7.xyz, v_21.xyz); + r6.y = clamp(vec4(v_114, v_114, v_114, v_114).y, 0.0f, 1.0f); + let v_115 = ((-(r6.xxxy)).zw + vec2(1.0f)); + r4 = vec4(r4.xy, v_115.xy); + let v_116 = (r4.zw * r4.zw); + r6 = vec4(v_116.xy, r6.zw); + let v_117 = (r6.xy * r6.xy); + r6 = vec4(v_117.xy, r6.zw); + let v_118 = (r4.zw * r6.xy); + r4 = vec4(r4.xy, v_118.xy); + r5.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f); + let v_119 = fma(cb12_12.tint_symbol_4[0u].xx, r4.zw, r5.ww); + r4 = vec4(r4.xy, v_119.xy); + let v_120 = (r1.yy + vec2(2.0f, 0.00000000999999993923f)); + r6 = vec4(v_120.xy, r6.zw); + r5.w = (r6.x * 0.125f); + r4.z = fma((-(r1.xxxx)).z, r4.z, 1.0f); + r6.x = dot(r2.xyz, r7.xyz); + r6.x = clamp(((r6.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r6.x = log2(r6.x); + r6.x = (r6.x * r6.y); + r6.x = exp2(r6.x); + r4.w = (r4.w * r6.x); + r4.w = (r5.w * r4.w); + r1.x = (r1.x * r4.w); + r1.x = (r3.w * r1.x); + r3.w = (r3.w * r4.z); + let v_121 = fma(r0.xyz, r3.www, r1.xxx); + r6 = vec4(v_121.xyz, r6.w); + let v_122 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz); + r6 = vec4(v_122.xyz, r6.w); + r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_123 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r7 = vec4(v_123.xyz, r7.w); + r1.z = ((-(cb2_2.tint_symbol_1[16u].zzzz)).z + 1.0f); + let v_124 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r8 = vec4(v_124.xyz, r8.w); + let v_125 = (r8.xyz * cb2_2.tint_symbol_1[16u].zzz); + r8 = vec4(v_125.xyz, r8.w); + let v_126 = fma(r7.xyz, r1.zzz, r8.xyz); + r7 = vec4(v_126.xyz, r7.w); + let v_127 = (r4.yyy * r7.xyz); + r7 = vec4(v_127.xyz, r7.w); + let v_128 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r1 = vec4(v_128.x, r1.y, v_128.yz); + r8.x = cb3_3.tint_symbol_2[46u].w; + r8.y = cb3_3.tint_symbol_2[47u].w; + r8.z = cb3_3.tint_symbol_2[48u].w; + let v_129 = dot(r8.xyz, r2.xyz); + r2.x = clamp(vec4(v_129, v_129, v_129, v_129).x, 0.0f, 1.0f); + let v_130 = fma(cb3_3.tint_symbol_2[49u].xyz, r2.xxx, r1.xzw); + r1 = vec4(v_130.x, r1.y, v_130.yz); + let v_131 = fma(r1.xzw, r4.xxx, r7.xyz); + r1 = vec4(v_131.x, r1.y, v_131.yz); + let v_132 = (r4.zzz * r1.xzw); + r1 = vec4(v_132.x, r1.y, v_132.yz); + let v_133 = (r0.xyz * r1.xzw); + r0 = vec4(v_133.xyz, r0.w); + let v_134 = fma(r6.xyz, r2.www, r0.xyz); + r0 = vec4(v_134.xyz, r0.w); + r1.x = ((-(r4.zzzz)).x + 1.0f); + r1.z = max(r4.y, r4.x); + let v_135 = (r1.zzz * r3.xyz); + r2 = vec4(v_135.xyz, r2.w); + r1.y = clamp(((r1.yyyy * vec4(0.00177619897294789553f))).y, 0.0f, 1.0f); + let v_136 = (r1.yyy * r2.xyz); + r1 = vec4(r1.x, v_136.xyz); + let v_137 = (r1.yzw * vec3(0.68169009685516357422f)); + r1 = vec4(r1.x, v_137.xyz); + let v_138 = fma(r2.xyz, vec3(0.31830990314483642578f), r1.yzw); + r1 = vec4(r1.x, v_138.xyz); + let v_139 = fma(r1.yzw, r1.xxx, r0.xyz); + r0 = vec4(v_139.xyz, r0.w); + r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r1.x = dot(r5.xyz, r5.xyz); + r1.y = sqrt(r1.x); + let v_140 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.z = (r1.y + v_140.z); + r1.z = max(r1.z, 0.0f); + r1.y = (r1.z / r1.y); + r1.y = (r1.y * r5.z); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].z); + r1.y = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.yyyy).y))); + r2.x = (r1.w * -1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.w = (r2.x / r1.w); + let v_141 = bitcast(r1.y); + r1.y = select(1.0f, r1.w, (v_141 != 0u)); + r1.w = (r1.z * cb3_3.tint_symbol_2[51u].w); + r1.y = (r1.y * r1.w); + r1.y = min(r1.y, 1.0f); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = min(r1.y, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].y); + r1.x = inverseSqrt(r1.x); + let v_142 = (r1.xxx * r5.xyz); + r2 = vec4(v_142.xyz, r2.w); + let v_143 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.x = clamp(vec4(v_143, v_143, v_143, v_143).x, 0.0f, 1.0f); + r1.x = log2(r1.x); + r1.x = (r1.x * cb3_3.tint_symbol_2[54u].w); + r1.x = exp2(r1.x); + let v_144 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.x = clamp(vec4(v_144, v_144, v_144, v_144).x, 0.0f, 1.0f); + r2.x = log2(r2.x); + r2.x = (r2.x * cb3_3.tint_symbol_2[53u].w); + r2.x = exp2(r2.x); + r1.y = fma((-(r1.yyyy)).y, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.y = (r1.y * cb3_3.tint_symbol_2[51u].y); + let v_145 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.y = (r1.z + v_145.y); + r2.y = max(r2.y, 0.0f); + r2.y = (r2.y * cb3_3.tint_symbol_2[51u].x); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + r1.w = clamp(fma(r1.yyyy, r2.yyyy, r1.wwww).w, 0.0f, 1.0f); + let v_146 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.z = (r1.z * v_146.z); + r1.z = (r1.z * 1.44269502162933349609f); + r1.z = exp2(r1.z); + r1.z = ((-(r1.zzzz)).z + 1.0f); + let v_147 = ((-(cb3_3.tint_symbol_2[56u].xxyz)).yzw + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(r2.x, v_147.xyz); + let v_148 = fma(r1.xxx, r2.yzw, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(r2.x, v_148.xyz); + let v_149 = ((-(r2.yzwy)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_149.xyz, r3.w); + let v_150 = fma(r2.xxx, r3.xyz, r2.yzw); + r2 = vec4(v_150.xyz, r2.w); + let v_151 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_152 = (r2.xyz + v_151.xyz); + r2 = vec4(v_152.xyz, r2.w); + let v_153 = fma(r1.zzz, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_153.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_154 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_154.xyz, r3.w); + let v_155 = fma(r1.yyy, r3.xyz, r2.xyz); + r1 = vec4(v_155.xyz, r1.w); + r2.x = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r2.x) != 0u)) { + let v_156 = (v7.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_156.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r2.x = (r2.x + -1.0f); + r2.x = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r2.xxxx, vec4(1.0f)).x, 0.0f, 1.0f); + } else { + r2.x = 1.0f; + } + let v_157 = -(r0.xyzx); + let v_158 = fma(r1.xyz, r2.xxx, v_157.xyz); + r1 = vec4(v_158.xyz, r1.w); + let v_159 = fma(r1.www, r1.xyz, r0.xyz); + r1 = vec4(v_159.xyz, r1.w); + } else { + r1.w = dot(r5.xyz, r5.xyz); + r2.x = sqrt(r1.w); + let v_160 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.y = (r2.x + v_160.y); + r2.y = max(r2.y, 0.0f); + r2.x = (r2.y / r2.x); + r2.x = (r2.x * r5.z); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].z); + r2.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r2.xxxx).x))); + r2.w = (r2.z * -1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.z = (r2.w / r2.z); + let v_161 = bitcast(r2.x); + r2.x = select(1.0f, r2.z, (v_161 != 0u)); + r2.z = (r2.y * cb3_3.tint_symbol_2[51u].w); + r2.x = (r2.x * r2.z); + r2.x = min(r2.x, 1.0f); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = min(r2.x, 1.0f); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].y); + r1.w = inverseSqrt(r1.w); + let v_162 = (r1.www * r5.xyz); + r3 = vec4(v_162.xyz, r3.w); + let v_163 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.w = clamp(vec4(v_163, v_163, v_163, v_163).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[54u].w); + r1.w = exp2(r1.w); + let v_164 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.w = clamp(vec4(v_164, v_164, v_164, v_164).w, 0.0f, 1.0f); + r2.w = log2(r2.w); + r2.w = (r2.w * cb3_3.tint_symbol_2[53u].w); + r2.w = exp2(r2.w); + r2.x = fma((-(r2.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].y); + let v_165 = -(cb3_3.tint_symbol_2[52u].xxxx); + r3.x = (r2.y + v_165.x); + r3.x = max(r3.x, 0.0f); + r3.x = (r3.x * cb3_3.tint_symbol_2[51u].x); + r3.x = (r3.x * 1.44269502162933349609f); + r3.x = exp2(r3.x); + r3.x = ((-(r3.xxxx)).x + 1.0f); + r2.z = clamp(fma(r2.xxxx, r3.xxxx, r2.zzzz).z, 0.0f, 1.0f); + let v_166 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.y = (r2.y * v_166.y); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + let v_167 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_167.xyz, r3.w); + let v_168 = fma(r1.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_168.xyz, r3.w); + let v_169 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_169.xyz, r4.w); + let v_170 = fma(r2.www, r4.xyz, r3.xyz); + r3 = vec4(v_170.xyz, r3.w); + let v_171 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_172 = (r3.xyz + v_171.xyz); + r3 = vec4(v_172.xyz, r3.w); + let v_173 = fma(r2.yyy, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r3 = vec4(v_173.xyz, r3.w); + r4.x = cb3_3.tint_symbol_2[55u].w; + r4.y = cb3_3.tint_symbol_2[56u].w; + r4.z = cb3_3.tint_symbol_2[57u].w; + let v_174 = ((-(r3.xyzx)).xyz + r4.xyz); + r4 = vec4(v_174.xyz, r4.w); + let v_175 = fma(r2.xxx, r4.xyz, r3.xyz); + r2 = vec4(v_175.xy, r2.z, v_175.z); + let v_176 = ((-(r0.xyxz)).xyw + r2.xyw); + r2 = vec4(v_176.xy, r2.z, v_176.z); + let v_177 = fma(r2.zzz, r2.xyw, r0.xyz); + r1 = vec4(v_177.xyz, r1.w); + } + let v_178 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_178.xyz, o0.w); + r0.x = bitcast(select(0u, 4294967295u, (0.30000001192092895508f < r0.w))); + r0.x = bitcast((bitcast(r0.x) & 1065353216u)); + o1 = (r0.x * v1.z); + o0.w = r0.w; + o2 = r0.x; +} + +struct tint_symbol_8 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : f32, + @location(2u) + o2 : f32, +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @builtin(position) v_179 : vec4) -> tint_symbol_8 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v_179); + return tint_symbol_8(o0, o1, o2); +} diff --git a/b/8b0b5899ed/shaders/0174148c8350049e.wgsl b/b/8b0b5899ed/shaders/0174148c8350049e.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..1e34a3358f635a7743d06ae12ec91b6e308385d1 --- /dev/null +++ b/b/8b0b5899ed/shaders/0174148c8350049e.wgsl @@ -0,0 +1,331 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +struct cb17_struct { + tint_symbol : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb46_struct { + tint_symbol_1 : array, 46u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb46_struct; + +struct cb4_struct { + tint_symbol_2 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb2_struct { + tint_symbol_3 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(34u) var t2 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4) { + let v = clamp(v2.zw, vec2(), vec2(1.0f)); + r0 = vec4(v.xy, r0.zw); + let v_1 = bitcast>(select(vec2(), vec2(4294967295u), (cb2_2.tint_symbol[2u].xy == vec2(1.0f)))); + r1 = vec4(v_1.xy, r1.zw); + if ((bitcast(r1.x) != 0u)) { + r2 = vec4(v2.xy, r2.zw); + let v_2 = r1; + r1 = vec4(v2.x, v_2.y, v2.y, v_2.w); + } else { + r1.z = ((-(r0.xxxx)).z + 1.0f); + r1.w = ((-(v2.wwww)).w + 1.0f); + r1.w = max(r1.w, 0.10000000149011611938f); + r1.w = min(r1.w, 1.0f); + r2.x = dot(v5.xyz, v4.xyz); + r2.y = dot(v6.xyz, v4.xyz); + r2.z = dot(v3.xyz, v4.xyz); + r2.w = dot(r2.xyz, r2.xyz); + r2.w = inverseSqrt(r2.w); + let v_3 = (r2.www * r2.xyz); + r2 = vec4(v_3.xyz, r2.w); + r1.w = max(r1.w, r2.z); + r2.z = dot(v4.xyz, v4.xyz); + r2.z = inverseSqrt(r2.z); + let v_4 = (r2.zzz * v4.xyz); + r3 = vec4(v_4.xyz, r3.w); + r2.z = dot(v3.xyz, v3.xyz); + r2.z = inverseSqrt(r2.z); + let v_5 = (r2.zzz * v3.xyz); + r4 = vec4(v_5.xyz, r4.w); + r2.z = dot(r3.xyz, r4.xyz); + r2.w = ((-(cb2_2.tint_symbol[3u].wwww)).w + cb2_2.tint_symbol[3u].z); + r2.w = fma(abs(r2.zzzz).w, r2.w, cb2_2.tint_symbol[3u].w); + r1.z = (r1.z * cb2_2.tint_symbol[1u].x); + r3.x = clamp(((r2.wwww + vec4(-1.0f))).x, 0.0f, 1.0f); + r1.z = (r1.z * r3.x); + r2.z = (abs(r2.zzzz).z * 4.0f); + r2.z = min(r2.z, 1.0f); + r1.z = (r1.z * r2.z); + let v_6 = ((-(r2.xyxx)).xy / r1.ww); + r3 = vec4(v_6.xy, r3.zw); + let v_7 = (r3.xy * cb12_12.tint_symbol_3[1u].xx); + r3 = vec4(v_7.xy, r3.zw); + let v_8 = (r1.zz * r3.xy); + r3 = vec4(v_8.xy, r3.zw); + let v_9 = (r2.xy / r1.ww); + r2 = vec4(v_9.xy, r2.zw); + let v_10 = (r2.xy * cb12_12.tint_symbol_3[1u].yy); + r2 = vec4(v_10.xy, r2.zw); + let v_11 = (r1.zz * r2.xy); + r1 = vec4(r1.xy, v_11.xy); + let v_12 = r2.w; + let v_13 = max(v_12, -2147483648.0f); + r2.x = bitcast(select(select(i32(v_13), 2147483647i, (v_13 >= 2147483648.0f)), 0i, !((v_12 == v_12)))); + r2.y = bitcast(select(0u, 4294967295u, (bitcast(r2.x) == 0i))); + r1.x = bitcast((bitcast(r1.x) | bitcast(r2.y))); + if ((bitcast(r1.x) != 0u)) { + r1.x = 0.0f; + } else { + r1.x = trunc(r2.w); + r1.x = (1.0f / r1.x); + let v_14 = dpdx(v2.xy); + let v_15 = r2; + r2 = vec4(v_15.x, v_14.xy, v_15.w); + let v_16 = dpdy(v2.xy); + r3 = vec4(r3.xy, v_16.xy); + r4 = textureSampleGrad(t2, s2, v2.xyxx.xy, r2.yz, r3.zw); + r2.w = (r4.x + 0.00000099999999747524f); + let v_17 = r1; + r4 = vec4(v_17.zw, r4.zw); + r4 = vec4(r4.xy, vec2(1.0f)); + let v_18 = r2; + r5 = vec4(v_18.ww, r5.zw); + r5.z = 0.0f; + loop { + r5.w = bitcast(select(0u, 4294967295u, (bitcast(r5.z) >= bitcast(r2.x)))); + if ((bitcast(r5.w) != 0u)) { + break; + } + r5.w = bitcast(select(0u, 4294967295u, (r5.x < r4.z))); + if ((bitcast(r5.w) != 0u)) { + r5.w = ((-(r1.xxxx)).w + r4.z); + let v_19 = fma(r3.xy, r1.xx, r4.xy); + r4 = vec4(v_19.xy, r4.zw); + let v_20 = (r4.xy + v2.xy); + r6 = vec4(v_20.xy, r6.zw); + let v_21 = r2.yz; + let v_22 = r3.zw; + r6 = textureSampleGrad(t2, s2, r6.xyxx.xy, v_21, v_22); + r4.w = r4.z; + let v_23 = r5; + let v_24 = r5; + r5 = vec4(v_24.x, v_23.xz, v_24.w); + r4.z = r5.w; + r5.x = r6.x; + } else { + r5.z = r2.x; + } + r5.z = bitcast((bitcast(r5.z) + 1i)); + } + let v_25 = -(r5.xxxx); + r1.x = (r4.z + v_25.x); + let v_26 = -(r5.yyyy); + r2.x = (r4.w + v_26.x); + r2.y = ((-(r1.xxxx)).y + r2.x); + r2.z = bitcast(select(0u, 4294967295u, (0.0f < r2.y))); + r1.x = (r1.x * r4.w); + let v_27 = -(r1.xxxx); + r1.x = fma(r4.z, r2.x, v_27.x); + r1.x = (r1.x / r2.y); + let v_28 = bitcast>(r2.zzzz); + let v_29 = r1.xxxx; + r1.x = clamp(select(r5.xxxx, v_29, (v_28 != vec4())).x, 0.0f, 1.0f); + } + r1.x = ((-(r1.xxxx)).x + 1.0f); + let v_30 = fma(r3.xy, r1.xx, r1.zw); + let v_31 = r1; + r1 = vec4(v_30.x, v_31.y, v_30.y, v_31.w); + let v_32 = (r1.xz + v2.xy); + let v_33 = r1; + r1 = vec4(v_32.x, v_33.y, v_32.y, v_33.w); + let v_34 = r1; + r2 = vec4(v_34.xz, r2.zw); + } + r3 = textureSample(t0, s0, r2.xyxx.xy); + r4 = textureSample(t3, s3, r1.xzxx.xy); + let v_35 = fma(r4.xy, vec2(2.0f), vec2(-1.0f)); + let v_36 = r1; + r1 = vec4(v_35.x, v_36.y, v_35.y, v_36.w); + r1.w = dot(r1.xz, r1.xz); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.w = sqrt(abs(r1.wwww).w); + r2.z = max(cb12_12.tint_symbol_3[0u].w, 0.00100000004749745131f); + let v_37 = (r1.xz * r2.zz); + let v_38 = r1; + r1 = vec4(v_37.x, v_38.y, v_37.y, v_38.w); + let v_39 = (r1.zzz * v6.xyz); + r4 = vec4(v_39.xyz, r4.w); + let v_40 = fma(r1.xxx, v5.xyz, r4.xyz); + r4 = vec4(v_40.xyz, r4.w); + let v_41 = fma(r1.www, v3.xyz, r4.xyz); + r1 = vec4(v_41.x, r1.y, v_41.yz); + r2.z = dot(r1.xzw, r1.xzw); + r2.z = inverseSqrt(r2.z); + let v_42 = (r1.xzw * r2.zzz); + r4 = vec4(v_42.xyz, r4.w); + r5.x = dot(v5.xyz, cb3_3.tint_symbol_1[0u].xyz); + r5.y = dot(v6.xyz, cb3_3.tint_symbol_1[0u].xyz); + r1.x = dot(v3.xyz, cb3_3.tint_symbol_1[0u].xyz); + r1.z = ((-(v2.zzzz)).z + 1.0f); + r2.w = (cb2_2.tint_symbol[1u].x * cb12_12.tint_symbol_3[1u].x); + let v_43 = (r2.ww * r5.xy); + r5 = vec4(v_43.xy, r5.zw); + let v_44 = (r1.zz * r5.xy); + r5 = vec4(v_44.xy, r5.zw); + let v_45 = (r5.xy / r1.xx); + let v_46 = r1; + r1 = vec4(v_45.x, v_46.y, v_45.y, v_46.w); + r5 = textureSample(t2, s2, r2.xyxx.xy); + r6 = fma(r1.xzxz, vec4(0.87999999523162841797f, 0.87999999523162841797f, 0.76999998092651367188f, 0.76999998092651367188f), r2.xyxy); + r7 = textureSample(t2, s2, r6.xyxx.xy); + r2.w = ((-(r5.xxxx)).w + r7.x); + r2.w = (r2.w + -0.87999999523162841797f); + r6 = textureSample(t2, s2, r6.zwzz.xy); + r4.w = ((-(r5.xxxx)).w + r6.x); + r4.w = (r4.w + -0.76999998092651367188f); + r4.w = (r4.w + r4.w); + r6 = fma(r1.xzxz, vec4(0.66000002622604370117f, 0.66000002622604370117f, 0.55000001192092895508f, 0.55000001192092895508f), r2.xyxy); + r7 = textureSample(t2, s2, r6.xyxx.xy); + r5.y = ((-(r5.xxxx)).y + r7.x); + r5.y = (r5.y + -0.66000002622604370117f); + r6 = textureSample(t2, s2, r6.zwzz.xy); + r5.z = ((-(r5.xxxx)).z + r6.x); + r5.z = (r5.z + -0.55000001192092895508f); + r6 = fma(r1.xzxz, vec4(0.43999999761581420898f, 0.43999999761581420898f, 0.33000001311302185059f, 0.33000001311302185059f), r2.xyxy); + r7 = textureSample(t2, s2, r6.xyxx.xy); + r5.w = ((-(r5.xxxx)).w + r7.x); + r5.w = (r5.w + -0.43999999761581420898f); + let v_47 = (r5.yzw * vec3(4.0f, 6.0f, 8.0f)); + r5 = vec4(r5.x, v_47.xyz); + r6 = textureSample(t2, s2, r6.zwzz.xy); + r6.x = ((-(r5.xxxx)).x + r6.x); + r6.x = (r6.x + -0.33000001311302185059f); + r6.x = (r6.x * 10.0f); + let v_48 = fma(r1.xz, vec2(0.21999999880790710449f), r2.xy); + let v_49 = r1; + r1 = vec4(v_48.x, v_49.y, v_48.y, v_49.w); + r7 = textureSample(t2, s2, r1.xzxx.xy); + r1.x = ((-(r5.xxxx)).x + r7.x); + r1.x = (r1.x + -0.21999999880790710449f); + r1.x = (r1.x * 12.0f); + r1.z = max(r2.w, r4.w); + r1.z = max(r5.y, r1.z); + r1.z = max(r5.z, r1.z); + r1.z = max(r5.w, r1.z); + r1.z = max(r6.x, r1.z); + r1.x = clamp(max(r1.xxxx, r1.zzzz).x, 0.0f, 1.0f); + o2.w = fma((-(r1.xxxx)).w, cb12_12.tint_symbol_3[1u].z, 1.0f); + r0.z = ((-(r0.yyyy)).z + 1.0f); + r0.w = 0.0f; + let v_50 = bitcast>(r1.yyy); + let v_51 = r0.xzw; + let v_52 = select(r3.xyz, v_51, (v_50 != vec3())); + r0 = vec4(v_52.xyz, r0.w); + r0.w = clamp(fma(v3.xyz.zzzz, vec4(128.0f), vec4(-127.0f)).w, 0.0f, 1.0f); + r1.x = (r3.w * v1.w); + let v_53 = (v1.xy * cb2_2.tint_symbol[15u].zy); + let v_54 = r3; + r3 = vec4(v_54.x, v_53.xy, v_54.w); + o0.w = (r1.x * cb2_2.tint_symbol[15u].x); + let v_55 = fma(r4.xyz, vec3(0.5f), vec3(0.5f)); + o1 = vec4(v_55.xyz, o1.w); + r1.x = (cb12_12.tint_symbol_3[1u].w + -0.20000000298023223877f); + r1.x = clamp(((r1.xxxx * vec4(10.0f))).x, 0.0f, 1.0f); + o1.w = (r0.w * r1.x); + r3.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w); + let v_56 = (r3.xz * vec2(0.5f)); + r1 = vec4(v_56.xy, r1.zw); + let v_57 = sqrt(r1.xy); + o3 = vec4(v_57.xy, o3.zw); + r0.w = fma(r1.w, r2.z, -0.34999999403953552246f); + r0.w = clamp(((r0.wwww * vec4(1.53846156597137451172f))).w, 0.0f, 1.0f); + r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z); + r1.x = ((-(cb2_2.tint_symbol[16u].zzzz)).x + 1.0f); + r0.w = (r0.w * r1.x); + r0.w = (r3.y * r0.w); + r1.x = (cb12_12.tint_symbol_3[0u].y * 0.001953125f); + r1.z = (-(r1.xxxx)).z; + r2.x = fma((-(cb12_12.tint_symbol_3[0u].zzzz)).x, 0.5f, 1.0f); + r2.x = (r0.w * r2.x); + r2.y = ((-(cb12_12.tint_symbol_3[1u].wwww)).y + 1.0f); + r2.x = (r2.y * r2.x); + r0.w = (r0.w * cb12_12.tint_symbol_3[1u].w); + r2.x = fma(r2.x, -0.5f, 1.0f); + let v_58 = (r0.xyz * r2.xxx); + o0 = vec4(v_58.xyz, o0.w); + let v_59 = (-(cb12_12.tint_symbol_3[0u].zzzx)).yw; + let v_60 = r1; + r1 = vec4(v_60.x, v_59.x, v_60.z, v_59.y); + let v_61 = (r1.yzw + vec3(0.5f, 0.48828125f, 0.97000002861022949219f)); + r0 = vec4(v_61.xyz, r0.w); + let v_62 = max(r0.xyz, vec3()); + r0 = vec4(v_62.xyz, r0.w); + let v_63 = fma(r0.xz, r0.ww, cb12_12.tint_symbol_3[0u].zx); + let v_64 = r2; + r2 = vec4(v_63.x, v_64.y, v_63.y, v_64.w); + r2.y = fma(r0.y, r0.w, r1.x); + let v_65 = sqrt(r2.xy); + o2 = vec4(v_65.xy, o2.zw); + o2.z = r2.z; + o3 = vec4(o3.xy, vec2(0.0f, 1.00188386440277099609f)); +} + +struct tint_symbol_4 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4) -> tint_symbol_4 { + main_inner(v1, v2, v3, v4, v5, v6); + return tint_symbol_4(o0, o1, o2, o3); +} diff --git a/b/8b0b5899ed/shaders/017ddbb29b2a2343.consts.json b/b/8b0b5899ed/shaders/017ddbb29b2a2343.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..5fccacd3c1d416721b775ddc9a06f6f9a0cfec43 --- /dev/null +++ b/b/8b0b5899ed/shaders/017ddbb29b2a2343.consts.json @@ -0,0 +1 @@ +[4294967295, 2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/017ddbb29b2a2343.wgsl b/b/8b0b5899ed/shaders/017ddbb29b2a2343.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..7bc36602943c277fc274d4629dc8e7fbc1935cc4 --- /dev/null +++ b/b/8b0b5899ed/shaders/017ddbb29b2a2343.wgsl @@ -0,0 +1,692 @@ +enable clip_distances; +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb45_struct { + tint_symbol_1 : array, 45u>, +} + +@group(0u) @binding(3u) var cb3_3 : cb45_struct; + +struct cb15_struct { + tint_symbol_2 : array, 15u>, +} + +@group(0u) @binding(6u) var cb6_6 : cb15_struct; + +struct cb1_struct { + tint_symbol_3 : array, 1u>, +} + +@group(0u) @binding(9u) var cb9_9 : cb1_struct; + +struct cb14_struct { + tint_symbol_4 : array, 14u>, +} + +@group(0u) @binding(8u) var cb8_8 : cb14_struct; + +@group(0u) @binding(21u) var s5 : sampler; + +@group(0u) @binding(22u) var s6 : sampler; + +@group(0u) @binding(31u) var s15 : sampler_comparison; + +@group(0u) @binding(37u) var t5 : texture_2d; + +@group(0u) @binding(38u) var t6 : texture_2d; + +@group(0u) @binding(47u) var t15 : texture_depth_2d; + +var icb0 : array, 10u> = array, 10u>(vec4(0.02027519047260284424f, -0.78676551580429077148f, 0.0f, 0.0f), vec4(-0.70158278942108154297f, -0.47476160526275634766f, 0.0f, 0.0f), vec4(0.54473602771759033203f, -0.06281875073909759521f, 0.0f, 0.0f), vec4(-0.12336549907922744751f, -0.12901020050048828125f, 0.0f, 0.0f), vec4(0.7202141880989074707f, -0.59987431764602661133f, 0.0f, 0.0f), vec4(0.5887699127197265625f, 0.80624562501907348633f, 0.0f, 0.0f), vec4(-0.55884128808975219727f, 0.33167970180511474609f, 0.0f, 0.0f), vec4(-0.33118340373039245605f, 0.88791167736053466797f, 0.0f, 0.0f), vec4(0.05035594850778579712f, 0.48651018738746643066f, 0.0f, 0.0f), vec4(0.9244028925895690918f, 0.36059340834617614746f, 0.0f, 0.0f)); + +var v1 : vec4; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +var o6 : vec4; + +var o7 : array; + +var v : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_6 { + tint_symbol_5 : array, 4u>, +} + +@group(0u) @binding(15u) var v_1 : tint_symbol_6; + +fn main_inner(v0 : vec2, v_2 : i32) { + let v_3 = 0i; + v1.x = bitcast((v_2 - v_3)); + r0.x = f32(bitcast(v1.x)); + r0.x = (r0.x / cb9_9.tint_symbol_3[0u].x); + let v_4 = -(r0.xxxx); + r0.y = bitcast(select(0u, 4294967295u, (r0.x >= v_4.y))); + r0.z = fract(abs(r0.xxxx).z); + let v_5 = -(r0.zzzz); + let v_6 = bitcast(r0.y); + r0.y = select(v_5.y, r0.z, (v_6 != 0u)); + r1.x = (r0.y * cb9_9.tint_symbol_3[0u].x); + r1.y = floor(r0.x); + let v_7 = (r1.xy * cb9_9.tint_symbol_3[0u].zw); + r0 = vec4(v_7.xy, r0.zw); + r1 = textureSampleLevel(t5, s5, r0.xyxx.xy, 0.0f); + r0 = textureSampleLevel(t6, s6, r0.xyxx.xy, 0.0f); + let v_8 = (r1.xyz + cb8_8.tint_symbol_4[10u].yzw); + r2 = vec4(v_8.xyz, r2.w); + r1.x = fract(r0.w); + let v_9 = -(r1.xxxx); + r0.w = (r0.w + v_9.w); + r0.w = (r0.w * cb8_8.tint_symbol_4[10u].x); + r1.y = (r0.w * 0.0039215688593685627f); + let v_10 = (r1.xx * vec2(10.0f, 1000.0f)); + r3 = vec4(v_10.xy, r3.zw); + let v_11 = fract(r3.xy); + r3 = vec4(v_11.xy, r3.zw); + let v_12 = fma(cb8_8.tint_symbol_4[3u].zw, r3.xx, cb8_8.tint_symbol_4[3u].xy); + let v_13 = r3; + r3 = vec4(v_12.x, v_13.y, v_12.y, v_13.w); + r1.z = fma(cb8_8.tint_symbol_4[6u].z, r3.y, cb8_8.tint_symbol_4[6u].y); + r2.w = fma(r3.z, r1.z, r2.z); + let v_14 = (v0 + vec2(-0.5f)); + let v_15 = r3; + r3 = vec4(v_15.x, v_14.x, v_15.z, v_14.y); + r1.z = bitcast(select(0u, 4294967295u, (0.0f < cb8_8.tint_symbol_4[6u].x))); + if ((bitcast(r1.z) != 0u)) { + let v_16 = (r0.xyz + cb8_8.tint_symbol_4[9u].xyz); + r0 = vec4(v_16.xyz, r0.w); + let v_17 = ((-(r2.ywxy)).xyz + cb1_1.tint_symbol[15u].yzx); + r4 = vec4(v_17.xyz, r4.w); + r1.z = dot(r0.xyz, r0.xyz); + r1.z = inverseSqrt(r1.z); + let v_18 = (r0.xyz * r1.zzz); + r0 = vec4(v_18.xyz, r0.w); + let v_19 = (r4.xyz * r0.zxy); + r5 = vec4(v_19.xyz, r5.w); + let v_20 = -(r5.xyzx); + let v_21 = fma(r0.yzx, r4.yzx, v_20.xyz); + r4 = vec4(v_21.xyz, r4.w); + r1.z = dot(r4.xyz, r4.xyz); + r1.z = inverseSqrt(r1.z); + let v_22 = (r1.zzz * r4.xyz); + r4 = vec4(v_22.xyz, r4.w); + r1.z = (r3.x * r3.y); + r4.w = ((-(v0.yyyy)).w + 0.69999998807907104492f); + r4.w = (r3.z * r4.w); + let v_23 = ((-(r0.xyzx)).xyz * r4.www); + r5 = vec4(v_23.xyz, r5.w); + let v_24 = fma(r1.zzz, r4.xyz, r5.xyz); + r5 = vec4(v_24.xyz, r5.w); + } else { + r1.z = (r1.x * 100.0f); + r1.z = fract(r1.z); + r1.z = fma(cb8_8.tint_symbol_4[5u].w, r1.z, cb8_8.tint_symbol_4[5u].z); + r1.z = (abs(r1.wwww).z * r1.z); + let v_25 = r1.zzzz; + r6.x = sin(v_25.x); + r7.x = cos(v_25.x); + r6 = (r6.xxxx * cb1_1.tint_symbol[14u].xyzx); + let v_26 = (r6.zwy + r6.zwy); + r7 = vec4(r7.x, v_26.xyz); + let v_27 = (r6.xyz * r7.zwy); + r8 = vec4(v_27.xyz, r8.w); + let v_28 = (r7.yzw * r7.xxx); + r9 = vec4(v_28.xyz, r9.w); + let v_29 = (r8.zzy + r8.yxx); + r8 = vec4(v_29.xyz, r8.w); + let v_30 = -(r9.xxxx); + r10.x = fma(r6.w, r7.w, v_30.x); + r11.x = fma(r6.w, r7.w, r9.x); + let v_31 = -(r9.yyzy); + let v_32 = fma(r6.yz, r7.yz, v_31.yz); + let v_33 = r11; + r11 = vec4(v_33.x, v_32.xy, v_33.w); + let v_34 = fma(r6.zy, r7.zy, r9.zy); + let v_35 = r10; + r10 = vec4(v_35.x, v_34.xy, v_35.w); + let v_36 = ((-(r8.xyzx)).xyz + vec3(1.0f)); + r6 = vec4(v_36.xyz, r6.w); + let v_37 = r2; + r7 = vec4(v_37.xyw, r7.w); + r7.w = r1.w; + r7 = (-(r7) + cb1_1.tint_symbol[15u]); + r1.z = dot(r7, r7); + r1.z = inverseSqrt(r1.z); + let v_38 = (r1.zzz * r7.yzx); + r7 = vec4(v_38.xyz, r7.w); + r1.z = bitcast(select(0u, 4294967295u, (r7.y < 0.99999499320983886719f))); + let v_39 = (r7.zxy * vec3(0.0f, 1.0f, 0.0f)); + r8 = vec4(v_39.xyz, r8.w); + let v_40 = -(r8.xyzx); + let v_41 = fma(r7.xyz, vec3(0.0f, 0.0f, 1.0f), v_40.xyz); + r8 = vec4(v_41.xyz, r8.w); + r4.w = dot(r8.yz, r8.yz); + r4.w = inverseSqrt(r4.w); + let v_42 = (r4.www * r8.xyz); + r8 = vec4(v_42.xyz, r8.w); + let v_43 = (r7.xyz * r8.xyz); + r9 = vec4(v_43.xyz, r9.w); + let v_44 = -(r9.xyzx); + let v_45 = fma(r8.zxy, r7.yzx, v_44.xyz); + r7 = vec4(v_45.xyz, r7.w); + r4.w = dot(r7.xyz, r7.xyz); + r4.w = inverseSqrt(r4.w); + let v_46 = (r4.www * r7.xyz); + r7 = vec4(v_46.xyz, r7.w); + let v_47 = bitcast>(r1.zz); + let v_48 = select(vec2(1.0f, 0.0f), r8.yz, (v_47 != vec2())); + r8 = vec4(v_48.xy, r8.zw); + let v_49 = bitcast>(r1.zzz); + let v_50 = select(vec3(0.0f, 1.0f, 0.0f), r7.xyz, (v_49 != vec3())); + r7 = vec4(v_50.xyz, r7.w); + r10.w = r6.x; + r0.x = dot(r7.yzx, r10.xyw); + r11.w = r6.y; + r0.y = dot(r7.xzy, r11.xyw); + r6.x = r11.z; + r6.y = r10.z; + r0.z = dot(r7.xyz, r6.xyz); + r4.x = dot(r8.yx, r10.xw); + r4.y = dot(r8.xy, r11.xw); + r4.z = dot(r8.xy, r6.xy); + let v_51 = (r3.xz * r3.yw); + r3 = vec4(v_51.xy, r3.zw); + let v_52 = (r0.xyz * r3.yyy); + r3 = vec4(r3.x, v_52.xyz); + let v_53 = fma(r3.xxx, r4.xyz, r3.yzw); + r5 = vec4(v_53.xyz, r5.w); + } + let v_54 = (r2.xyw + r5.xyz); + r3 = vec4(v_54.xyz, r3.w); + r5 = (r3.yyyy * cb1_1.tint_symbol[9u]); + r5 = fma(r3.xxxx, cb1_1.tint_symbol[8u], r5); + r5 = fma(r3.zzzz, cb1_1.tint_symbol[10u], r5); + r5 = (r5 + cb1_1.tint_symbol[11u]); + let v_55 = -(abs(r1.wwww)); + r0.w = fma(r0.w, 0.0039215688593685627f, v_55.w); + r1.z = (r0.w * cb8_8.tint_symbol_4[2u].x); + r1.y = (r0.w / r1.y); + let v_56 = -(r1.zzzz); + r1.y = fma(r1.y, cb8_8.tint_symbol_4[2u].x, v_56.y); + r1.y = fma(cb8_8.tint_symbol_4[2u].y, r1.y, r1.z); + r1.y = fract(r1.y); + r1.z = bitcast(select(0u, 4294967295u, (0.0f >= cb8_8.tint_symbol_4[2u].x))); + r1.z = bitcast((bitcast(r1.z) & 1065353216u)); + r1.x = ((-(r1.yyyy)).x + r1.x); + r1.x = fma(r1.x, r1.z, r1.y); + r1.x = (r1.x * 0.99900001287460327148f); + r1.y = (cb8_8.tint_symbol_4[1u].w + 1.0f); + let v_57 = -(cb8_8.tint_symbol_4[1u].zzzz); + r1.y = (r1.y + v_57.y); + r1.y = fma(r1.x, r1.y, cb8_8.tint_symbol_4[1u].z); + r1.y = floor(r1.y); + r1.y = (r1.y / cb8_8.tint_symbol_4[1u].y); + let v_58 = -(r1.yyyy); + r1.z = bitcast(select(0u, 4294967295u, (r1.y >= v_58.z))); + r2.w = fract(abs(r1.yyyy).w); + let v_59 = -(r2.wwww); + let v_60 = bitcast(r1.z); + r1.z = select(v_59.z, r2.w, (v_60 != 0u)); + r6.x = (r1.z * cb8_8.tint_symbol_4[1u].y); + r6.y = floor(r1.y); + let v_61 = (vec2(1.0f) / cb8_8.tint_symbol_4[1u].yx); + let v_62 = r1; + r1 = vec4(v_62.x, v_61.xy, v_62.w); + let v_63 = (r6.xy + v0); + r6 = vec4(v_63.xy, r6.zw); + let v_64 = (r1.yz * r6.xy); + o1 = vec4(v_64.xy, o1.zw); + r2.w = (cb8_8.tint_symbol_4[2u].w + 1.0f); + let v_65 = -(cb8_8.tint_symbol_4[2u].zzzz); + r2.w = (r2.w + v_65.w); + r1.x = fma(r1.x, r2.w, cb8_8.tint_symbol_4[2u].z); + r1.x = floor(r1.x); + r1.x = (r1.x / cb8_8.tint_symbol_4[1u].y); + let v_66 = -(r1.xxxx); + r2.w = bitcast(select(0u, 4294967295u, (r1.x >= v_66.w))); + r3.w = fract(abs(r1.xxxx).w); + let v_67 = -(r3.wwww); + let v_68 = bitcast(r2.w); + r2.w = select(v_67.w, r3.w, (v_68 != 0u)); + r6.z = (r2.w * cb8_8.tint_symbol_4[1u].y); + r6.w = floor(r1.x); + let v_69 = (r6.zw + v0); + r6 = vec4(v_69.xy, r6.zw); + let v_70 = (r1.yz * r6.xy); + o1 = vec4(o1.xy, v_70.xy); + let v_71 = -(cb1_1.tint_symbol[15u].xyzx); + let v_72 = (r2.xyz + v_71.xyz); + r1 = vec4(v_72.xyz, r1.w); + r1.x = dot(r1.xyz, r1.xyz); + r1.x = inverseSqrt(r1.x); + r1.x = (r1.x * r1.z); + r1.y = ((-(abs(r1.xxxx))).y + 1.0f); + let v_73 = -(cb8_8.tint_symbol_4[13u].xxxx); + r1.y = (r1.y + v_73.y); + let v_74 = abs(r1.xxxx); + r1.x = (v_74.x + (-(cb8_8.tint_symbol_4[13u].zzzz)).x); + o5 = clamp(((r1.yxyy * cb8_8.tint_symbol_4[13u].ywyy)).xy, vec2(), vec2(1.0f)).xyxy; + let v_75 = ((-(r2.xyxx)).xy + cb1_1.tint_symbol[15u].xy); + r1 = vec4(v_75.xy, r1.zw); + r1.x = dot(r1.xy, r1.xy); + r1.x = sqrt(r1.x); + r1.y = (r1.x * cb8_8.tint_symbol_4[7u].x); + r1.x = fma((-(r1.xxxx)).x, cb8_8.tint_symbol_4[7u].y, 1.0f); + r1.z = (r1.x * r1.x); + r1.x = clamp(((r1.xxxx * r1.zzzz)).x, 0.0f, 1.0f); + r1.x = (r1.x * cb8_8.tint_symbol_4[4u].w); + r1.z = (r1.y * r1.y); + r1.y = clamp(((r1.yyyy * r1.zzzz)).y, 0.0f, 1.0f); + r1.x = (r1.y * r1.x); + let v_76 = -(cb8_8.tint_symbol_4[8u].xxxx); + r1.y = (r2.z + v_76.y); + let v_77 = abs(cb8_8.tint_symbol_4[8u].yyzy); + let v_78 = clamp(((r1.yyyy * v_77)).yz, vec2(), vec2(1.0f)); + let v_79 = r1; + r1 = vec4(v_79.x, v_78.xy, v_79.w); + r1.x = (r1.y * r1.x); + r1.y = ((-(r1.zzzz)).y + 1.0f); + r1.x = (r1.y * r1.x); + r0.w = clamp(((r0.wwww * cb8_8.tint_symbol_4[5u].xxxx)).w, 0.0f, 1.0f); + r1.y = clamp(((abs(r1.wwww) * cb8_8.tint_symbol_4[5u].yyyy)).y, 0.0f, 1.0f); + r0.w = (r0.w * r1.y); + r0.w = (r0.w * r1.x); + let v_80 = ((-(r2.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r1 = vec4(v_80.xyz, r1.w); + r2.w = dot(r1.xyz, r1.xyz); + r2.w = inverseSqrt(r2.w); + let v_81 = (r1.xyz * r2.www); + r1 = vec4(v_81.xyz, r1.w); + r2.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_1[2u].x)))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_1[19u].w == 0.0f))); + let v_82 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_1[3u].xyz); + r6 = vec4(v_82.xyz, r6.w); + let v_83 = -(cb3_3.tint_symbol_1[3u].xyzx); + let v_84 = (r2.xyz + v_83.xyz); + r7 = vec4(v_84.xyz, r7.w); + r4.w = dot(r7.xyz, cb3_3.tint_symbol_1[11u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_1[19u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_1[19u].w); + let v_85 = fma(cb3_3.tint_symbol_1[11u].xyz, r4.www, cb3_3.tint_symbol_1[3u].xyz); + r7 = vec4(v_85.xyz, r7.w); + let v_86 = ((-(r2.xyzx)).xyz + r7.xyz); + r7 = vec4(v_86.xyz, r7.w); + let v_87 = bitcast>(r3.www); + let v_88 = r6.xyz; + let v_89 = select(r7.xyz, v_88, (v_87 != vec3())); + r6 = vec4(v_89.xyz, r6.w); + r3.w = dot(r6.xyz, r6.xyz); + let v_90 = (r6.xyz + vec3(0.00000099999999747524f)); + r6 = vec4(v_90.xyz, r6.w); + r4.w = dot(r6.xyz, r6.xyz); + r4.w = inverseSqrt(r4.w); + let v_91 = (r4.www * r6.xyz); + r6 = vec4(v_91.xyz, r6.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_1[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_1[11u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_1[11u].w); + r3.w = (r3.w / r4.w); + let v_92 = -(cb3_3.tint_symbol_1[11u].xyzx); + r4.w = dot(r6.xyz, v_92.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_1[27u].xxxx, cb3_3.tint_symbol_1[35u].xxxx).w, 0.0f, 1.0f); + r6.x = dot(r6.xyz, r1.xyz); + r6.y = clamp(r6.xxxx.y, 0.0f, 1.0f); + r6.y = ((-(abs(r6.xxxx))).y + r6.y); + let v_93 = abs(r6.xxxx); + r6.x = fma(r0.w, r6.y, v_93.x); + r4.w = (r4.w * r6.x); + r3.w = (r3.w * r4.w); + let v_94 = (r3.www * cb3_3.tint_symbol_1[19u].xyz); + r6 = vec4(v_94.xyz, r6.w); + let v_95 = bitcast>(r2.www); + let v_96 = select(r6.xyz, vec3(), (v_95 != vec3())); + r6 = vec4(v_96.xyz, r6.w); + r3.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_1[2u].x)))); + if ((bitcast(r3.w) != 0u)) { + r3.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_1[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_1[20u].w == 0.0f))); + let v_97 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_1[4u].xyz); + r7 = vec4(v_97.xyz, r7.w); + let v_98 = -(cb3_3.tint_symbol_1[4u].xyzx); + let v_99 = (r2.xyz + v_98.xyz); + r8 = vec4(v_99.xyz, r8.w); + r4.w = dot(r8.xyz, cb3_3.tint_symbol_1[12u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_1[20u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_1[20u].w); + let v_100 = fma(cb3_3.tint_symbol_1[12u].xyz, r4.www, cb3_3.tint_symbol_1[4u].xyz); + r8 = vec4(v_100.xyz, r8.w); + let v_101 = ((-(r2.xyzx)).xyz + r8.xyz); + r8 = vec4(v_101.xyz, r8.w); + let v_102 = bitcast>(r3.www); + let v_103 = r7.xyz; + let v_104 = select(r8.xyz, v_103, (v_102 != vec3())); + r7 = vec4(v_104.xyz, r7.w); + r3.w = dot(r7.xyz, r7.xyz); + let v_105 = (r7.xyz + vec3(0.00000099999999747524f)); + r7 = vec4(v_105.xyz, r7.w); + r4.w = dot(r7.xyz, r7.xyz); + r4.w = inverseSqrt(r4.w); + let v_106 = (r4.www * r7.xyz); + r7 = vec4(v_106.xyz, r7.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_1[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_1[12u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_1[12u].w); + r3.w = (r3.w / r4.w); + let v_107 = -(cb3_3.tint_symbol_1[12u].xyzx); + r4.w = dot(r7.xyz, v_107.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_1[28u].xxxx, cb3_3.tint_symbol_1[36u].xxxx).w, 0.0f, 1.0f); + r6.w = dot(r7.xyz, r1.xyz); + r7.x = clamp(r6.wwww.x, 0.0f, 1.0f); + r7.x = ((-(abs(r6.wwww))).x + r7.x); + let v_108 = abs(r6.wwww); + r6.w = fma(r0.w, r7.x, v_108.w); + r4.w = (r4.w * r6.w); + r3.w = (r3.w * r4.w); + let v_109 = fma(r3.www, cb3_3.tint_symbol_1[20u].xyz, r6.xyz); + r7 = vec4(v_109.xyz, r7.w); + let v_110 = bitcast>(r2.www); + let v_111 = r6.xyz; + let v_112 = select(r7.xyz, v_111, (v_110 != vec3())); + r6 = vec4(v_112.xyz, r6.w); + } else { + r2.w = bitcast(v_1.tint_symbol_5[0i].x); + } + if ((bitcast(r2.w) != 0u)) { + r2.w = bitcast(v_1.tint_symbol_5[0i].x); + } else { + r3.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_1[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_1[21u].w == 0.0f))); + let v_113 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_1[5u].xyz); + r7 = vec4(v_113.xyz, r7.w); + let v_114 = -(cb3_3.tint_symbol_1[5u].xyzx); + let v_115 = (r2.xyz + v_114.xyz); + r8 = vec4(v_115.xyz, r8.w); + r4.w = dot(r8.xyz, cb3_3.tint_symbol_1[13u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_1[21u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_1[21u].w); + let v_116 = fma(cb3_3.tint_symbol_1[13u].xyz, r4.www, cb3_3.tint_symbol_1[5u].xyz); + r8 = vec4(v_116.xyz, r8.w); + let v_117 = ((-(r2.xyzx)).xyz + r8.xyz); + r8 = vec4(v_117.xyz, r8.w); + let v_118 = bitcast>(r3.www); + let v_119 = r7.xyz; + let v_120 = select(r8.xyz, v_119, (v_118 != vec3())); + r7 = vec4(v_120.xyz, r7.w); + r3.w = dot(r7.xyz, r7.xyz); + let v_121 = (r7.xyz + vec3(0.00000099999999747524f)); + r7 = vec4(v_121.xyz, r7.w); + r4.w = dot(r7.xyz, r7.xyz); + r4.w = inverseSqrt(r4.w); + let v_122 = (r4.www * r7.xyz); + r7 = vec4(v_122.xyz, r7.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_1[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_1[13u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_1[13u].w); + r3.w = (r3.w / r4.w); + let v_123 = -(cb3_3.tint_symbol_1[13u].xyzx); + r4.w = dot(r7.xyz, v_123.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_1[29u].xxxx, cb3_3.tint_symbol_1[37u].xxxx).w, 0.0f, 1.0f); + r6.w = dot(r7.xyz, r1.xyz); + r7.x = clamp(r6.wwww.x, 0.0f, 1.0f); + r7.x = ((-(abs(r6.wwww))).x + r7.x); + let v_124 = abs(r6.wwww); + r6.w = fma(r0.w, r7.x, v_124.w); + r4.w = (r4.w * r6.w); + r3.w = (r3.w * r4.w); + let v_125 = fma(r3.www, cb3_3.tint_symbol_1[21u].xyz, r6.xyz); + r7 = vec4(v_125.xyz, r7.w); + let v_126 = bitcast>(r2.www); + let v_127 = r6.xyz; + let v_128 = select(r7.xyz, v_127, (v_126 != vec3())); + r6 = vec4(v_128.xyz, r6.w); + } + if ((bitcast(r2.w) != 0u)) { + } else { + r3.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_1[2u].x)))); + r2.w = bitcast((bitcast(r2.w) | bitcast(r3.w))); + r3.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_1[22u].w == 0.0f))); + let v_129 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_1[6u].xyz); + r7 = vec4(v_129.xyz, r7.w); + let v_130 = -(cb3_3.tint_symbol_1[6u].xyzx); + let v_131 = (r2.xyz + v_130.xyz); + r8 = vec4(v_131.xyz, r8.w); + r4.w = dot(r8.xyz, cb3_3.tint_symbol_1[14u].xyz); + r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_1[22u].wwww)).w, 0.0f, 1.0f); + r4.w = (r4.w * cb3_3.tint_symbol_1[22u].w); + let v_132 = fma(cb3_3.tint_symbol_1[14u].xyz, r4.www, cb3_3.tint_symbol_1[6u].xyz); + r8 = vec4(v_132.xyz, r8.w); + let v_133 = ((-(r2.xyzx)).xyz + r8.xyz); + r8 = vec4(v_133.xyz, r8.w); + let v_134 = bitcast>(r3.www); + let v_135 = r7.xyz; + let v_136 = select(r8.xyz, v_135, (v_134 != vec3())); + r7 = vec4(v_136.xyz, r7.w); + r3.w = dot(r7.xyz, r7.xyz); + let v_137 = (r7.xyz + vec3(0.00000099999999747524f)); + r7 = vec4(v_137.xyz, r7.w); + r4.w = dot(r7.xyz, r7.xyz); + r4.w = inverseSqrt(r4.w); + let v_138 = (r4.www * r7.xyz); + r7 = vec4(v_138.xyz, r7.w); + r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_1[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r4.w = ((-(cb3_3.tint_symbol_1[14u].wwww)).w + 1.0f); + r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_1[14u].w); + r3.w = (r3.w / r4.w); + let v_139 = -(cb3_3.tint_symbol_1[14u].xyzx); + r4.w = dot(r7.xyz, v_139.xyz); + r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_1[30u].xxxx, cb3_3.tint_symbol_1[38u].xxxx).w, 0.0f, 1.0f); + r1.x = dot(r7.xyz, r1.xyz); + r1.y = clamp(r1.xxxx.y, 0.0f, 1.0f); + r1.y = ((-(abs(r1.xxxx))).y + r1.y); + let v_140 = abs(r1.xxxx); + r1.x = fma(r0.w, r1.y, v_140.x); + r1.x = (r4.w * r1.x); + r1.x = (r3.w * r1.x); + let v_141 = fma(r1.xxx, cb3_3.tint_symbol_1[22u].xyz, r6.xyz); + r1 = vec4(v_141.xyz, r1.w); + let v_142 = bitcast>(r2.www); + let v_143 = r6.xyz; + let v_144 = select(r1.xyz, v_143, (v_142 != vec3())); + r6 = vec4(v_144.xyz, r6.w); + } + let v_145 = (cb3_3.tint_symbol_1[43u].xyz + cb3_3.tint_symbol_1[44u].xyz); + r1 = vec4(v_145.xyz, r1.w); + r2.w = bitcast(select(0u, 4294967295u, (0.0f < cb8_8.tint_symbol_4[12u].x))); + if ((bitcast(r2.w) != 0u)) { + let v_146 = (r3.yyy * cb1_1.tint_symbol[1u].xyz); + r7 = vec4(v_146.xyz, r7.w); + let v_147 = fma(r3.xxx, cb1_1.tint_symbol[0u].xyz, r7.xyz); + r3 = vec4(v_147.xy, r3.z, v_147.z); + let v_148 = fma(r3.zzz, cb1_1.tint_symbol[2u].xyz, r3.xyw); + r3 = vec4(v_148.xyz, r3.w); + let v_149 = (r3.xyz + cb1_1.tint_symbol[3u].xyz); + r3 = vec4(v_149.xyz, r3.w); + let v_150 = (r2.xyz + r3.xyz); + r7 = vec4(v_150.xyz, r7.w); + let v_151 = -(r3.xyzx); + let v_152 = (r2.xyz + v_151.xyz); + r2 = vec4(v_152.xyz, r2.w); + r2.x = dot(r2.xyz, r2.xyz); + r2.x = sqrt(r2.x); + r2.y = fma((-(cb6_6.tint_symbol_2[14u].zzzz)).y, 1.5f, 1.0f); + let v_153 = (r2.xy * vec2(0.5f)); + r2 = vec4(v_153.xy, r2.zw); + r2 = vec4(r2.xy, vec2()); + loop { + r3.x = bitcast(select(0u, 4294967295u, (bitcast(r2.w) >= 10i))); + if ((bitcast(r3.x) != 0u)) { + break; + } + let v_154 = (r0.xyz * icb0[bitcast(r2.w)].yyy); + r3 = vec4(v_154.xyz, r3.w); + let v_155 = fma(r4.xyz, icb0[bitcast(r2.w)].xxx, r3.xyz); + r3 = vec4(v_155.xyz, r3.w); + let v_156 = (r2.xxx * r3.xyz); + r3 = vec4(v_156.xyz, r3.w); + let v_157 = fma(r7.xyz, vec3(0.5f), r3.xyz); + r3 = vec4(v_157.xyz, r3.w); + let v_158 = (r3.xyz + v_71.xyz); + r3 = vec4(v_158.xyz, r3.w); + let v_159 = (r3.yyy * cb6_6.tint_symbol_2[1u].xyz); + r8 = vec4(v_159.xyz, r8.w); + let v_160 = fma(r3.xxx, cb6_6.tint_symbol_2[0u].xyz, r8.xyz); + r3 = vec4(v_160.xy, r3.z, v_160.z); + let v_161 = fma(r3.zzz, cb6_6.tint_symbol_2[2u].xyz, r3.xyw); + r3 = vec4(v_161.xyz, r3.w); + let v_162 = fma(r3.xyz, cb6_6.tint_symbol_2[4u].xyz, cb6_6.tint_symbol_2[8u].xyz); + r8 = vec4(v_162.xyz, r8.w); + let v_163 = &(x0[0u]); + let v_164 = r8; + *(v_163) = vec4(v_164.xyz, (*(v_163)).w); + let v_165 = fma(r3.xyz, cb6_6.tint_symbol_2[5u].xyz, cb6_6.tint_symbol_2[9u].xyz); + r9 = vec4(v_165.xyz, r9.w); + let v_166 = &(x0[1u]); + let v_167 = r9; + *(v_166) = vec4(v_167.xyz, (*(v_166)).w); + let v_168 = fma(r3.xyz, cb6_6.tint_symbol_2[6u].xyz, cb6_6.tint_symbol_2[10u].xyz); + r10 = vec4(v_168.xyz, r10.w); + let v_169 = &(x0[2u]); + let v_170 = r10; + *(v_169) = vec4(v_170.xyz, (*(v_169)).w); + let v_171 = fma(r3.xyz, cb6_6.tint_symbol_2[7u].xyz, cb6_6.tint_symbol_2[11u].xyz); + r3 = vec4(v_171.xyz, r3.w); + let v_172 = &(x0[3u]); + let v_173 = r3; + *(v_172) = vec4(v_173.xyz, (*(v_172)).w); + let v_174 = abs(r10.yyyy); + r3.x = max(v_174.x, abs(r10.xxxx).x); + r3.x = bitcast(select(0u, 4294967295u, (r3.x < r2.y))); + let v_175 = (bitcast(r3.x) != 0u); + let v_176 = bitcast(v_1.tint_symbol_5[1i].x); + r3.x = select(bitcast(v_1.tint_symbol_5[2i].x), v_176, v_175); + let v_177 = abs(r9.yyyy); + r3.y = max(v_177.y, abs(r9.xxxx).y); + r3.y = bitcast(select(0u, 4294967295u, (r3.y < r2.y))); + let v_178 = bitcast(r3.y); + r3.x = select(r3.x, bitcast(v_1.tint_symbol_5[3i].x), (v_178 != 0u)); + let v_179 = abs(r8.yyyy); + r3.y = max(v_179.y, abs(r8.xxxx).y); + r3.y = bitcast(select(0u, 4294967295u, (r3.y < r2.y))); + let v_180 = bitcast(r3.y); + r3.x = select(r3.x, 0.0f, (v_180 != 0u)); + let v_181 = x0[bitcast(r3.x)]; + r3 = vec4(r3.x, v_181.xyz); + r3.x = f32(bitcast(r3.x)); + r3.x = (r3.x + 0.5f); + r3.x = (r3.x * 0.25f); + r3.y = (r3.y + cb6_6.tint_symbol_2[14u].z); + r3.x = fma(r3.z, 0.25f, r3.x); + let v_182 = (r3.yw + vec2(0.5f, 0.0f)); + let v_183 = r8; + r8 = vec4(v_182.x, v_183.y, v_182.y, v_183.w); + r8.y = fma(cb6_6.tint_symbol_2[14u].w, 0.25f, r3.x); + let v_184 = r8.xyxx; + r3.x = textureSampleCompareLevel(t15, s15, v_184.xy, r8.z); + r2.z = (r2.z + r3.x); + r2.w = bitcast((bitcast(r2.w) + 1i)); + } + r0.x = fma(r2.z, 0.10000000149011611938f, -1.0f); + r0.x = fma(cb8_8.tint_symbol_4[12u].x, r0.x, 1.0f); + let v_185 = (r0.xxx * cb3_3.tint_symbol_1[1u].xyz); + r0 = vec4(v_185.xyz, r0.w); + } else { + let v_186 = cb3_3.tint_symbol_1[1u]; + r0 = vec4(v_186.xyz, r0.w); + } + let v_187 = (r1.xyz + r0.xyz); + r0 = vec4(v_187.xyz, r0.w); + let v_188 = (r6.xyz * cb8_8.tint_symbol_4[12u].yyy); + r1 = vec4(v_188.xyz, r1.w); + let v_189 = fma(r0.xyz, cb8_8.tint_symbol_4[0u].xxx, r1.xyz); + o4 = vec4(v_189.xyz, o4.w); + r0.x = (r1.w * r0.w); + r0.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f >= r0.x))); + x1[0u] = select(vec4(1.0f), vec4(-1.0f), (bitcast>(r0.xxxx) != vec4())); + let v_190 = cb8_8.tint_symbol_4[4u]; + o3 = vec4(v_190.xyz, o3.w); + o3.w = r0.w; + o4.w = r5.w; + o6 = r5; + r0 = vec4(v0.xy, r0.zw); + r0.z = 0.0f; + o0 = r0.xyz.xyzx; + o2 = r0.xyz.xyzx; + o7[0u] = x1[0u].x; + o7[1u] = x1[0u].y; + o7[2u] = x1[0u].z; + o7[3u] = x1[0u].w; + v = vec4(o7[0u], o7[1u], o7[2u], o7[3u]); +} + +struct tint_symbol_8 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, + @builtin(position) + o6 : vec4, + @builtin(clip_distances) + o7 : array, + @location(15u) + tint_symbol_7 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec2, @builtin(instance_index) v_191 : u32) -> tint_symbol_8 { + main_inner(v0, i32(v_191)); + return tint_symbol_8(o0, o1, o2, o3, o4, o5, o6, o7, v); +} diff --git a/b/8b0b5899ed/shaders/018361322397e42c.wgsl b/b/8b0b5899ed/shaders/018361322397e42c.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..70399390734bc4435f302bf7edd56766a93c50df --- /dev/null +++ b/b/8b0b5899ed/shaders/018361322397e42c.wgsl @@ -0,0 +1,123 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb12_struct { + tint_symbol : array, 12u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb12_struct; + +struct cb6_struct { + tint_symbol_1 : array, 6u>, +} + +@group(0u) @binding(10u) var cb10_10 : cb6_struct; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +var o6 : vec4; + +var o7 : vec4; + +fn main_inner(v0 : vec3, v1 : vec4, v2 : vec2, v3 : vec3, v4 : vec4) { + let v = (v3 * cb10_10.tint_symbol_1[0u].xxx); + r0 = vec4(v.xyz, r0.w); + let v_1 = fma(r0.xyz, vec3(3.0f), v0); + r0 = vec4(v_1.xyz, r0.w); + r1 = (r0.yyyy * cb1_1.tint_symbol[9u]); + r1 = fma(r0.xxxx, cb1_1.tint_symbol[8u], r1); + r0 = fma(r0.zzzz, cb1_1.tint_symbol[10u], r1); + o0 = (r0 + cb1_1.tint_symbol[11u]); + o1 = v1; + o2 = (v2.xyxy * cb10_10.tint_symbol_1[1u].xxyy); + let v_2 = (cb10_10.tint_symbol_1[2u].yx * cb10_10.tint_symbol_1[2u].yx); + r0 = vec4(v_2.xy, r0.zw); + let v_3 = -(r0.yyyy); + r0.y = fma(cb10_10.tint_symbol_1[2u].y, cb10_10.tint_symbol_1[2u].y, v_3.y); + r0.y = (1.0f / r0.y); + o3.z = (r0.y * r0.x); + o3.w = -(r0.y); + o3.x = cb10_10.tint_symbol_1[5u].w; + o3.y = cb10_10.tint_symbol_1[3u].w; + let v_4 = (v0.yyy * cb1_1.tint_symbol[1u].xyz); + r0 = vec4(v_4.xyz, r0.w); + let v_5 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz); + r0 = vec4(v_5.xyz, r0.w); + let v_6 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz); + r0 = vec4(v_6.xyz, r0.w); + o4 = ((r0.xyz + cb1_1.tint_symbol[3u].xyz)).xyzx; + r0.x = dot(v3, v3); + r0.x = bitcast(select(0u, 4294967295u, (r0.x < 0.10000000149011611938f))); + let v_7 = select(v3, vec3(0.0f, 0.0f, 1.0f), (bitcast>(r0.xxx) != vec3())); + r0 = vec4(v_7.xyz, r0.w); + let v_8 = (r0.yyy * cb1_1.tint_symbol[1u].xyz); + r1 = vec4(v_8.xyz, r1.w); + let v_9 = fma(r0.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz); + r0 = vec4(v_9.xy, r0.z, v_9.z); + let v_10 = fma(r0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyw); + r0 = vec4(v_10.xyz, r0.w); + r0.w = dot(r0.xyz, r0.xyz); + r0.w = inverseSqrt(r0.w); + let v_11 = (r0.www * r0.xyz); + r0 = vec4(v_11.xyz, r0.w); + o5 = r0.xyz.xyzx; + let v_12 = (v4.yyy * cb1_1.tint_symbol[1u].xyz); + r1 = vec4(v_12.xyz, r1.w); + let v_13 = fma(v4.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz); + r1 = vec4(v_13.xyz, r1.w); + let v_14 = fma(v4.zzz, cb1_1.tint_symbol[2u].xyz, r1.xyz); + r1 = vec4(v_14.xyz, r1.w); + let v_15 = r1; + o6 = vec4(v_15.xyz, o6.w); + let v_16 = (v2 * cb10_10.tint_symbol_1[1u].zz); + r2 = vec4(v_16.xy, r2.zw); + o6.w = r2.x; + o7.w = r2.y; + let v_17 = (r0.yzx * r1.zxy); + r2 = vec4(v_17.xyz, r2.w); + let v_18 = -(r2.xyzx); + let v_19 = fma(r1.yzx, r0.zxy, v_18.xyz); + r0 = vec4(v_19.xyz, r0.w); + let v_20 = (r0.xyz * v4.www); + o7 = vec4(v_20.xyz, o7.w); +} + +struct tint_symbol_2 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, + @location(6u) + o6 : vec4, + @location(7u) + o7 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(2u) v2 : vec2, @location(3u) v3 : vec3, @location(4u) v4 : vec4) -> tint_symbol_2 { + main_inner(v0, v1, v2, v3, v4); + return tint_symbol_2(o0, o1, o2, o3, o4, o5, o6, o7); +} diff --git a/b/8b0b5899ed/shaders/0184dbef5faab5b1.consts.json b/b/8b0b5899ed/shaders/0184dbef5faab5b1.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..9c27df027d15db715744502f6c2271644a23c98e --- /dev/null +++ b/b/8b0b5899ed/shaders/0184dbef5faab5b1.consts.json @@ -0,0 +1 @@ +[2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/0184dbef5faab5b1.wgsl b/b/8b0b5899ed/shaders/0184dbef5faab5b1.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..5224668275628c301ce0a937924520491e2895e4 --- /dev/null +++ b/b/8b0b5899ed/shaders/0184dbef5faab5b1.wgsl @@ -0,0 +1,282 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb17_struct { + tint_symbol_1 : array, 17u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb60_struct { + tint_symbol_2 : array, 60u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb60_struct; + +struct cb4_struct { + tint_symbol_3 : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +struct cb10_struct { + tint_symbol_4 : array, 10u>, +} + +@group(1u) @binding(11u) var cb11_11 : cb10_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v5 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 3u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4) { + x1[0u].x = v5[0u]; + x1[0u].y = v5[1u]; + x1[0u].z = v5[2u]; + x1[0u].w = v5[3u]; + let v_1 = (v2.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r0 = vec4(v_1.xyz, r0.w); + let v_2 = (r0.yyy * cb6_6.tint_symbol_5[1u].xyz); + r1 = vec4(v_2.xyz, r1.w); + let v_3 = fma(r0.xxx, cb6_6.tint_symbol_5[0u].xyz, r1.xyz); + r0 = vec4(v_3.xy, r0.z, v_3.z); + let v_4 = fma(r0.zzz, cb6_6.tint_symbol_5[2u].xyz, r0.xyw); + r0 = vec4(v_4.xyz, r0.w); + let v_5 = fma(r0.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r1 = vec4(v_5.xyz, r1.w); + let v_6 = &(x0[0u]); + let v_7 = r1; + *(v_6) = vec4(v_7.xyz, (*(v_6)).w); + let v_8 = abs(r1.yyyy); + r0.w = max(v_8.w, abs(r1.xxxx).w); + let v_9 = fma(r0.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r1 = vec4(v_9.xyz, r1.w); + let v_10 = &(x0[1u]); + let v_11 = r1; + *(v_10) = vec4(v_11.xyz, (*(v_10)).w); + let v_12 = abs(r1.yyyy); + r1.x = max(v_12.x, abs(r1.xxxx).x); + let v_13 = fma(r0.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r1 = vec4(r1.x, v_13.xyz); + let v_14 = fma(r0.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r0 = vec4(v_14.xyz, r0.w); + let v_15 = &(x0[2u]); + let v_16 = r1; + *(v_15) = vec4(v_16.yzw, (*(v_15)).w); + let v_17 = abs(r1.zzzz); + r1.y = max(v_17.y, abs(r1.yyyy).y); + let v_18 = &(x0[3u]); + let v_19 = r0; + *(v_18) = vec4(v_19.xyz, (*(v_18)).w); + let v_20 = abs(r0.yyyy); + r0.x = max(v_20.x, abs(r0.xxxx).x); + r0.x = clamp(fma(r0.xxxx, vec4(15.0f), vec4(-6.30000019073486328125f)).x, 0.0f, 1.0f); + r0.y = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).y, 1.5f, 1.0f); + r0.y = (r0.y * 0.5f); + r0.z = bitcast(select(0u, 4294967295u, (r1.y < r0.y))); + let v_21 = (bitcast(r0.z) != 0u); + let v_22 = bitcast(v.tint_symbol_6[0i].x); + r0.z = select(bitcast(v.tint_symbol_6[1i].x), v_22, v_21); + r1.x = bitcast(select(0u, 4294967295u, (r1.x < r0.y))); + r0.y = bitcast(select(0u, 4294967295u, (r0.w < r0.y))); + let v_23 = bitcast(r1.x); + r0.z = select(r0.z, bitcast(v.tint_symbol_6[2i].x), (v_23 != 0u)); + let v_24 = bitcast(r0.y); + r0.y = select(r0.z, 0.0f, (v_24 != 0u)); + r0.z = f32(bitcast(r0.y)); + let v_25 = x0[bitcast(r0.y)]; + r1 = vec4(v_25.xyz, r1.w); + r0.y = (r0.z + 0.5f); + r2 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r0.zzzz))); + r2 = bitcast>((bitcast>(r2) & vec4(1065353216u))); + r0.y = (r0.y * 0.25f); + r0.y = fma(r1.y, 0.25f, r0.y); + r0.z = (r1.x + 0.5f); + r4.x = dpdx(r0.z); + r0.w = dot(r2, cb6_6.tint_symbol_5[12u]); + r1.x = dot(r2, cb6_6.tint_symbol_5[13u]); + r1.y = ((-(r0.wwww)).y + r1.z); + r0.w = bitcast(select(0u, 4294967295u, !((r0.w == 0.0f)))); + r4.z = dpdx(r1.y); + let v_26 = dpdx(r0.yy); + r2 = vec4(v_26.xy, r2.zw); + r5.y = fma(cb6_6.tint_symbol_5[14u].w, 0.25f, r0.y); + r3.w = dpdy(r1.y); + let v_27 = dpdy(r0.yzy); + r3 = vec4(v_27.xyz, r3.w); + r5.x = (r0.z + cb6_6.tint_symbol_5[14u].z); + let v_28 = (r2.xy * r3.yw); + let v_29 = r0; + r0 = vec4(v_29.x, v_28.xy, v_29.w); + r1.w = (r3.y * r4.z); + let v_30 = -(r0.yzyy); + let v_31 = fma(r4.xz, r3.xz, v_30.xy); + r2 = vec4(v_31.xy, r2.zw); + let v_32 = -(r1.wwww); + r2.z = fma(r4.x, r3.w, v_32.z); + r0.y = (1.0f / r2.x); + let v_33 = (r0.yy * r2.yz); + let v_34 = r0; + r0 = vec4(v_34.x, v_33.xy, v_34.w); + let v_35 = max(r0.yz, vec2()); + let v_36 = r0; + r0 = vec4(v_36.x, v_35.xy, v_36.w); + let v_37 = min(r0.yz, vec2(0.5f)); + let v_38 = r0; + r0 = vec4(v_38.x, v_37.xy, v_38.w); + r0.y = fma((-(r1.xxxx)).y, r0.y, r1.y); + r0.y = fma((-(r1.xxxx)).y, r0.z, r0.y); + let v_39 = bitcast(r0.w); + let v_40 = r0.y; + r0.y = select(r1.z, v_40, (v_39 != 0u)); + let v_41 = r5.xyxx; + r0.y = textureSampleCompareLevel(t15, s15, v_41.xy, r0.y); + let v_42 = ((-(v2.xyz.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r1 = vec4(v_42.xyz, r1.w); + r0.z = dot(r1.xyz, cb1_1.tint_symbol[14u].xyz); + r0.z = clamp(fma(r0.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f); + r0.z = ((-(r0.zzzz)).z + 1.0f); + r0.x = fma(r0.z, r0.x, r0.y); + r0.x = (r0.x * r0.x); + r0.x = min(r0.x, 1.0f); + r0.y = clamp(fma(v2.xyz.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).y, 0.0f, 1.0f); + r0.y = sqrt(r0.y); + r0.y = (r0.y * cb6_6.tint_symbol_5[3u].z); + let v_43 = -(r0.xxxx); + r0.x = fma(r0.y, v_43.x, r0.x); + r0.y = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).y, 0.0f, 1.0f); + r0.y = (r0.y * cb2_2.tint_symbol_1[15u].y); + r0.y = (r0.y * r0.y); + r0.z = ((-(cb2_2.tint_symbol_1[16u].zzzz)).z + 1.0f); + r0.w = dot(v1.xyz, v1.xyz); + r0.w = inverseSqrt(r0.w); + r1.x = fma(v1.z, r0.w, cb3_3.tint_symbol_2[43u].w); + let v_44 = (r0.www * v1.xyz); + r1 = vec4(r1.x, v_44.xyz); + r0.w = (r1.x * cb3_3.tint_symbol_2[44u].w); + r0.w = max(r0.w, 0.0f); + let v_45 = fma(cb3_3.tint_symbol_2[45u].xyz, r0.www, cb3_3.tint_symbol_2[46u].xyz); + r2 = vec4(v_45.xyz, r2.w); + let v_46 = (r2.xyz * cb2_2.tint_symbol_1[16u].zzz); + r2 = vec4(v_46.xyz, r2.w); + let v_47 = fma(cb3_3.tint_symbol_2[47u].xyz, r0.www, cb3_3.tint_symbol_2[48u].xyz); + r3 = vec4(v_47.xyz, r3.w); + let v_48 = fma(cb3_3.tint_symbol_2[43u].xyz, r0.www, cb3_3.tint_symbol_2[44u].xyz); + r4 = vec4(v_48.xyz, r4.w); + let v_49 = fma(r3.xyz, r0.zzz, r2.xyz); + r2 = vec4(v_49.xyz, r2.w); + let v_50 = (r0.yyy * r2.xyz); + r0 = vec4(r0.x, v_50.xyz); + r2.x = cb3_3.tint_symbol_2[46u].w; + r2.y = cb3_3.tint_symbol_2[47u].w; + r2.z = cb3_3.tint_symbol_2[48u].w; + let v_51 = dot(r2.xyz, r1.yzw); + r1.x = clamp(vec4(v_51, v_51, v_51, v_51).x, 0.0f, 1.0f); + let v_52 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_53 = dot(r1.yzw, v_52.xyz); + r1.y = clamp(vec4(v_53, v_53, v_53, v_53).y, 0.0f, 1.0f); + let v_54 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r4.xyz); + r1 = vec4(v_54.x, r1.y, v_54.yz); + r2.x = (cb2_2.tint_symbol_1[15u].z * cb2_2.tint_symbol_1[15u].z); + let v_55 = fma(r1.xzw, r2.xxx, r0.yzw); + r0 = vec4(r0.x, v_55.xyz); + r1.x = (cb5_5.tint_symbol_3[3u].z * cb11_11.tint_symbol_4[8u].z); + let v_56 = ((-(cb11_11.tint_symbol_4[8u].zzzz)).zw + vec2(1.0f, 2.0f)); + r1 = vec4(r1.xy, v_56.xy); + let v_57 = (r1.ww * v0.zw); + r2 = vec4(v_57.xy, r2.zw); + r2 = textureSample(t3, s3, r2.xyxx.xy); + r1.w = ((-(r2.xxxx)).w + r2.z); + r1.x = fma(r1.x, r1.w, r2.x); + r1.w = fma(v3.z, r1.z, -1.0f); + r1.w = fma(r1.z, r1.w, 1.0f); + r1.z = (r1.z * v3.z); + let v_58 = (r1.xz * cb11_11.tint_symbol_4[8u].xx); + let v_59 = r1; + r1 = vec4(v_58.x, v_59.y, v_58.y, v_59.w); + r1.x = (r1.w * r1.x); + r1.w = fma((-(cb2_2.tint_symbol_1[16u].yyyy)).w, 100.0f, 1.0f); + r1.x = clamp(((r1.wwww * r1.xxxx)).x, 0.0f, 1.0f); + r1.w = clamp(((v3.wwww + vec4(-2.0f))).w, 0.0f, 1.0f); + r1.w = fma((-(r1.wwww)).w, 0.75f, 1.0f); + r1.x = (r1.w * r1.x); + r3 = textureSample(t0, s0, v0.xyxx.xy); + let v_60 = (r3.xyz * cb11_11.tint_symbol_4[0u].xyz); + r2 = vec4(v_60.xy, r2.z, v_60.z); + r1.w = (r3.w * v3.w); + o0.w = (r1.w * cb2_2.tint_symbol_1[15u].x); + let v_61 = (r2.xyw * r2.xyw); + r2 = vec4(v_61.xy, r2.z, v_61.z); + let v_62 = -(r2.xywx); + let v_63 = fma(cb11_11.tint_symbol_4[9u].xyz, cb11_11.tint_symbol_4[8u].yyy, v_62.xyz); + r3 = vec4(v_63.xyz, r3.w); + let v_64 = fma(r1.xxx, r3.xyz, r2.xyw); + r2 = vec4(v_64.xy, r2.z, v_64.z); + let v_65 = ((-(r2.xywx)).xyz + r2.zzz); + r3 = vec4(v_65.xyz, r3.w); + let v_66 = fma(r1.zzz, r3.xyz, r2.xyw); + r1 = vec4(v_66.x, r1.y, v_66.yz); + let v_67 = (r0.yzw * r1.xzw); + r0 = vec4(r0.x, v_67.xyz); + let v_68 = (r1.yyy * r1.xzw); + r2 = vec4(v_68.xyz, r2.w); + let v_69 = (r2.xyz * cb3_3.tint_symbol_2[1u].xyz); + r2 = vec4(v_69.xyz, r2.w); + let v_70 = fma(r2.xyz, r0.xxx, r0.yzw); + r0 = vec4(v_70.xyz, r0.w); + r0.w = (v3.x * cb11_11.tint_symbol_4[2u].x); + r0.w = (r0.w * cb3_3.tint_symbol_2[59u].w); + let v_71 = fma(r1.xzw, r0.www, r0.xyz); + o0 = vec4(v_71.xyz, o0.w); +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v3); + return o0; +} diff --git a/b/8b0b5899ed/shaders/019249fa1f33ce96.consts.json b/b/8b0b5899ed/shaders/019249fa1f33ce96.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..9c27df027d15db715744502f6c2271644a23c98e --- /dev/null +++ b/b/8b0b5899ed/shaders/019249fa1f33ce96.consts.json @@ -0,0 +1 @@ +[2, 3, 1] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/019249fa1f33ce96.wgsl b/b/8b0b5899ed/shaders/019249fa1f33ce96.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..dddfea419803af60f74aab781b055b4c9fdbe493 --- /dev/null +++ b/b/8b0b5899ed/shaders/019249fa1f33ce96.wgsl @@ -0,0 +1,547 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb15_struct { + tint_symbol_4 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v5 : vec4; + +var v6 : array; + +var o0 : vec4; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_6 { + tint_symbol_5 : array, 3u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_6; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v4 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v5 = v_2; + x1[0u].x = v6[0u]; + x1[0u].y = v6[1u]; + x1[0u].z = v6[2u]; + x1[0u].w = v6[3u]; + r0 = textureSample(t0, s0, v1.xy.xyxx.xy); + r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x); + r1.x = bitcast(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x))); + v_3((bitcast(r1.x) != 0u)); + r1.x = dot(v2.xyz, v2.xyz); + r1.x = inverseSqrt(r1.x); + let v_4 = (r1.xxx * v2.xyz); + r1 = vec4(r1.x, v_4.xyz); + r0.w = (r0.w * v0.w); + let v_5 = (v0.xy * cb2_2.tint_symbol_1[15u].zy); + r2 = vec4(v_5.xy, r2.zw); + let v_6 = (r0.xyz * r0.xyz); + r0 = vec4(v_6.xyz, r0.w); + let v_7 = ((-(v4.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz); + r3 = vec4(v_7.xyz, r3.w); + r2.z = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz); + let v_8 = (v4.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r3 = vec4(v_8.xyz, r3.w); + let v_9 = (r3.yyy * cb6_6.tint_symbol_4[1u].xyz); + r4 = vec4(v_9.xyz, r4.w); + let v_10 = fma(r3.xxx, cb6_6.tint_symbol_4[0u].xyz, r4.xyz); + r4 = vec4(v_10.xyz, r4.w); + let v_11 = fma(r3.zzz, cb6_6.tint_symbol_4[2u].xyz, r4.xyz); + r4 = vec4(v_11.xyz, r4.w); + let v_12 = fma(r4.xyz, cb6_6.tint_symbol_4[4u].xyz, cb6_6.tint_symbol_4[8u].xyz); + r5 = vec4(v_12.xyz, r5.w); + let v_13 = &(x0[0u]); + let v_14 = r5; + *(v_13) = vec4(v_14.xyz, (*(v_13)).w); + let v_15 = fma(r4.xyz, cb6_6.tint_symbol_4[5u].xyz, cb6_6.tint_symbol_4[9u].xyz); + r6 = vec4(v_15.xyz, r6.w); + let v_16 = &(x0[1u]); + let v_17 = r6; + *(v_16) = vec4(v_17.xyz, (*(v_16)).w); + let v_18 = fma(r4.xyz, cb6_6.tint_symbol_4[6u].xyz, cb6_6.tint_symbol_4[10u].xyz); + r7 = vec4(v_18.xyz, r7.w); + let v_19 = &(x0[2u]); + let v_20 = r7; + *(v_19) = vec4(v_20.xyz, (*(v_19)).w); + let v_21 = fma(r4.xyz, cb6_6.tint_symbol_4[7u].xyz, cb6_6.tint_symbol_4[11u].xyz); + r4 = vec4(v_21.xyz, r4.w); + let v_22 = &(x0[3u]); + let v_23 = r4; + *(v_22) = vec4(v_23.xyz, (*(v_22)).w); + let v_24 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_25 = r8; + r8 = vec4(v_25.x, v_24.x, v_25.z, v_24.y); + r2.w = fma((-(cb6_6.tint_symbol_4[14u].zzzz)).w, 1.5f, 1.0f); + r2.w = (r2.w * 0.5f); + let v_26 = abs(r7.yyyy); + r3.w = max(v_26.w, abs(r7.xxxx).w); + r3.w = bitcast(select(0u, 4294967295u, (r3.w < r2.w))); + let v_27 = (bitcast(r3.w) != 0u); + let v_28 = bitcast(v.tint_symbol_5[0i].x); + r3.w = select(bitcast(v.tint_symbol_5[1i].x), v_28, v_27); + let v_29 = abs(r6.yyyy); + r4.z = max(v_29.z, abs(r6.xxxx).z); + r4.z = bitcast(select(0u, 4294967295u, (r4.z < r2.w))); + let v_30 = bitcast(r4.z); + r3.w = select(r3.w, bitcast(v.tint_symbol_5[2i].x), (v_30 != 0u)); + let v_31 = abs(r5.yyyy); + r4.z = max(v_31.z, abs(r5.xxxx).z); + r2.w = bitcast(select(0u, 4294967295u, (r4.z < r2.w))); + let v_32 = bitcast(r2.w); + r2.w = select(r3.w, 0.0f, (v_32 != 0u)); + let v_33 = x0[bitcast(r2.w)]; + r5 = vec4(v_33.xyz, r5.w); + r2.w = f32(bitcast(r2.w)); + r3.w = (r2.w + 0.5f); + r3.w = (r3.w * 0.25f); + r6 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r2.wwww))); + r6 = bitcast>((bitcast>(r6) & vec4(1065353216u))); + r2.w = dot(r6, cb6_6.tint_symbol_4[12u]); + r4.z = dot(r6, cb6_6.tint_symbol_4[13u]); + r6.x = (r5.x + 0.5f); + r6.y = fma(r5.y, 0.25f, r3.w); + r3.w = bitcast(select(0u, 4294967295u, !((r2.w == 0.0f)))); + r2.w = ((-(r2.wwww)).w + r5.z); + let v_34 = dpdx(r6.xyy); + r7 = vec4(v_34.xy, r7.z, v_34.z); + r7.z = dpdx(r2.w); + let v_35 = dpdy(r6.yxy); + r9 = vec4(v_35.xyz, r9.w); + r9.w = dpdy(r2.w); + let v_36 = (r7.yw * r9.yw); + r5 = vec4(v_36.xy, r5.zw); + let v_37 = -(r5.xyxx); + let v_38 = fma(r7.xz, r9.xz, v_37.xy); + r10 = vec4(v_38.xy, r10.zw); + r4.w = (1.0f / r10.x); + r5.x = (r7.z * r9.y); + let v_39 = -(r5.xxxx); + r10.z = fma(r7.x, r9.w, v_39.z); + let v_40 = (r4.ww * r10.yz); + r5 = vec4(v_40.xy, r5.zw); + let v_41 = max(r5.xy, vec2()); + r5 = vec4(v_41.xy, r5.zw); + let v_42 = min(r5.xy, vec2(0.5f)); + r5 = vec4(v_42.xy, r5.zw); + r2.w = fma((-(r4.zzzz)).w, r5.x, r2.w); + r2.w = fma((-(r4.zzzz)).w, r5.y, r2.w); + let v_43 = bitcast(r3.w); + let v_44 = r2.w; + r8.z = select(r5.z, v_44, (v_43 != 0u)); + r6.z = 0.0f; + let v_45 = (r6.xyz + r8.ywz); + r5 = vec4(v_45.xyz, r5.w); + let v_46 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r8 = vec4(v_46.xy, r8.zw); + let v_47 = (r6.xyz + r8.xyz); + r7 = vec4(v_47.xyz, r7.w); + let v_48 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r8 = vec4(v_48.xy, r8.zw); + let v_49 = (r6.xyz + r8.xyz); + r9 = vec4(v_49.xyz, r9.w); + let v_50 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r8 = vec4(v_50.xy, r8.zw); + let v_51 = (r6.xyz + r8.xyz); + r10 = vec4(v_51.xyz, r10.w); + let v_52 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r8 = vec4(v_52.xy, r8.zw); + let v_53 = (r6.xyz + r8.xyz); + r11 = vec4(v_53.xyz, r11.w); + let v_54 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r8 = vec4(v_54.xy, r8.zw); + let v_55 = (r6.xyz + r8.xyz); + r12 = vec4(v_55.xyz, r12.w); + let v_56 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r8 = vec4(v_56.xy, r8.zw); + let v_57 = (r6.xyz + r8.xyz); + r13 = vec4(v_57.xyz, r13.w); + let v_58 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r8 = vec4(v_58.xy, r8.zw); + let v_59 = (r6.xyz + r8.xyz); + r14 = vec4(v_59.xyz, r14.w); + let v_60 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r8 = vec4(v_60.xy, r8.zw); + let v_61 = (r6.xyz + r8.xyz); + r15 = vec4(v_61.xyz, r15.w); + let v_62 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r8 = vec4(v_62.xy, r8.zw); + let v_63 = (r6.xyz + r8.xyz); + r16 = vec4(v_63.xyz, r16.w); + let v_64 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r8 = vec4(v_64.xy, r8.zw); + let v_65 = (r6.xyz + r8.xyz); + r17 = vec4(v_65.xyz, r17.w); + let v_66 = (cb6_6.tint_symbol_4[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r8 = vec4(v_66.xy, r8.zw); + let v_67 = (r6.xyz + r8.xyz); + r18 = vec4(v_67.xyz, r18.w); + let v_68 = (cb6_6.tint_symbol_4[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r8 = vec4(v_68.xy, r8.zw); + let v_69 = (r6.xyz + r8.xyz); + r19 = vec4(v_69.xyz, r19.w); + let v_70 = (cb6_6.tint_symbol_4[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r8 = vec4(v_70.xy, r8.zw); + let v_71 = (r6.xyz + r8.xyz); + r20 = vec4(v_71.xyz, r20.w); + let v_72 = (cb6_6.tint_symbol_4[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r8 = vec4(v_72.xy, r8.zw); + let v_73 = (r6.xyz + r8.xyz); + r21 = vec4(v_73.xyz, r21.w); + let v_74 = (cb6_6.tint_symbol_4[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r8 = vec4(v_74.xy, r8.zw); + let v_75 = (r6.xyz + r8.xyz); + r6 = vec4(v_75.xyz, r6.w); + let v_76 = r5.xyxx; + r5.x = textureSampleCompareLevel(t15, s15, v_76.xy, r5.z); + let v_77 = r7.xyxx; + r5.y = textureSampleCompareLevel(t15, s15, v_77.xy, r7.z); + let v_78 = r9.xyxx; + r5.z = textureSampleCompareLevel(t15, s15, v_78.xy, r9.z); + let v_79 = r10.xyxx; + r5.w = textureSampleCompareLevel(t15, s15, v_79.xy, r10.z); + let v_80 = r11.xyxx; + r7.x = textureSampleCompareLevel(t15, s15, v_80.xy, r11.z); + let v_81 = r12.xyxx; + r7.y = textureSampleCompareLevel(t15, s15, v_81.xy, r12.z); + let v_82 = r13.xyxx; + r7.z = textureSampleCompareLevel(t15, s15, v_82.xy, r13.z); + let v_83 = r14.xyxx; + r7.w = textureSampleCompareLevel(t15, s15, v_83.xy, r14.z); + let v_84 = r15.xyxx; + r8.x = textureSampleCompareLevel(t15, s15, v_84.xy, r15.z); + let v_85 = r16.xyxx; + r8.y = textureSampleCompareLevel(t15, s15, v_85.xy, r16.z); + let v_86 = r17.xyxx; + r8.z = textureSampleCompareLevel(t15, s15, v_86.xy, r17.z); + let v_87 = r18.xyxx; + r8.w = textureSampleCompareLevel(t15, s15, v_87.xy, r18.z); + let v_88 = r19.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_88.xy, r19.z); + let v_89 = r20.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_89.xy, r20.z); + let v_90 = r21.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_90.xy, r21.z); + let v_91 = r6.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_91.xy, r6.z); + r5 = (r5 + r7); + r5 = (r8 + r5); + r5 = (r9 + r5); + r2.w = dot(r5, vec4(1.0f)); + r2.z = clamp(fma(r2.zzzz, cb6_6.tint_symbol_4[0u].wwww, cb6_6.tint_symbol_4[1u].wwww).z, 0.0f, 1.0f); + let v_92 = abs(r4.yyyy); + r3.w = max(v_92.w, abs(r4.xxxx).w); + r3.w = clamp(fma(r3.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.z = (r3.w * r2.z); + r2.z = fma(r2.w, 0.0625f, r2.z); + let v_93 = (r2.xyz * r2.xyz); + r2 = vec4(v_93.xyz, r2.w); + r2.z = min(r2.z, 1.0f); + r2.w = clamp(fma(v4.zzzz, cb6_6.tint_symbol_4[3u].xxxx, cb6_6.tint_symbol_4[3u].yyyy).w, 0.0f, 1.0f); + r2.w = sqrt(r2.w); + r2.w = (r2.w * cb6_6.tint_symbol_4[3u].z); + let v_94 = -(r2.zzzz); + r2.z = fma(r2.w, v_94.z, r2.z); + let v_95 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_96 = dot(r1.yzw, v_95.xyz); + r2.w = clamp(vec4(v_96, v_96, v_96, v_96).w, 0.0f, 1.0f); + let v_97 = (r0.xyz * r2.www); + r4 = vec4(v_97.xyz, r4.w); + let v_98 = (r4.xyz * cb3_3.tint_symbol_2[1u].xyz); + r4 = vec4(v_98.xyz, r4.w); + r1.x = fma(v2.z, r1.x, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_99 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r5 = vec4(v_99.xyz, r5.w); + r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_100 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r6 = vec4(v_100.xyz, r6.w); + let v_101 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz); + r6 = vec4(v_101.xyz, r6.w); + let v_102 = fma(r5.xyz, r2.www, r6.xyz); + r5 = vec4(v_102.xyz, r5.w); + let v_103 = (r2.yyy * r5.xyz); + r5 = vec4(v_103.xyz, r5.w); + let v_104 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r6 = vec4(v_104.xyz, r6.w); + r7.x = cb3_3.tint_symbol_2[46u].w; + r7.y = cb3_3.tint_symbol_2[47u].w; + r7.z = cb3_3.tint_symbol_2[48u].w; + let v_105 = dot(r7.xyz, r1.yzw); + r1.x = clamp(vec4(v_105, v_105, v_105, v_105).x, 0.0f, 1.0f); + let v_106 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r6.xyz); + r1 = vec4(v_106.xyz, r1.w); + let v_107 = fma(r1.xyz, r2.xxx, r5.xyz); + r1 = vec4(v_107.xyz, r1.w); + let v_108 = (r0.xyz * r1.xyz); + r0 = vec4(v_108.xyz, r0.w); + let v_109 = fma(r4.xyz, r2.zzz, r0.xyz); + r0 = vec4(v_109.xyz, r0.w); + o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r0.w = dot(r3.xyz, r3.xyz); + r1.x = sqrt(r0.w); + let v_110 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.y = (r1.x + v_110.y); + r1.y = max(r1.y, 0.0f); + r1.x = (r1.y / r1.x); + r1.x = (r1.x * r3.z); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z); + r1.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x))); + r1.w = (r1.z * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.z = (r1.w / r1.z); + let v_111 = bitcast(r1.x); + r1.x = select(1.0f, r1.z, (v_111 != 0u)); + r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w); + r1.x = (r1.x * r1.z); + r1.x = min(r1.x, 1.0f); + r1.x = (r1.x * 1.44269502162933349609f); + r1.x = exp2(r1.x); + r1.x = min(r1.x, 1.0f); + r1.x = ((-(r1.xxxx)).x + 1.0f); + r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_112 = (r0.www * r3.xyz); + r2 = vec4(v_112.xyz, r2.w); + let v_113 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_113, v_113, v_113, v_113).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_114 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r1.w = clamp(vec4(v_114, v_114, v_114, v_114).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w); + r1.w = exp2(r1.w); + r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y); + let v_115 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.x = (r1.y + v_115.x); + r2.x = max(r2.x, 0.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f); + let v_116 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.y = (r1.y * v_116.y); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = ((-(r1.yyyy)).y + 1.0f); + let v_117 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(v_117.xyz, r2.w); + let v_118 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(v_118.xyz, r2.w); + let v_119 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_119.xyz, r4.w); + let v_120 = fma(r1.www, r4.xyz, r2.xyz); + r2 = vec4(v_120.xyz, r2.w); + let v_121 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_122 = (r2.xyz + v_121.xyz); + r2 = vec4(v_122.xyz, r2.w); + let v_123 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_123.xyz, r2.w); + r4.x = cb3_3.tint_symbol_2[55u].w; + r4.y = cb3_3.tint_symbol_2[56u].w; + r4.z = cb3_3.tint_symbol_2[57u].w; + let v_124 = ((-(r2.xyzx)).xyz + r4.xyz); + r4 = vec4(v_124.xyz, r4.w); + let v_125 = fma(r1.xxx, r4.xyz, r2.xyz); + r1 = vec4(v_125.xy, r1.z, v_125.z); + r0.w = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r0.w) != 0u)) { + let v_126 = (v5.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_126.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r0.w = (r2.x + -1.0f); + r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4(1.0f)).w, 0.0f, 1.0f); + } else { + r0.w = 1.0f; + } + let v_127 = -(r0.xyxz); + let v_128 = fma(r1.xyw, r0.www, v_127.xyw); + r1 = vec4(v_128.xy, r1.z, v_128.z); + let v_129 = fma(r1.zzz, r1.xyw, r0.xyz); + r1 = vec4(v_129.xyz, r1.w); + } else { + r0.w = dot(r3.xyz, r3.xyz); + r1.w = sqrt(r0.w); + let v_130 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.x = (r1.w + v_130.x); + r2.x = max(r2.x, 0.0f); + r1.w = (r2.x / r1.w); + r1.w = (r1.w * r3.z); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z); + r1.w = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w))); + r2.z = (r2.y * -1.44269502162933349609f); + r2.z = exp2(r2.z); + r2.z = ((-(r2.zzzz)).z + 1.0f); + r2.y = (r2.z / r2.y); + let v_131 = bitcast(r1.w); + r1.w = select(1.0f, r2.y, (v_131 != 0u)); + r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w); + r1.w = (r1.w * r2.y); + r1.w = min(r1.w, 1.0f); + r1.w = (r1.w * 1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = min(r1.w, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y); + r0.w = inverseSqrt(r0.w); + let v_132 = (r0.www * r3.xyz); + r3 = vec4(v_132.xyz, r3.w); + let v_133 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r0.w = clamp(vec4(v_133, v_133, v_133, v_133).w, 0.0f, 1.0f); + r0.w = log2(r0.w); + r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w); + r0.w = exp2(r0.w); + let v_134 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.z = clamp(vec4(v_134, v_134, v_134, v_134).z, 0.0f, 1.0f); + r2.z = log2(r2.z); + r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w); + r2.z = exp2(r2.z); + r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y); + let v_135 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.w = (r2.x + v_135.w); + r2.w = max(r2.w, 0.0f); + r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x); + r2.w = (r2.w * 1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f); + let v_136 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.x = (r2.x * v_136.x); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + let v_137 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_137.xyz, r3.w); + let v_138 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_138.xyz, r3.w); + let v_139 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_139.xyz, r4.w); + let v_140 = fma(r2.zzz, r4.xyz, r3.xyz); + r3 = vec4(v_140.xyz, r3.w); + let v_141 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_142 = (r3.xyz + v_141.xyz); + r3 = vec4(v_142.xyz, r3.w); + let v_143 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_143.x, r2.y, v_143.yz); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_144 = ((-(r2.xzwx)).xyz + r3.xyz); + r3 = vec4(v_144.xyz, r3.w); + let v_145 = fma(r1.www, r3.xyz, r2.xzw); + r2 = vec4(v_145.x, r2.y, v_145.yz); + let v_146 = ((-(r0.xxyz)).xzw + r2.xzw); + r2 = vec4(v_146.x, r2.y, v_146.yz); + let v_147 = fma(r2.yyy, r2.xzw, r0.xyz); + r1 = vec4(v_147.xyz, r1.w); + } + let v_148 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_148.xyz, o0.w); +} + +fn v_3(v_149 : bool) { + if (v_149) { + discard; + return; + } +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(4u) v4 : vec4, @builtin(position) v_150 : vec4) -> @location(0u) vec4 { + main_inner(v0, v1, v2, v4, v_150); + return o0; +} diff --git a/b/8b0b5899ed/shaders/01a05b914ee571f0.wgsl b/b/8b0b5899ed/shaders/01a05b914ee571f0.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..e413546a05723f8c7ae960ff17f825d194e2baac --- /dev/null +++ b/b/8b0b5899ed/shaders/01a05b914ee571f0.wgsl @@ -0,0 +1,27 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +struct cb4_struct { + tint_symbol : array, 4u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb4_struct; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(34u) var t2 : texture_2d; + +var o0 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4) { + r0 = textureSampleLevel(t2, s2, v2.xy.xyxx.xy, cb5_5.tint_symbol[3u].x); + r0 = (r0 * v1); + o0 = (r0 * cb5_5.tint_symbol[2u]); +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4) -> @location(0u) vec4 { + main_inner(v1, v2); + return o0; +} diff --git a/b/8b0b5899ed/shaders/01a1684bb49b936f.wgsl b/b/8b0b5899ed/shaders/01a1684bb49b936f.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..0d8c5152c229eaf4eb3a968ca1cd67f758fbfd2e --- /dev/null +++ b/b/8b0b5899ed/shaders/01a1684bb49b936f.wgsl @@ -0,0 +1,64 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +struct cb3_struct { + tint_symbol : array, 3u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb3_struct; + +@group(1u) @binding(18u) var s2 : sampler; + +@group(1u) @binding(34u) var t2 : texture_2d; + +var o0 : vec4; + +fn main_inner(v1 : vec4, v2 : vec4, v3 : vec4) { + r0 = textureSample(t2, s2, v2.xyxx.xy); + r0.x = dot(r0.yw, vec2(0.75f, 0.25f)); + r1 = textureSample(t2, s2, v3.xyxx.xy); + r0.y = dot(r1.yw, vec2(0.75f, 0.25f)); + r0.x = ((-(r0.yyyy)).x + r0.x); + r1 = textureSample(t2, s2, v2.zwzz.xy); + r0.y = dot(r1.yw, vec2(0.75f, 0.25f)); + r1 = textureSample(t2, s2, v3.zwzz.xy); + r0.z = dot(r1.yw, vec2(0.75f, 0.25f)); + r0.y = ((-(r0.zzzz)).y + r0.y); + let v = -(r0.yyyy); + let v_1 = fma(r0.xx, vec2(-1.0f, 1.0f), v.xy); + r0 = vec4(v_1.xy, r0.zw); + r0.z = dot(r0.xy, r0.xy); + r0.w = inverseSqrt(r0.z); + r0.z = sqrt(r0.z); + r0.z = (r0.z * 3.0f); + r0.z = min(r0.z, 1.0f); + r0.z = (r0.z * r0.z); + let v_2 = (r0.wwz * r0.xyz); + r0 = vec4(v_2.xyz, r0.w); + let v_3 = (r0.zz * r0.xy); + r0 = vec4(v_3.xy, r0.zw); + let v_4 = (r0.xy * cb5_5.tint_symbol[0u].xy); + r0 = vec4(v_4.xy, r0.zw); + let v_5 = fma((-(r0.xxxy)).zw, vec2(1.5f), v1.xy); + r0 = vec4(r0.xy, v_5.xy); + let v_6 = fma(r0.xy, vec2(1.5f), v1.xy); + r0 = vec4(v_6.xy, r0.zw); + r1 = textureSample(t2, s2, r0.xyxx.xy); + r0 = textureSample(t2, s2, r0.zwzz.xy); + r2 = textureSample(t2, s2, v1.xy.xyxx.xy); + r0 = fma(r2, vec4(0.5f), r0); + r0 = (r1 + r0); + r0 = (r0 * cb5_5.tint_symbol[2u]); + o0 = (r0 * vec4(0.40000000596046447754f)); +} + +@fragment +fn main(@location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4) -> @location(0u) vec4 { + main_inner(v1, v2, v3); + return o0; +} diff --git a/b/8b0b5899ed/shaders/01a9018c2e91f9fd.consts.json b/b/8b0b5899ed/shaders/01a9018c2e91f9fd.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/01a9018c2e91f9fd.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/01a9018c2e91f9fd.wgsl b/b/8b0b5899ed/shaders/01a9018c2e91f9fd.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..310ef71258e23fe1286ef0fa718bb2a98017062c --- /dev/null +++ b/b/8b0b5899ed/shaders/01a9018c2e91f9fd.wgsl @@ -0,0 +1,967 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +var r11 : vec4; + +var r12 : vec4; + +var r13 : vec4; + +var r14 : vec4; + +var r15 : vec4; + +var r16 : vec4; + +var r17 : vec4; + +var r18 : vec4; + +var r19 : vec4; + +var r20 : vec4; + +var r21 : vec4; + +var r22 : vec4; + +var r23 : vec4; + +var r24 : vec4; + +var r25 : vec4; + +struct cb16_struct { + tint_symbol : array, 16u>, +} + +@group(1u) @binding(1u) var cb1_1 : cb16_struct; + +struct cb23_struct { + tint_symbol_1 : array, 23u>, +} + +@group(1u) @binding(2u) var cb2_2 : cb23_struct; + +struct cb59_struct { + tint_symbol_2 : array, 59u>, +} + +@group(1u) @binding(3u) var cb3_3 : cb59_struct; + +struct cb8_struct { + tint_symbol_3 : array, 8u>, +} + +@group(1u) @binding(5u) var cb5_5 : cb8_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(1u) @binding(12u) var cb12_12 : cb2_struct; + +struct cb15_struct { + tint_symbol_5 : array, 15u>, +} + +@group(1u) @binding(6u) var cb6_6 : cb15_struct; + +@group(1u) @binding(16u) var s0 : sampler; + +@group(1u) @binding(19u) var s3 : sampler; + +@group(1u) @binding(27u) var s11 : sampler; + +@group(1u) @binding(31u) var s15 : sampler_comparison; + +@group(1u) @binding(32u) var t0 : texture_2d; + +@group(1u) @binding(35u) var t3 : texture_2d; + +@group(1u) @binding(43u) var t11 : texture_2d; + +@group(1u) @binding(47u) var t15 : texture_depth_2d; + +var v7 : vec4; + +var v8 : array; + +var o0 : vec4; + +var o1 : f32; + +var o2 : f32; + +var x0 : array, 4u>; + +var x1 : array, 1u>; + +struct tint_symbol_7 { + tint_symbol_6 : array, 4u>, +} + +@group(1u) @binding(15u) var v : tint_symbol_7; + +fn main_inner(v0 : vec4, v1 : vec4, v2 : vec4, v3 : vec4, v4 : vec4, v5 : vec4, v6 : vec4, v_1 : vec4) { + var v_2 : vec4 = v_1; + v_2.w = (1.0f / v_1.w); + v7 = v_2; + x1[0u].x = v8[0u]; + x1[0u].y = v8[1u]; + x1[0u].z = v8[2u]; + x1[0u].w = v8[3u]; + r0 = textureSample(t3, s3, v1.xyz.xyxx.xy); + r0.z = dot(v6.xyz, v6.xyz); + r0.z = inverseSqrt(r0.z); + let v_3 = (r0.zz * v6.xy); + r1 = vec4(v_3.xy, r1.zw); + let v_4 = ((-(r1.xyxx)).xy * cb12_12.tint_symbol_4[0u].yy); + r1 = vec4(v_4.xy, r1.zw); + r1 = vec4(r1.xy, v1.xyz.xy.xy); + let v_5 = r0; + let v_6 = r2; + r2 = vec4(v_6.x, v_5.xy, v_6.w); + r2.x = -1.0f; + r2.w = (-(r0.wwww)).w; + r0.z = 0.0f; + loop { + r3.x = bitcast(select(0u, 4294967295u, (bitcast(r0.z) >= 8i))); + if ((bitcast(r3.x) != 0u)) { + break; + } + let v_7 = fma(r1.xy, vec2(0.125f), r1.zw); + r3 = vec4(v_7.xy, r3.zw); + r4 = textureSample(t3, s3, r3.xyxx.xy); + r3.z = bitcast(select(0u, 4294967295u, (r2.x < r2.w))); + r5.x = (r2.x + 0.125f); + let v_8 = bitcast>(r3.zz); + let v_9 = r3.xy; + let v_10 = select(r1.zw, v_9, (v_8 != vec2())); + r1 = vec4(r1.xy, v_10.xy); + let v_11 = (r4.xyw * vec3(1.0f, 1.0f, -1.0f)); + r5 = vec4(r5.x, v_11.xyz); + let v_12 = bitcast>(r3.zzzz); + let v_13 = r5; + r2 = select(r2, v_13, (v_12 != vec4())); + r0.z = bitcast((bitcast(r0.z) + 1i)); + } + r0 = textureSample(t0, s0, r1.zwzz.xy); + let v_14 = fma(r2.yz, vec2(2.0f), vec2(-1.0f)); + r1 = vec4(v_14.xy, r1.zw); + r1.z = dot(r1.xy, r1.xy); + r1.z = ((-(r1.zzzz)).z + 1.0f); + r1.z = sqrt(abs(r1.zzzz).z); + r1.w = max(cb12_12.tint_symbol_4[1u].y, 0.00100000004749745131f); + let v_15 = (r1.ww * r1.xy); + r1 = vec4(v_15.xy, r1.zw); + let v_16 = (r1.yyy * v4.xyz); + r3 = vec4(v_16.xyz, r3.w); + let v_17 = fma(r1.xxx, v3.xyz, r3.xyz); + r1 = vec4(v_17.xy, r1.z, v_17.z); + let v_18 = fma(r1.zzz, v2.xyz, r1.xyw); + r1 = vec4(v_18.xyz, r1.w); + r1.w = dot(r1.xyz, r1.xyz); + r1.w = inverseSqrt(r1.w); + let v_19 = (r1.www * r1.xyz); + r3 = vec4(v_19.xyz, r3.w); + r1.x = dot(r2.yz, r2.yz); + r1.x = bitcast(select(0u, 4294967295u, (r1.x >= 0.00200000009499490261f))); + r1.x = bitcast((bitcast(r1.x) & 1065353216u)); + let v_20 = (r0.xyz * r1.xxx); + r0 = vec4(v_20.xyz, r0.w); + let v_21 = (r1.xxx * v0.xyz); + r2 = vec4(v_21.xyz, r2.w); + r1.x = clamp(((r1.xxxx * cb12_12.tint_symbol_4[1u].xxxx)).x, 0.0f, 1.0f); + r2.w = v0.w; + r0 = (r0 * r2); + let v_22 = (r0.xyz * r0.xyz); + r0 = vec4(v_22.xyz, r0.w); + let v_23 = -(v5.xyzx); + let v_24 = (v_23.xyz + cb1_1.tint_symbol[15u].xyz); + r2 = vec4(v_24.xyz, r2.w); + r1.y = dot(r2.xyz, r2.xyz); + r1.y = inverseSqrt(r1.y); + let v_25 = (r1.yyy * r2.xyz); + r4 = vec4(v_25.xyz, r4.w); + let v_26 = -(cb3_3.tint_symbol_2[0u].xyzx); + let v_27 = fma(r2.xyz, r1.yyy, v_26.xyz); + r5 = vec4(v_27.xyz, r5.w); + r2.w = dot(r5.xyz, r5.xyz); + r2.w = inverseSqrt(r2.w); + let v_28 = (r2.www * r5.xyz); + r5 = vec4(v_28.xyz, r5.w); + let v_29 = (cb2_2.tint_symbol_1[15u].zy * cb2_2.tint_symbol_1[15u].zy); + r6 = vec4(v_29.xy, r6.zw); + r2.w = (cb12_12.tint_symbol_4[0u].w + -500.0f); + r2.w = max(r2.w, 0.0f); + r3.w = ((-(r2.wwww)).w + cb12_12.tint_symbol_4[0u].w); + r2.w = (r2.w * 558.0f); + r2.w = fma(r3.w, 3.0f, r2.w); + r3.w = dot(r2.xyz, cb1_1.tint_symbol[14u].xyz); + let v_30 = (v5.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz); + r7 = vec4(v_30.xyz, r7.w); + let v_31 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz); + r8 = vec4(v_31.xyz, r8.w); + let v_32 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz); + r8 = vec4(v_32.xyz, r8.w); + let v_33 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz); + r8 = vec4(v_33.xyz, r8.w); + let v_34 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz); + r9 = vec4(v_34.xyz, r9.w); + let v_35 = &(x0[0u]); + let v_36 = r9; + *(v_35) = vec4(v_36.xyz, (*(v_35)).w); + let v_37 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz); + r10 = vec4(v_37.xyz, r10.w); + let v_38 = &(x0[1u]); + let v_39 = r10; + *(v_38) = vec4(v_39.xyz, (*(v_38)).w); + let v_40 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz); + r11 = vec4(v_40.xyz, r11.w); + let v_41 = &(x0[2u]); + let v_42 = r11; + *(v_41) = vec4(v_42.xyz, (*(v_41)).w); + let v_43 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz); + r8 = vec4(v_43.xyz, r8.w); + let v_44 = &(x0[3u]); + let v_45 = r8; + *(v_44) = vec4(v_45.xyz, (*(v_44)).w); + let v_46 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.34609651565551757812f, 0.32848981022834777832f)); + let v_47 = r12; + r12 = vec4(v_47.x, v_46.x, v_47.z, v_46.y); + r4.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f); + r4.w = (r4.w * 0.5f); + let v_48 = abs(r11.yyyy); + r5.w = max(v_48.w, abs(r11.xxxx).w); + r5.w = bitcast(select(0u, 4294967295u, (r5.w < r4.w))); + let v_49 = (bitcast(r5.w) != 0u); + let v_50 = bitcast(v.tint_symbol_6[0i].x); + r5.w = select(bitcast(v.tint_symbol_6[1i].x), v_50, v_49); + let v_51 = abs(r10.yyyy); + r6.z = max(v_51.z, abs(r10.xxxx).z); + r6.z = bitcast(select(0u, 4294967295u, (r6.z < r4.w))); + let v_52 = bitcast(r6.z); + r5.w = select(r5.w, bitcast(v.tint_symbol_6[2i].x), (v_52 != 0u)); + let v_53 = abs(r9.yyyy); + r6.z = max(v_53.z, abs(r9.xxxx).z); + r4.w = bitcast(select(0u, 4294967295u, (r6.z < r4.w))); + let v_54 = bitcast(r4.w); + r4.w = select(r5.w, 0.0f, (v_54 != 0u)); + let v_55 = x0[bitcast(r4.w)]; + r9 = vec4(v_55.xyz, r9.w); + r4.w = f32(bitcast(r4.w)); + r5.w = (r4.w + 0.5f); + r5.w = (r5.w * 0.25f); + r10 = bitcast>(select(vec4(), vec4(4294967295u), (vec4(0.0f, 1.0f, 2.0f, 3.0f) == r4.wwww))); + r10 = bitcast>((bitcast>(r10) & vec4(1065353216u))); + r4.w = dot(r10, cb6_6.tint_symbol_5[12u]); + r6.z = dot(r10, cb6_6.tint_symbol_5[13u]); + r10.x = (r9.x + 0.5f); + r10.y = fma(r9.y, 0.25f, r5.w); + r5.w = bitcast(select(0u, 4294967295u, !((r4.w == 0.0f)))); + r4.w = ((-(r4.wwww)).w + r9.z); + let v_56 = dpdx(r10.xyy); + r11 = vec4(v_56.xy, r11.z, v_56.z); + r11.z = dpdx(r4.w); + let v_57 = dpdy(r10.yxy); + r13 = vec4(v_57.xyz, r13.w); + r13.w = dpdy(r4.w); + let v_58 = (r11.yw * r13.yw); + r8 = vec4(r8.xy, v_58.xy); + let v_59 = -(r8.zwzz); + let v_60 = fma(r11.xz, r13.xz, v_59.xy); + r14 = vec4(v_60.xy, r14.zw); + r6.w = (1.0f / r14.x); + r7.w = (r11.z * r13.y); + let v_61 = -(r7.wwww); + r14.z = fma(r11.x, r13.w, v_61.z); + let v_62 = (r6.ww * r14.yz); + r8 = vec4(r8.xy, v_62.xy); + let v_63 = max(r8.zw, vec2()); + r8 = vec4(r8.xy, v_63.xy); + let v_64 = min(r8.zw, vec2(0.5f)); + r8 = vec4(r8.xy, v_64.xy); + r4.w = fma((-(r6.zzzz)).w, r8.z, r4.w); + r4.w = fma((-(r6.zzzz)).w, r8.w, r4.w); + let v_65 = bitcast(r5.w); + let v_66 = r4.w; + r12.z = select(r9.z, v_66, (v_65 != 0u)); + r10.z = 0.0f; + let v_67 = (r10.xyz + r12.ywz); + r9 = vec4(v_67.xyz, r9.w); + let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.79929149150848388672f, 0.20174059271812438965f)); + r12 = vec4(v_68.xy, r12.zw); + let v_69 = (r10.xyz + r12.xyz); + r11 = vec4(v_69.xyz, r11.w); + let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.03117550723254680634f, 0.17933775484561920166f)); + r12 = vec4(v_70.xy, r12.zw); + let v_71 = (r10.xyz + r12.xyz); + r13 = vec4(v_71.xyz, r13.w); + let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.51474946737289428711f, 0.25350245833396911621f)); + r12 = vec4(v_72.xy, r12.zw); + let v_73 = (r10.xyz + r12.xyz); + r14 = vec4(v_73.xyz, r14.w); + let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.07286971807479858398f, 0.00809734128415584564f)); + r12 = vec4(v_74.xy, r12.zw); + let v_75 = (r10.xyz + r12.xyz); + r15 = vec4(v_75.xyz, r15.w); + let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.96978127956390380859f, 0.03452160954475402832f)); + r12 = vec4(v_76.xy, r12.zw); + let v_77 = (r10.xyz + r12.xyz); + r16 = vec4(v_77.xyz, r16.w); + let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.54554665088653564453f, 0.02412854135036468506f)); + r12 = vec4(v_78.xy, r12.zw); + let v_79 = (r10.xyz + r12.xyz); + r17 = vec4(v_79.xyz, r17.w); + let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.02890610881149768829f, -0.13678458333015441895f)); + r12 = vec4(v_80.xy, r12.zw); + let v_81 = (r10.xyz + r12.xyz); + r18 = vec4(v_81.xyz, r18.w); + let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.47951146960258483887f, -0.24483287334442138672f)); + r12 = vec4(v_82.xy, r12.zw); + let v_83 = (r10.xyz + r12.xyz); + r19 = vec4(v_83.xyz, r19.w); + let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.7587884068489074707f, -0.1121091991662979126f)); + r12 = vec4(v_84.xy, r12.zw); + let v_85 = (r10.xyz + r12.xyz); + r20 = vec4(v_85.xyz, r20.w); + let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.33935257792472839355f, -0.24932782351970672607f)); + r12 = vec4(v_86.xy, r12.zw); + let v_87 = (r10.xyz + r12.xyz); + r21 = vec4(v_87.xyz, r21.w); + let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.07059764862060546875f, 0.2081225961446762085f)); + r12 = vec4(v_88.xy, r12.zw); + let v_89 = (r10.xyz + r12.xyz); + r22 = vec4(v_89.xyz, r22.w); + let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2(1.29403817653656005859f, -0.01807767525315284729f)); + r12 = vec4(v_90.xy, r12.zw); + let v_91 = (r10.xyz + r12.xyz); + r23 = vec4(v_91.xyz, r23.w); + let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2(-0.7475630640983581543f, -0.11397434771060943604f)); + r12 = vec4(v_92.xy, r12.zw); + let v_93 = (r10.xyz + r12.xyz); + r24 = vec4(v_93.xyz, r24.w); + let v_94 = (cb6_6.tint_symbol_5[14u].zw * vec2(0.94772171974182128906f, -0.24876354634761810303f)); + r12 = vec4(v_94.xy, r12.zw); + let v_95 = (r10.xyz + r12.xyz); + r25 = vec4(v_95.xyz, r25.w); + let v_96 = (cb6_6.tint_symbol_5[14u].zw * vec2(-1.34315288066864013672f, -0.08858405798673629761f)); + r12 = vec4(v_96.xy, r12.zw); + let v_97 = (r10.xyz + r12.xyz); + r10 = vec4(v_97.xyz, r10.w); + let v_98 = r9.xyxx; + r9.x = textureSampleCompareLevel(t15, s15, v_98.xy, r9.z); + let v_99 = r11.xyxx; + r9.y = textureSampleCompareLevel(t15, s15, v_99.xy, r11.z); + let v_100 = r13.xyxx; + r9.z = textureSampleCompareLevel(t15, s15, v_100.xy, r13.z); + let v_101 = r14.xyxx; + r9.w = textureSampleCompareLevel(t15, s15, v_101.xy, r14.z); + let v_102 = r15.xyxx; + r11.x = textureSampleCompareLevel(t15, s15, v_102.xy, r15.z); + let v_103 = r16.xyxx; + r11.y = textureSampleCompareLevel(t15, s15, v_103.xy, r16.z); + let v_104 = r17.xyxx; + r11.z = textureSampleCompareLevel(t15, s15, v_104.xy, r17.z); + let v_105 = r18.xyxx; + r11.w = textureSampleCompareLevel(t15, s15, v_105.xy, r18.z); + let v_106 = r19.xyxx; + r12.x = textureSampleCompareLevel(t15, s15, v_106.xy, r19.z); + let v_107 = r20.xyxx; + r12.y = textureSampleCompareLevel(t15, s15, v_107.xy, r20.z); + let v_108 = r21.xyxx; + r12.z = textureSampleCompareLevel(t15, s15, v_108.xy, r21.z); + let v_109 = r22.xyxx; + r12.w = textureSampleCompareLevel(t15, s15, v_109.xy, r22.z); + let v_110 = r23.xyxx; + r13.x = textureSampleCompareLevel(t15, s15, v_110.xy, r23.z); + let v_111 = r24.xyxx; + r13.y = textureSampleCompareLevel(t15, s15, v_111.xy, r24.z); + let v_112 = r25.xyxx; + r13.z = textureSampleCompareLevel(t15, s15, v_112.xy, r25.z); + let v_113 = r10.xyxx; + r13.w = textureSampleCompareLevel(t15, s15, v_113.xy, r10.z); + r9 = (r9 + r11); + r9 = (r12 + r9); + r9 = (r13 + r9); + r4.w = dot(r9, vec4(1.0f)); + r3.w = clamp(fma(r3.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f); + let v_114 = abs(r8.yyyy); + r5.w = max(v_114.w, abs(r8.xxxx).w); + r5.w = clamp(fma(r5.wwww, vec4(15.0f), vec4(-6.30000019073486328125f)).w, 0.0f, 1.0f); + r3.w = ((-(r3.wwww)).w + 1.0f); + r3.w = (r5.w * r3.w); + r3.w = fma(r4.w, 0.0625f, r3.w); + r3.w = (r3.w * r3.w); + r3.w = min(r3.w, 1.0f); + r4.w = clamp(fma(v5.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f); + r4.w = sqrt(r4.w); + r4.w = (r4.w * cb6_6.tint_symbol_5[3u].z); + let v_115 = -(r3.wwww); + r3.w = fma(r4.w, v_115.w, r3.w); + let v_116 = dot(r3.xyz, v_26.xyz); + r4.w = clamp(vec4(v_116, v_116, v_116, v_116).w, 0.0f, 1.0f); + let v_117 = dot(r4.xyz, r3.xyz); + r8.x = clamp(vec4(v_117, v_117, v_117, v_117).x, 0.0f, 1.0f); + let v_118 = dot(r5.xyz, v_26.xyz); + r8.y = clamp(vec4(v_118, v_118, v_118, v_118).y, 0.0f, 1.0f); + let v_119 = ((-(r8.xxxy)).zw + vec2(1.0f)); + r6 = vec4(r6.xy, v_119.xy); + let v_120 = (r6.zw * r6.zw); + r8 = vec4(v_120.xy, r8.zw); + let v_121 = (r8.xy * r8.xy); + r8 = vec4(v_121.xy, r8.zw); + let v_122 = (r6.zw * r8.xy); + r6 = vec4(r6.xy, v_122.xy); + r5.w = ((-(cb12_12.tint_symbol_4[0u].zzzz)).w + 1.0f); + let v_123 = fma(cb12_12.tint_symbol_4[0u].zz, r6.zw, r5.ww); + r6 = vec4(r6.xy, v_123.xy); + let v_124 = (r2.ww + vec2(2.0f, 0.00000000999999993923f)); + r8 = vec4(v_124.xy, r8.zw); + r2.w = (r8.x * 0.125f); + r6.z = fma((-(r1.xxxx)).z, r6.z, 1.0f); + r5.x = dot(r3.xyz, r5.xyz); + r5.x = clamp(((r5.xxxx + vec4(0.00000000999999993923f))).x, 0.0f, 1.0f); + r5.x = log2(r5.x); + r5.x = (r5.x * r8.y); + r5.x = exp2(r5.x); + r5.x = (r6.w * r5.x); + r5.x = (r2.w * r5.x); + r5.x = (r1.x * r5.x); + r5.x = (r4.w * r5.x); + r4.w = (r4.w * r6.z); + let v_125 = fma(r0.xyz, r4.www, r5.xxx); + r5 = vec4(v_125.xyz, r5.w); + let v_126 = (r5.xyz * cb3_3.tint_symbol_2[1u].xyz); + r5 = vec4(v_126.xyz, r5.w); + r4.w = bitcast(select(0u, 4294967295u, (0i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r4.w) != 0u)) { + r9 = vec4(vec3(), r9.w); + r8 = vec4(0.0f, r8.y, vec2()); + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f))); + let v_127 = ((-(v5.xxyz)).xzw + cb3_3.tint_symbol_2[3u].xyz); + r8 = vec4(v_127.x, r8.y, v_127.yz); + let v_128 = (v5.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz); + r9 = vec4(v_128.xyz, r9.w); + r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w); + let v_129 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz); + r9 = vec4(v_129.xyz, r9.w); + let v_130 = (r9.xyz + v_23.xyz); + r9 = vec4(v_130.xyz, r9.w); + let v_131 = bitcast>(r6.www); + let v_132 = r8.xzw; + let v_133 = select(r9.xyz, v_132, (v_131 != vec3())); + r8 = vec4(v_133.x, r8.y, v_133.yz); + r6.w = dot(r8.xzw, r8.xzw); + let v_134 = (r8.xzw + vec3(0.00000099999999747524f)); + r8 = vec4(v_134.x, r8.y, v_134.yz); + r7.w = dot(r8.xzw, r8.xzw); + r7.w = inverseSqrt(r7.w); + let v_135 = (r7.www * r8.xzw); + r8 = vec4(v_135.x, r8.y, v_135.yz); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[11u].w); + r6.w = (r6.w / r7.w); + let v_136 = -(cb3_3.tint_symbol_2[11u].xyzx); + r7.w = dot(r8.xzw, v_136.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f); + let v_137 = dot(r8.xzw, r3.xyz); + r9.x = clamp(vec4(v_137, v_137, v_137, v_137).x, 0.0f, 1.0f); + r7.w = (r7.w * r9.x); + r9.x = (r6.w * r7.w); + let v_138 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz); + r9 = vec4(v_138.xyz, r9.w); + let v_139 = (r0.xyz * r9.xyz); + r9 = vec4(v_139.xyz, r9.w); + let v_140 = fma(r2.xyz, r1.yyy, r8.xzw); + r8 = vec4(v_140.x, r8.y, v_140.yz); + r9.w = dot(r8.xzw, r8.xzw); + r9.w = inverseSqrt(r9.w); + let v_141 = (r8.xzw * r9.www); + r8 = vec4(v_141.x, r8.y, v_141.yz); + let v_142 = dot(r8.xzw, r4.xyz); + r9.w = clamp(vec4(v_142, v_142, v_142, v_142).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.x = (r9.w * r9.w); + r10.x = (r10.x * r10.x); + r9.w = (r9.w * r10.x); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_143 = dot(r8.xzw, r3.xyz); + r8.x = clamp(vec4(v_143, v_143, v_143, v_143).x, 0.0f, 1.0f); + r8.x = log2(r8.x); + r8.x = (r8.x * r8.y); + r8.x = exp2(r8.x); + r8.x = (r8.x * r9.w); + r7.w = (r7.w * r8.x); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_144 = (r6.www * cb3_3.tint_symbol_2[19u].xyz); + r8 = vec4(v_144.x, r8.y, v_144.yz); + } + r6.w = bitcast(select(0u, 4294967295u, (0i < bitcast(cb3_3.tint_symbol_2[2u].x)))); + if ((bitcast(r6.w) != 0u)) { + r7.w = bitcast(select(0u, 4294967295u, (1i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r6.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + let v_145 = bitcast(r7.w); + let v_146 = r6.w; + r4.w = select(r4.w, v_146, (v_145 != 0u)); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f))); + let v_147 = (v_23.xyz + cb3_3.tint_symbol_2[4u].xyz); + r10 = vec4(v_147.xyz, r10.w); + let v_148 = (v5.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz); + r11 = vec4(v_148.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w); + let v_149 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz); + r11 = vec4(v_149.xyz, r11.w); + let v_150 = (r11.xyz + v_23.xyz); + r11 = vec4(v_150.xyz, r11.w); + let v_151 = bitcast>(r6.www); + let v_152 = r10.xyz; + let v_153 = select(r11.xyz, v_152, (v_151 != vec3())); + r10 = vec4(v_153.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_154 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_154.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_155 = (r7.www * r10.xyz); + r10 = vec4(v_155.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[12u].w); + r6.w = (r6.w / r7.w); + let v_156 = -(cb3_3.tint_symbol_2[12u].xyzx); + r7.w = dot(r10.xyz, v_156.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f); + let v_157 = dot(r10.xyz, r3.xyz); + r9.w = clamp(vec4(v_157, v_157, v_157, v_157).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_158 = (r9.www * cb3_3.tint_symbol_2[20u].xyz); + r11 = vec4(v_158.xyz, r11.w); + let v_159 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_159.xyz, r9.w); + let v_160 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_160.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_161 = (r9.www * r10.xyz); + r10 = vec4(v_161.xyz, r10.w); + let v_162 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_162, v_162, v_162, v_162).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_163 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_163, v_163, v_163, v_163).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_164 = fma(r6.www, cb3_3.tint_symbol_2[20u].xyz, r8.xzw); + r8 = vec4(v_164.x, r8.y, v_164.yz); + } + } else { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } + if ((bitcast(r4.w) != 0u)) { + r4.w = bitcast(v.tint_symbol_6[3i].x); + } else { + r6.w = bitcast(select(0u, 4294967295u, (2i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f))); + let v_165 = (v_23.xyz + cb3_3.tint_symbol_2[5u].xyz); + r10 = vec4(v_165.xyz, r10.w); + let v_166 = (v5.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz); + r11 = vec4(v_166.xyz, r11.w); + r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz); + r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f); + r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w); + let v_167 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz); + r11 = vec4(v_167.xyz, r11.w); + let v_168 = (r11.xyz + v_23.xyz); + r11 = vec4(v_168.xyz, r11.w); + let v_169 = bitcast>(r6.www); + let v_170 = r10.xyz; + let v_171 = select(r11.xyz, v_170, (v_169 != vec3())); + r10 = vec4(v_171.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + let v_172 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_172.xyz, r10.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = inverseSqrt(r7.w); + let v_173 = (r7.www * r10.xyz); + r10 = vec4(v_173.xyz, r10.w); + r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f); + r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[13u].w); + r6.w = (r6.w / r7.w); + let v_174 = -(cb3_3.tint_symbol_2[13u].xyzx); + r7.w = dot(r10.xyz, v_174.xyz); + r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f); + let v_175 = dot(r10.xyz, r3.xyz); + r9.w = clamp(vec4(v_175, v_175, v_175, v_175).w, 0.0f, 1.0f); + r7.w = (r7.w * r9.w); + r9.w = (r6.w * r7.w); + let v_176 = (r9.www * cb3_3.tint_symbol_2[21u].xyz); + r11 = vec4(v_176.xyz, r11.w); + let v_177 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_177.xyz, r9.w); + let v_178 = fma(r2.xyz, r1.yyy, r10.xyz); + r10 = vec4(v_178.xyz, r10.w); + r9.w = dot(r10.xyz, r10.xyz); + r9.w = inverseSqrt(r9.w); + let v_179 = (r9.www * r10.xyz); + r10 = vec4(v_179.xyz, r10.w); + let v_180 = dot(r10.xyz, r4.xyz); + r9.w = clamp(vec4(v_180, v_180, v_180, v_180).w, 0.0f, 1.0f); + r9.w = ((-(r9.wwww)).w + 1.0f); + r10.w = (r9.w * r9.w); + r10.w = (r10.w * r10.w); + r9.w = (r9.w * r10.w); + r9.w = fma(cb12_12.tint_symbol_4[0u].z, r9.w, r5.w); + let v_181 = dot(r10.xyz, r3.xyz); + r10.x = clamp(vec4(v_181, v_181, v_181, v_181).x, 0.0f, 1.0f); + r10.x = log2(r10.x); + r10.x = (r8.y * r10.x); + r10.x = exp2(r10.x); + r9.w = (r9.w * r10.x); + r7.w = (r7.w * r9.w); + r6.w = (r6.w * r7.w); + r6.w = (r2.w * r6.w); + let v_182 = fma(r6.www, cb3_3.tint_symbol_2[21u].xyz, r8.xzw); + r8 = vec4(v_182.x, r8.y, v_182.yz); + } + } + if ((bitcast(r4.w) != 0u)) { + } else { + r6.w = bitcast(select(0u, 4294967295u, (3i >= bitcast(cb3_3.tint_symbol_2[2u].x)))); + r4.w = bitcast((bitcast(r4.w) | bitcast(r6.w))); + if ((bitcast(r4.w) != 0u)) { + } else { + r4.w = bitcast(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f))); + let v_183 = (v_23.xyz + cb3_3.tint_symbol_2[6u].xyz); + r10 = vec4(v_183.xyz, r10.w); + let v_184 = (v5.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz); + r11 = vec4(v_184.xyz, r11.w); + r6.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz); + r6.w = clamp(((r6.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f); + r6.w = (r6.w * cb3_3.tint_symbol_2[22u].w); + let v_185 = fma(cb3_3.tint_symbol_2[14u].xyz, r6.www, cb3_3.tint_symbol_2[6u].xyz); + r11 = vec4(v_185.xyz, r11.w); + let v_186 = (r11.xyz + v_23.xyz); + r11 = vec4(v_186.xyz, r11.w); + let v_187 = bitcast>(r4.www); + let v_188 = r10.xyz; + let v_189 = select(r11.xyz, v_188, (v_187 != vec3())); + r10 = vec4(v_189.xyz, r10.w); + r4.w = dot(r10.xyz, r10.xyz); + let v_190 = (r10.xyz + vec3(0.00000099999999747524f)); + r10 = vec4(v_190.xyz, r10.w); + r6.w = dot(r10.xyz, r10.xyz); + r6.w = inverseSqrt(r6.w); + let v_191 = (r6.www * r10.xyz); + r10 = vec4(v_191.xyz, r10.w); + r4.w = clamp(fma(-(r4.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4(1.0f)).w, 0.0f, 1.0f); + r6.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f); + r6.w = fma(r6.w, r4.w, cb3_3.tint_symbol_2[14u].w); + r4.w = (r4.w / r6.w); + let v_192 = -(cb3_3.tint_symbol_2[14u].xyzx); + r6.w = dot(r10.xyz, v_192.xyz); + r6.w = clamp(fma(r6.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f); + let v_193 = dot(r10.xyz, r3.xyz); + r7.w = clamp(vec4(v_193, v_193, v_193, v_193).w, 0.0f, 1.0f); + r6.w = (r6.w * r7.w); + r7.w = (r4.w * r6.w); + let v_194 = (r7.www * cb3_3.tint_symbol_2[22u].xyz); + r11 = vec4(v_194.xyz, r11.w); + let v_195 = fma(r11.xyz, r0.xyz, r9.xyz); + r9 = vec4(v_195.xyz, r9.w); + let v_196 = fma(r2.xyz, r1.yyy, r10.xyz); + r2 = vec4(v_196.xyz, r2.w); + r1.y = dot(r2.xyz, r2.xyz); + r1.y = inverseSqrt(r1.y); + let v_197 = (r1.yyy * r2.xyz); + r2 = vec4(v_197.xyz, r2.w); + let v_198 = dot(r2.xyz, r4.xyz); + r1.y = clamp(vec4(v_198, v_198, v_198, v_198).y, 0.0f, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r4.x = (r1.y * r1.y); + r4.x = (r4.x * r4.x); + r1.y = (r1.y * r4.x); + r1.y = fma(cb12_12.tint_symbol_4[0u].z, r1.y, r5.w); + let v_199 = dot(r2.xyz, r3.xyz); + r2.x = clamp(vec4(v_199, v_199, v_199, v_199).x, 0.0f, 1.0f); + r2.x = log2(r2.x); + r2.x = (r2.x * r8.y); + r2.x = exp2(r2.x); + r1.y = (r1.y * r2.x); + r1.y = (r6.w * r1.y); + r1.y = (r4.w * r1.y); + r1.y = (r2.w * r1.y); + let v_200 = fma(r1.yyy, cb3_3.tint_symbol_2[22u].xyz, r8.xzw); + r8 = vec4(v_200.x, r8.y, v_200.yz); + } + } + r1.y = (r6.z * r6.z); + r1.x = (r1.x * r1.x); + let v_201 = (r8.xzw * r1.xxx); + r2 = vec4(v_201.xyz, r2.w); + let v_202 = fma(r1.yyy, r9.xyz, r2.xyz); + r2 = vec4(v_202.xyz, r2.w); + let v_203 = fma(r5.xyz, r3.www, r2.xyz); + r2 = vec4(v_203.xyz, r2.w); + r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w); + r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w); + r1.x = max(r1.x, 0.0f); + let v_204 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz); + r1 = vec4(r1.x, v_204.xyz); + r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f); + let v_205 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz); + r4 = vec4(v_205.xyz, r4.w); + let v_206 = (r4.xyz * cb2_2.tint_symbol_1[16u].zzz); + r4 = vec4(v_206.xyz, r4.w); + let v_207 = fma(r1.yzw, r2.www, r4.xyz); + r1 = vec4(r1.x, v_207.xyz); + let v_208 = (r6.yyy * r1.yzw); + r1 = vec4(r1.x, v_208.xyz); + let v_209 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz); + r4 = vec4(v_209.xyz, r4.w); + r5.x = cb3_3.tint_symbol_2[46u].w; + r5.y = cb3_3.tint_symbol_2[47u].w; + r5.z = cb3_3.tint_symbol_2[48u].w; + let v_210 = dot(r5.xyz, r3.xyz); + r1.x = clamp(vec4(v_210, v_210, v_210, v_210).x, 0.0f, 1.0f); + let v_211 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r4.xyz); + r3 = vec4(v_211.xyz, r3.w); + let v_212 = fma(r3.xyz, r6.xxx, r1.yzw); + r1 = vec4(v_212.xyz, r1.w); + let v_213 = (r6.zzz * r1.xyz); + r1 = vec4(v_213.xyz, r1.w); + let v_214 = fma(r1.xyz, r0.xyz, r2.xyz); + r0 = vec4(v_214.xyz, r0.w); + r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x); + if ((bitcast(cb5_5.tint_symbol_3[7u].x) != 0u)) { + r1.x = dot(r7.xyz, r7.xyz); + r1.y = sqrt(r1.x); + let v_215 = -(cb3_3.tint_symbol_2[50u].xxxx); + r1.z = (r1.y + v_215.z); + r1.z = max(r1.z, 0.0f); + r1.y = (r1.z / r1.y); + r1.y = (r1.y * r7.z); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].z); + r1.y = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.yyyy).y))); + r2.x = (r1.w * -1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r1.w = (r2.x / r1.w); + let v_216 = bitcast(r1.y); + r1.y = select(1.0f, r1.w, (v_216 != 0u)); + r1.w = (r1.z * cb3_3.tint_symbol_2[51u].w); + r1.y = (r1.y * r1.w); + r1.y = min(r1.y, 1.0f); + r1.y = (r1.y * 1.44269502162933349609f); + r1.y = exp2(r1.y); + r1.y = min(r1.y, 1.0f); + r1.y = ((-(r1.yyyy)).y + 1.0f); + r1.w = (r1.y * cb3_3.tint_symbol_2[52u].y); + r1.x = inverseSqrt(r1.x); + let v_217 = (r1.xxx * r7.xyz); + r2 = vec4(v_217.xyz, r2.w); + let v_218 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.x = clamp(vec4(v_218, v_218, v_218, v_218).x, 0.0f, 1.0f); + r1.x = log2(r1.x); + r1.x = (r1.x * cb3_3.tint_symbol_2[54u].w); + r1.x = exp2(r1.x); + let v_219 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.x = clamp(vec4(v_219, v_219, v_219, v_219).x, 0.0f, 1.0f); + r2.x = log2(r2.x); + r2.x = (r2.x * cb3_3.tint_symbol_2[53u].w); + r2.x = exp2(r2.x); + r1.y = fma((-(r1.yyyy)).y, cb3_3.tint_symbol_2[52u].y, 1.0f); + r1.y = (r1.y * cb3_3.tint_symbol_2[51u].y); + let v_220 = -(cb3_3.tint_symbol_2[52u].xxxx); + r2.y = (r1.z + v_220.y); + r2.y = max(r2.y, 0.0f); + r2.y = (r2.y * cb3_3.tint_symbol_2[51u].x); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + r1.w = clamp(fma(r1.yyyy, r2.yyyy, r1.wwww).w, 0.0f, 1.0f); + let v_221 = -(cb3_3.tint_symbol_2[51u].zzzz); + r1.z = (r1.z * v_221.z); + r1.z = (r1.z * 1.44269502162933349609f); + r1.z = exp2(r1.z); + r1.z = ((-(r1.zzzz)).z + 1.0f); + let v_222 = ((-(cb3_3.tint_symbol_2[56u].xxyz)).yzw + cb3_3.tint_symbol_2[58u].xyz); + r2 = vec4(r2.x, v_222.xyz); + let v_223 = fma(r1.xxx, r2.yzw, cb3_3.tint_symbol_2[56u].xyz); + r2 = vec4(r2.x, v_223.xyz); + let v_224 = ((-(r2.yzwy)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r3 = vec4(v_224.xyz, r3.w); + let v_225 = fma(r2.xxx, r3.xyz, r2.yzw); + r2 = vec4(v_225.xyz, r2.w); + let v_226 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_227 = (r2.xyz + v_226.xyz); + r2 = vec4(v_227.xyz, r2.w); + let v_228 = fma(r1.zzz, r2.xyz, cb3_3.tint_symbol_2[57u].xyz); + r2 = vec4(v_228.xyz, r2.w); + r3.x = cb3_3.tint_symbol_2[55u].w; + r3.y = cb3_3.tint_symbol_2[56u].w; + r3.z = cb3_3.tint_symbol_2[57u].w; + let v_229 = ((-(r2.xyzx)).xyz + r3.xyz); + r3 = vec4(v_229.xyz, r3.w); + let v_230 = fma(r1.yyy, r3.xyz, r2.xyz); + r1 = vec4(v_230.xyz, r1.w); + r2.x = bitcast(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y))); + if ((bitcast(r2.x) != 0u)) { + let v_231 = (v7.xy * cb2_2.tint_symbol_1[18u].zw); + r2 = vec4(v_231.xy, r2.zw); + r2 = textureSample(t11, s11, r2.xyxx.xy); + r2.x = (r2.x + -1.0f); + r2.x = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r2.xxxx, vec4(1.0f)).x, 0.0f, 1.0f); + } else { + r2.x = 1.0f; + } + let v_232 = -(r0.xyzx); + let v_233 = fma(r1.xyz, r2.xxx, v_232.xyz); + r1 = vec4(v_233.xyz, r1.w); + let v_234 = fma(r1.www, r1.xyz, r0.xyz); + r1 = vec4(v_234.xyz, r1.w); + } else { + r1.w = dot(r7.xyz, r7.xyz); + r2.x = sqrt(r1.w); + let v_235 = -(cb3_3.tint_symbol_2[50u].xxxx); + r2.y = (r2.x + v_235.y); + r2.y = max(r2.y, 0.0f); + r2.x = (r2.y / r2.x); + r2.x = (r2.x * r7.z); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].z); + r2.x = bitcast(select(0u, 4294967295u, (0.00999999977648258209f < abs(r2.xxxx).x))); + r2.w = (r2.z * -1.44269502162933349609f); + r2.w = exp2(r2.w); + r2.w = ((-(r2.wwww)).w + 1.0f); + r2.z = (r2.w / r2.z); + let v_236 = bitcast(r2.x); + r2.x = select(1.0f, r2.z, (v_236 != 0u)); + r2.z = (r2.y * cb3_3.tint_symbol_2[51u].w); + r2.x = (r2.x * r2.z); + r2.x = min(r2.x, 1.0f); + r2.x = (r2.x * 1.44269502162933349609f); + r2.x = exp2(r2.x); + r2.x = min(r2.x, 1.0f); + r2.x = ((-(r2.xxxx)).x + 1.0f); + r2.z = (r2.x * cb3_3.tint_symbol_2[52u].y); + r1.w = inverseSqrt(r1.w); + let v_237 = (r1.www * r7.xyz); + r3 = vec4(v_237.xyz, r3.w); + let v_238 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz); + r1.w = clamp(vec4(v_238, v_238, v_238, v_238).w, 0.0f, 1.0f); + r1.w = log2(r1.w); + r1.w = (r1.w * cb3_3.tint_symbol_2[54u].w); + r1.w = exp2(r1.w); + let v_239 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz); + r2.w = clamp(vec4(v_239, v_239, v_239, v_239).w, 0.0f, 1.0f); + r2.w = log2(r2.w); + r2.w = (r2.w * cb3_3.tint_symbol_2[53u].w); + r2.w = exp2(r2.w); + r2.x = fma((-(r2.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f); + r2.x = (r2.x * cb3_3.tint_symbol_2[51u].y); + let v_240 = -(cb3_3.tint_symbol_2[52u].xxxx); + r3.x = (r2.y + v_240.x); + r3.x = max(r3.x, 0.0f); + r3.x = (r3.x * cb3_3.tint_symbol_2[51u].x); + r3.x = (r3.x * 1.44269502162933349609f); + r3.x = exp2(r3.x); + r3.x = ((-(r3.xxxx)).x + 1.0f); + r2.z = clamp(fma(r2.xxxx, r3.xxxx, r2.zzzz).z, 0.0f, 1.0f); + let v_241 = -(cb3_3.tint_symbol_2[51u].zzzz); + r2.y = (r2.y * v_241.y); + r2.y = (r2.y * 1.44269502162933349609f); + r2.y = exp2(r2.y); + r2.y = ((-(r2.yyyy)).y + 1.0f); + let v_242 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz); + r3 = vec4(v_242.xyz, r3.w); + let v_243 = fma(r1.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz); + r3 = vec4(v_243.xyz, r3.w); + let v_244 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz); + r4 = vec4(v_244.xyz, r4.w); + let v_245 = fma(r2.www, r4.xyz, r3.xyz); + r3 = vec4(v_245.xyz, r3.w); + let v_246 = -(cb3_3.tint_symbol_2[57u].xyzx); + let v_247 = (r3.xyz + v_246.xyz); + r3 = vec4(v_247.xyz, r3.w); + let v_248 = fma(r2.yyy, r3.xyz, cb3_3.tint_symbol_2[57u].xyz); + r3 = vec4(v_248.xyz, r3.w); + r4.x = cb3_3.tint_symbol_2[55u].w; + r4.y = cb3_3.tint_symbol_2[56u].w; + r4.z = cb3_3.tint_symbol_2[57u].w; + let v_249 = ((-(r3.xyzx)).xyz + r4.xyz); + r4 = vec4(v_249.xyz, r4.w); + let v_250 = fma(r2.xxx, r4.xyz, r3.xyz); + r2 = vec4(v_250.xy, r2.z, v_250.z); + let v_251 = ((-(r0.xyxz)).xyw + r2.xyw); + r2 = vec4(v_251.xy, r2.z, v_251.z); + let v_252 = fma(r2.zzz, r2.xyw, r0.xyz); + r1 = vec4(v_252.xyz, r1.w); + } + let v_253 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz); + o0 = vec4(v_253.xyz, o0.w); + r0.x = bitcast(select(0u, 4294967295u, (0.15000000596046447754f < r0.w))); + r0.x = bitcast((bitcast(r0.x) & 1065353216u)); + o1 = (r0.x * v1.z); + o0.w = r0.w; + o2 = r0.x; +} + +struct tint_symbol_8 { + @location(0u) + o0 : vec4, + @location(1u) + o1 : f32, + @location(2u) + o2 : f32, +} + +@fragment +fn main(@location(0u) v0 : vec4, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec4, @location(4u) v4 : vec4, @location(5u) v5 : vec4, @location(6u) v6 : vec4, @builtin(position) v_254 : vec4) -> tint_symbol_8 { + main_inner(v0, v1, v2, v3, v4, v5, v6, v_254); + return tint_symbol_8(o0, o1, o2); +} diff --git a/b/8b0b5899ed/shaders/01ab6c0fe360230c.wgsl b/b/8b0b5899ed/shaders/01ab6c0fe360230c.wgsl new file mode 100644 index 0000000000000000000000000000000000000000..e6c30957ca97033ff04c7c6e9add23126652c2fc --- /dev/null +++ b/b/8b0b5899ed/shaders/01ab6c0fe360230c.wgsl @@ -0,0 +1,524 @@ +diagnostic(off, derivative_uniformity); + +var r0 : vec4; + +var r1 : vec4; + +var r2 : vec4; + +var r3 : vec4; + +var r4 : vec4; + +var r5 : vec4; + +var r6 : vec4; + +var r7 : vec4; + +var r8 : vec4; + +var r9 : vec4; + +var r10 : vec4; + +struct cb765_struct { + tint_symbol : array, 765u>, +} + +@group(0u) @binding(4u) var cb4_4 : cb765_struct; + +struct cb12_struct { + tint_symbol_1 : array, 12u>, +} + +@group(0u) @binding(1u) var cb1_1 : cb12_struct; + +struct cb17_struct { + tint_symbol_2 : array, 17u>, +} + +@group(0u) @binding(2u) var cb2_2 : cb17_struct; + +struct cb15_struct { + tint_symbol_3 : array, 15u>, +} + +@group(0u) @binding(11u) var cb11_11 : cb15_struct; + +struct cb2_struct { + tint_symbol_4 : array, 2u>, +} + +@group(0u) @binding(8u) var cb8_8 : cb2_struct; + +struct cb15_struct_1 { + tint_symbol_5 : array, 15u>, +} + +@group(0u) @binding(9u) var cb9_9 : cb15_struct_1; + +struct cb5_struct { + tint_symbol_6 : array, 5u>, +} + +@group(0u) @binding(12u) var cb12_12 : cb5_struct; + +@group(0u) @binding(18u) var s2 : sampler; + +@group(0u) @binding(34u) var t2 : texture_3d; + +var o0 : vec4; + +var o1 : vec4; + +var o2 : vec4; + +var o3 : vec4; + +var o4 : vec4; + +var o5 : vec4; + +fn main_inner(v0 : vec3, v1 : vec4, v2 : vec4, v3 : vec3, v4 : vec4, v6 : vec2, v7 : vec4) { + r0 = (v2 * vec4(255.001953125f)); + let v = r0; + let v_1 = max(v, vec4(-2147483648.0f)); + r0 = bitcast>(select(select(vec4(v_1), vec4(2147483647i), (v_1 >= vec4(2147483648.0f))), vec4(), !((v == v)))); + r0 = bitcast>((bitcast>(r0) * vec4(3i))); + r1 = (v1.yyyy * cb4_4.tint_symbol[bitcast(r0.y)]); + r2 = (v1.yyyy * cb4_4.tint_symbol[bitcast((bitcast(r0.y) + 1i))]); + r3 = (v1.yyyy * cb4_4.tint_symbol[bitcast((bitcast(r0.y) + 2i))]); + r1 = fma(cb4_4.tint_symbol[bitcast(r0.x)], v1.xxxx, r1); + r2 = fma(cb4_4.tint_symbol[bitcast((bitcast(r0.x) + 1i))], v1.xxxx, r2); + r3 = fma(cb4_4.tint_symbol[bitcast((bitcast(r0.x) + 2i))], v1.xxxx, r3); + r1 = fma(cb4_4.tint_symbol[bitcast(r0.z)], v1.zzzz, r1); + r2 = fma(cb4_4.tint_symbol[bitcast((bitcast(r0.z) + 1i))], v1.zzzz, r2); + r3 = fma(cb4_4.tint_symbol[bitcast((bitcast(r0.z) + 2i))], v1.zzzz, r3); + r1 = fma(cb4_4.tint_symbol[bitcast(r0.w)], v1.wwww, r1); + r2 = fma(cb4_4.tint_symbol[bitcast((bitcast(r0.w) + 1i))], v1.wwww, r2); + r0 = fma(cb4_4.tint_symbol[bitcast((bitcast(r0.w) + 2i))], v1.wwww, r3); + r3 = vec4(v0.xyz, r3.w); + r3.w = 1.0f; + r4.x = dot(r1, r3); + r4.y = dot(r2, r3); + r4.z = dot(r0, r3); + r0.w = dot(r1.xyz, v3); + r1.w = dot(r2.xyz, v3); + r2.w = dot(r0.xyz, v3); + r1.x = dot(r1.xyz, v7.xyz); + r1.y = dot(r2.xyz, v7.xyz); + r0.x = dot(r0.xyz, v7.xyz); + let v_2 = (r1.www * cb1_1.tint_symbol_1[1u].xyz); + r2 = vec4(v_2.xyz, r2.w); + let v_3 = fma(r0.www, cb1_1.tint_symbol_1[0u].xyz, r2.xyz); + r0 = vec4(r0.x, v_3.xyz); + let v_4 = fma(r2.www, cb1_1.tint_symbol_1[2u].xyz, r0.yzw); + r0 = vec4(r0.x, v_4.xyz); + let v_5 = (r1.yyy * cb1_1.tint_symbol_1[1u].xyz); + r1 = vec4(r1.x, v_5.xyz); + let v_6 = fma(r1.xxx, cb1_1.tint_symbol_1[0u].xyz, r1.yzw); + r1 = vec4(v_6.xyz, r1.w); + let v_7 = fma(r0.xxx, cb1_1.tint_symbol_1[2u].xyz, r1.xyz); + r1 = vec4(v_7.xyz, r1.w); + let v_8 = (r0.zwy * r1.zxy); + r2 = vec4(v_8.xyz, r2.w); + let v_9 = -(r2.xyzx); + let v_10 = fma(r1.yzx, r0.wyz, v_9.xyz); + r2 = vec4(v_10.xyz, r2.w); + o4 = ((r2.xyz * v7.www)).xyzx; + r0.x = dot(cb11_11.tint_symbol_3[5u].xyz, r4.xyz); + r0.x = clamp(((r0.xxxx + cb11_11.tint_symbol_3[5u].wwww)).x, 0.0f, 1.0f); + r1.w = bitcast(select(0u, 4294967295u, (0.0f < r0.x))); + if ((bitcast(r1.w) != 0u)) { + r1.w = clamp(((cb11_11.tint_symbol_3[4u].zzzz * cb12_12.tint_symbol_6[2u].zzzz)).w, 0.0f, 1.0f); + r1.w = ((-(r1.wwww)).w + 1.0f); + r2.x = (cb2_2.tint_symbol_2[16u].x * cb11_11.tint_symbol_3[1u].w); + r2.y = (cb2_2.tint_symbol_2[16u].x * cb11_11.tint_symbol_3[2u].w); + let v_11 = (r2.xy + v4.yy); + r2 = vec4(v_11.xy, r2.zw); + let v_12 = (r2.xy + cb11_11.tint_symbol_3[3u].ww); + r2 = vec4(v_12.xy, r2.zw); + let v_13 = fract(r2.xy); + r2 = vec4(v_13.xy, r2.zw); + let v_14 = (r2.xy + vec2(-0.5f)); + r2 = vec4(v_14.xy, r2.zw); + let v_15 = fma((-(abs(r2.xyxx))).xy, vec2(2.0f), vec2(1.0f)); + r2 = vec4(v_15.xy, r2.zw); + let v_16 = (r2.xy * r2.xy); + r2 = vec4(r2.xy, v_16.xy); + let v_17 = fma((-(r2.xyxx)).xy, vec2(2.0f), vec2(3.0f)); + r2 = vec4(v_17.xy, r2.zw); + let v_18 = (r2.xy * r2.zw); + r2 = vec4(v_18.xy, r2.zw); + let v_19 = fma(r2.xy, vec2(2.0f), vec2(-1.0f)); + r2 = vec4(v_19.xy, r2.zw); + let v_20 = ((-(r2.yyyx)).zw + vec2(1.0f)); + r2 = vec4(r2.xy, v_20.xy); + r3.x = (r2.z * r2.w); + let v_21 = (r2.zw * r2.xy); + r2 = vec4(r2.xy, v_21.xy); + r2.x = (r2.y * r2.x); + let v_22 = (r2.zzz * cb11_11.tint_symbol_3[1u].xyz); + r3 = vec4(r3.x, v_22.xyz); + let v_23 = fma(r3.xxx, cb11_11.tint_symbol_3[0u].xyz, r3.yzw); + r3 = vec4(v_23.xyz, r3.w); + let v_24 = fma(r2.www, cb11_11.tint_symbol_3[2u].xyz, r3.xyz); + r2 = vec4(r2.x, v_24.xyz); + let v_25 = fma(r2.xxx, cb11_11.tint_symbol_3[3u].xyz, r2.yzw); + r2 = vec4(v_25.xyz, r2.w); + r2.w = ((-(cb11_11.tint_symbol_3[11u].zzzz)).w + 1.0f); + let v_26 = (r2.xyz * cb11_11.tint_symbol_3[11u].zzz); + r2 = vec4(v_26.xyz, r2.w); + let v_27 = fma(r2.www, cb11_11.tint_symbol_3[0u].xyz, r2.xyz); + r2 = vec4(v_27.xyz, r2.w); + let v_28 = fma(cb11_11.tint_symbol_3[8u].xyz, cb2_2.tint_symbol_2[16u].xxx, v4.yyy); + r3 = vec4(v_28.xyz, r3.w); + let v_29 = (r3.xyz + cb11_11.tint_symbol_3[3u].www); + r3 = vec4(v_29.xyz, r3.w); + let v_30 = fract(r3.xyz); + r3 = vec4(v_30.xyz, r3.w); + let v_31 = (r3.xyz + vec3(-0.5f)); + r3 = vec4(v_31.xyz, r3.w); + let v_32 = fma((-(abs(r3.xyzx))).xyz, vec3(2.0f), vec3(1.0f)); + r3 = vec4(v_32.xyz, r3.w); + let v_33 = (r3.xyz * r3.xyz); + r5 = vec4(v_33.xyz, r5.w); + let v_34 = fma((-(r3.xyzx)).xyz, vec3(2.0f), vec3(3.0f)); + r3 = vec4(v_34.xyz, r3.w); + let v_35 = (r3.xyz * r5.xyz); + r3 = vec4(v_35.xyz, r3.w); + r2.w = (r3.x + r3.x); + r3.w = bitcast(select(0u, 4294967295u, (0.0f < cb11_11.tint_symbol_3[6u].w))); + if ((bitcast(r3.w) != 0u)) { + let v_36 = fma(r3.xyz, vec3(2.0f), vec3(-1.0f)); + r3 = vec4(v_36.xyz, r3.w); + let v_37 = fma(r3.xyz, cb11_11.tint_symbol_3[8u].www, r4.xyz); + r3 = vec4(v_37.xyz, r3.w); + let v_38 = -(cb11_11.tint_symbol_3[6u].xyzx); + let v_39 = (r3.xyz + v_38.xyz); + r3 = vec4(v_39.xyz, r3.w); + let v_40 = (r3.xyz * cb11_11.tint_symbol_3[7u].xyz); + r3 = vec4(v_40.xyz, r3.w); + r3 = textureSampleLevel(t2, s2, r3.xyzx.xyz, 0.0f); + } else { + r3 = vec4(vec3(), r3.w); + } + r3.w = ((-(cb11_11.tint_symbol_3[9u].xxxx)).w + 1.0f); + r2.w = (r2.w * cb11_11.tint_symbol_3[9u].x); + r2.w = fma(r2.w, 0.5f, r3.w); + let v_41 = (r3.xyz * r2.www); + r3 = vec4(v_41.xyz, r3.w); + let v_42 = (r3.xyz * cb11_11.tint_symbol_3[11u].yyy); + r3 = vec4(v_42.xyz, r3.w); + let v_43 = fma(cb11_11.tint_symbol_3[11u].xxx, r2.xyz, r3.xyz); + r2 = vec4(v_43.xyz, r2.w); + r2.w = max(v4.z, v4.x); + let v_44 = (r2.xyz * r2.www); + r2 = vec4(v_44.xyz, r2.w); + let v_45 = (r1.www * r2.xyz); + r2 = vec4(v_45.xyz, r2.w); + r3.x = dot(cb1_1.tint_symbol_1[0u].xyz, r2.xyz); + r3.y = dot(cb1_1.tint_symbol_1[1u].xyz, r2.xyz); + r3.z = dot(cb1_1.tint_symbol_1[2u].xyz, r2.xyz); + let v_46 = (r3.xyz * cb11_11.tint_symbol_3[10u].yyy); + r2 = vec4(v_46.xyz, r2.w); + r2.w = dot(r4.xyz, r4.xyz); + r2.w = sqrt(r2.w); + let v_47 = (abs(r2.xyzx).xyz + vec3(0.00100000004749745131f, 0.0f, 0.0f)); + r3 = vec4(v_47.xyz, r3.w); + r3.x = dot(r3.xyz, r3.xyz); + r3.x = sqrt(r3.x); + let v_48 = (r1.ww * cb11_11.tint_symbol_3[4u].xy); + let v_49 = r3; + r3 = vec4(v_49.x, v_48.xy, v_49.w); + r1.w = fma((-(cb11_11.tint_symbol_3[4u].xxxx)).w, r1.w, r3.x); + r1.w = max(r1.w, 0.0f); + r1.w = (r1.w / r3.z); + r1.w = (r1.w * -1.44269502162933349609f); + r1.w = exp2(r1.w); + r1.w = ((-(r1.wwww)).w + 1.0f); + r1.w = fma(r3.z, r1.w, r3.y); + r1.w = (r1.w / r3.x); + r3.x = bitcast(select(0u, 4294967295u, (r3.y >= r3.x))); + r3.x = bitcast((bitcast(r3.x) & 1065353216u)); + r3.y = ((-(r1.wwww)).y + 1.0f); + r1.w = fma(r3.y, r3.x, r1.w); + let v_50 = fma(r2.xyz, r1.www, r4.xyz); + r2 = vec4(v_50.xyz, r2.w); + r1.w = dot(r2.xyz, r2.xyz); + r1.w = sqrt(r1.w); + r1.w = (r2.w / r1.w); + let v_51 = (r1.www * r2.xyz); + r2 = vec4(v_51.xyz, r2.w); + } else { + let v_52 = r4; + r2 = vec4(v_52.xyz, r2.w); + } + r1.w = bitcast(select(0u, 4294967295u, (r0.x < 1.0f))); + let v_53 = (v4.xxz * cb12_12.tint_symbol_6[2u].xxy); + r3 = vec4(v_53.xyz, r3.w); + let v_54 = (r3.xyz * cb9_9.tint_symbol_5[13u].xxy); + r3 = vec4(v_54.xyz, r3.w); + r2.w = (v4.y + cb9_9.tint_symbol_5[0u].w); + r2.w = (abs(r2.wwww).w * 6.28318500518798828125f); + let v_55 = (cb9_9.tint_symbol_5[13u].zzw * cb12_12.tint_symbol_6[2u].zzw); + r5 = vec4(v_55.xyz, r5.w); + let v_56 = fma(cb2_2.tint_symbol_2[16u].xxx, r5.xyz, r2.www); + r5 = vec4(v_56.xyz, r5.w); + let v_57 = sin(r5.xyzx.xyz); + r5 = vec4(v_57.xyz, r5.w); + let v_58 = fma(r5.xyz, r3.xyz, r4.xyz); + r3 = vec4(v_58.xyz, r3.w); + let v_59 = bitcast>(r1.www); + let v_60 = r3.xyz; + let v_61 = select(r4.xyz, v_60, (v_59 != vec3())); + r3 = vec4(v_61.xyz, r3.w); + r1.w = ((-(r0.xxxx)).w + 1.0f); + let v_62 = (r0.xxx * r2.xyz); + r2 = vec4(v_62.xyz, r2.w); + let v_63 = fma(r1.www, r3.xyz, r2.xyz); + r2 = vec4(v_63.xyz, r2.w); + let v_64 = (cb1_1.tint_symbol_1[0u].xyz * cb9_9.tint_symbol_5[14u].zzz); + r3 = vec4(v_64.xyz, r3.w); + let v_65 = (cb1_1.tint_symbol_1[1u].xyz * cb9_9.tint_symbol_5[14u].zzz); + r4 = vec4(v_65.xyz, r4.w); + let v_66 = (cb1_1.tint_symbol_1[2u].xyz * cb9_9.tint_symbol_5[14u].www); + r5 = vec4(v_66.xyz, r5.w); + let v_67 = (r2.xyz * cb9_9.tint_symbol_5[14u].xxy); + r6 = vec4(v_67.xyz, r6.w); + r6.w = 1.0f; + r7.x = r3.x; + r7.y = r4.x; + r7.z = r5.x; + r7.w = cb1_1.tint_symbol_1[3u].x; + r8.x = dot(r6, r7); + r9.x = r3.y; + r9.y = r4.y; + r9.z = r5.y; + r9.w = cb1_1.tint_symbol_1[3u].y; + r8.y = dot(r6, r9); + r10.x = r3.z; + r10.y = r4.z; + r10.z = r5.z; + r10.w = cb1_1.tint_symbol_1[3u].z; + r8.z = dot(r6, r10); + let v_68 = -(cb9_9.tint_symbol_5[0u].xyzx); + let v_69 = (r8.xyz + v_68.xyz); + r6 = vec4(v_69.xyz, r6.w); + r0.x = dot(r6.xyz, r6.xyz); + r1.w = ((-(r0.xxxx)).w + 0.5625f); + r1.w = (r1.w * 1.77777779102325439453f); + r1.w = max(r1.w, 0.0f); + r0.x = inverseSqrt(r0.x); + let v_70 = (r0.xx * r6.xy); + r6 = vec4(v_70.xy, r6.zw); + let v_71 = (r1.ww * r6.xy); + r6 = vec4(v_71.xy, r6.zw); + let v_72 = fma(r6.xy, v4.xx, r8.xy); + r8 = vec4(v_72.xy, r8.zw); + let v_73 = -(cb1_1.tint_symbol_1[3u].xyzx); + let v_74 = (r8.xyz + v_73.xyz); + r6 = vec4(v_74.xyz, r6.w); + let v_75 = (r6.xyz * cb9_9.tint_symbol_5[14u].zzw); + r6 = vec4(v_75.xyz, r6.w); + r8.x = dot(r6.xyz, r3.xyz); + r8.y = dot(r6.xyz, r4.xyz); + r8.z = dot(r6.xyz, r5.xyz); + let v_76 = bitcast>(cb8_8.tint_symbol_4[0u].xxx); + let v_77 = r8.xyz; + let v_78 = select(r2.xyz, v_77, (v_76 != vec3())); + r2 = vec4(v_78.xyz, r2.w); + if ((bitcast(cb8_8.tint_symbol_4[0u].y) != 0u)) { + let v_79 = (r2.xyz * cb9_9.tint_symbol_5[14u].xxy); + r6 = vec4(v_79.xyz, r6.w); + r6.w = 1.0f; + r7.x = dot(r6, r7); + r7.y = dot(r6, r9); + r0.x = dot(r6, r10); + let v_80 = -(cb9_9.tint_symbol_5[1u].xyxx); + let v_81 = (r7.xy + v_80.xy); + r6 = vec4(v_81.xy, r6.zw); + r1.w = dot(cb9_9.tint_symbol_5[2u].xy, r6.xy); + r1.w = clamp(((r1.wwww * cb9_9.tint_symbol_5[2u].wwww)).w, 0.0f, 1.0f); + let v_82 = fma(r1.ww, cb9_9.tint_symbol_5[2u].xy, cb9_9.tint_symbol_5[1u].xy); + r6 = vec4(v_82.xy, r6.zw); + let v_83 = ((-(r6.xyxx)).xy + r7.xy); + r6 = vec4(v_83.xy, r6.zw); + r1.w = dot(r6.xy, r6.xy); + r2.w = ((-(r1.wwww)).w + cb9_9.tint_symbol_5[3u].y); + r2.w = clamp(((r2.wwww * cb9_9.tint_symbol_5[3u].zzzz)).w, 0.0f, 1.0f); + r3.w = (r2.w * cb9_9.tint_symbol_5[3u].x); + r4.w = inverseSqrt(r1.w); + let v_84 = (r4.ww * r6.xy); + r6 = vec4(v_84.xy, r6.zw); + let v_85 = (r3.ww * r6.xy); + r6 = vec4(v_85.xy, r6.zw); + let v_86 = fma(r6.xy, v4.xx, r7.xy); + r6 = vec4(v_86.xy, r6.zw); + r3.w = ((-(r0.xxxx)).w + cb9_9.tint_symbol_5[3u].w); + r0.x = fma(r2.w, r3.w, r0.x); + r2.w = (cb9_9.tint_symbol_5[3u].x * 0.5f); + r2.w = (r2.w * r2.w); + r1.w = bitcast(select(0u, 4294967295u, (r1.w < r2.w))); + r2.w = (cb9_9.tint_symbol_5[3u].w + -0.25f); + let v_87 = bitcast(r1.w); + let v_88 = r2.w; + r6.z = select(r0.x, v_88, (v_87 != 0u)); + if ((bitcast(cb8_8.tint_symbol_4[0u].z) != 0u)) { + let v_89 = -(cb9_9.tint_symbol_5[4u].xyxx); + let v_90 = (r6.xy + v_89.xy); + r7 = vec4(v_90.xy, r7.zw); + r0.x = dot(cb9_9.tint_symbol_5[5u].xy, r7.xy); + r0.x = clamp(((r0.xxxx * cb9_9.tint_symbol_5[5u].wwww)).x, 0.0f, 1.0f); + let v_91 = fma(r0.xx, cb9_9.tint_symbol_5[5u].xy, cb9_9.tint_symbol_5[4u].xy); + r7 = vec4(v_91.xy, r7.zw); + let v_92 = -(r7.xyxx); + let v_93 = (r6.xy + v_92.xy); + r7 = vec4(v_93.xy, r7.zw); + r0.x = dot(r7.xy, r7.xy); + r1.w = ((-(r0.xxxx)).w + cb9_9.tint_symbol_5[6u].y); + r1.w = clamp(((r1.wwww * cb9_9.tint_symbol_5[6u].zzzz)).w, 0.0f, 1.0f); + r2.w = (r1.w * cb9_9.tint_symbol_5[6u].x); + r3.w = inverseSqrt(r0.x); + let v_94 = (r3.ww * r7.xy); + r7 = vec4(v_94.xy, r7.zw); + let v_95 = (r2.ww * r7.xy); + r7 = vec4(v_95.xy, r7.zw); + let v_96 = fma(r7.xy, v4.xx, r6.xy); + r6 = vec4(v_96.xy, r6.zw); + r2.w = ((-(r6.zzzz)).w + cb9_9.tint_symbol_5[6u].w); + r1.w = fma(r1.w, r2.w, r6.z); + r2.w = (cb9_9.tint_symbol_5[6u].x * 0.5f); + r2.w = (r2.w * r2.w); + r0.x = bitcast(select(0u, 4294967295u, (r0.x < r2.w))); + r2.w = (cb9_9.tint_symbol_5[6u].w + -0.25f); + let v_97 = bitcast(r0.x); + let v_98 = r2.w; + r6.z = select(r1.w, v_98, (v_97 != 0u)); + } + if ((bitcast(cb8_8.tint_symbol_4[0u].w) != 0u)) { + let v_99 = -(cb9_9.tint_symbol_5[7u].xyxx); + let v_100 = (r6.xy + v_99.xy); + r7 = vec4(v_100.xy, r7.zw); + r0.x = dot(cb9_9.tint_symbol_5[8u].xy, r7.xy); + r0.x = clamp(((r0.xxxx * cb9_9.tint_symbol_5[8u].wwww)).x, 0.0f, 1.0f); + let v_101 = fma(r0.xx, cb9_9.tint_symbol_5[8u].xy, cb9_9.tint_symbol_5[7u].xy); + r7 = vec4(v_101.xy, r7.zw); + let v_102 = -(r7.xyxx); + let v_103 = (r6.xy + v_102.xy); + r7 = vec4(v_103.xy, r7.zw); + r0.x = dot(r7.xy, r7.xy); + r1.w = ((-(r0.xxxx)).w + cb9_9.tint_symbol_5[9u].y); + r1.w = clamp(((r1.wwww * cb9_9.tint_symbol_5[9u].zzzz)).w, 0.0f, 1.0f); + r2.w = (r1.w * cb9_9.tint_symbol_5[9u].x); + r3.w = inverseSqrt(r0.x); + let v_104 = (r3.ww * r7.xy); + r7 = vec4(v_104.xy, r7.zw); + let v_105 = (r2.ww * r7.xy); + r7 = vec4(v_105.xy, r7.zw); + let v_106 = fma(r7.xy, v4.xx, r6.xy); + r6 = vec4(v_106.xy, r6.zw); + r2.w = ((-(r6.zzzz)).w + cb9_9.tint_symbol_5[9u].w); + r1.w = fma(r1.w, r2.w, r6.z); + r2.w = (cb9_9.tint_symbol_5[9u].x * 0.5f); + r2.w = (r2.w * r2.w); + r0.x = bitcast(select(0u, 4294967295u, (r0.x < r2.w))); + r2.w = (cb9_9.tint_symbol_5[9u].w + -0.25f); + let v_107 = bitcast(r0.x); + let v_108 = r2.w; + r6.z = select(r1.w, v_108, (v_107 != 0u)); + } + if ((bitcast(cb8_8.tint_symbol_4[1u].x) != 0u)) { + let v_109 = -(cb9_9.tint_symbol_5[10u].xyxx); + let v_110 = (r6.xy + v_109.xy); + r7 = vec4(v_110.xy, r7.zw); + r0.x = dot(cb9_9.tint_symbol_5[11u].xy, r7.xy); + r0.x = clamp(((r0.xxxx * cb9_9.tint_symbol_5[11u].wwww)).x, 0.0f, 1.0f); + let v_111 = fma(r0.xx, cb9_9.tint_symbol_5[11u].xy, cb9_9.tint_symbol_5[10u].xy); + r7 = vec4(v_111.xy, r7.zw); + let v_112 = -(r7.xyxx); + let v_113 = (r6.xy + v_112.xy); + r7 = vec4(v_113.xy, r7.zw); + r0.x = dot(r7.xy, r7.xy); + r1.w = ((-(r0.xxxx)).w + cb9_9.tint_symbol_5[12u].y); + r1.w = clamp(((r1.wwww * cb9_9.tint_symbol_5[12u].zzzz)).w, 0.0f, 1.0f); + r2.w = (r1.w * cb9_9.tint_symbol_5[12u].x); + r3.w = inverseSqrt(r0.x); + let v_114 = (r3.ww * r7.xy); + r7 = vec4(v_114.xy, r7.zw); + let v_115 = (r2.ww * r7.xy); + r7 = vec4(v_115.xy, r7.zw); + let v_116 = fma(r7.xy, v4.xx, r6.xy); + r6 = vec4(v_116.xy, r6.zw); + r2.w = ((-(r6.zzzz)).w + cb9_9.tint_symbol_5[12u].w); + r1.w = fma(r1.w, r2.w, r6.z); + r2.w = (cb9_9.tint_symbol_5[12u].x * 0.5f); + r2.w = (r2.w * r2.w); + r0.x = bitcast(select(0u, 4294967295u, (r0.x < r2.w))); + r2.w = (cb9_9.tint_symbol_5[12u].w + -0.25f); + let v_117 = bitcast(r0.x); + let v_118 = r2.w; + r6.z = select(r1.w, v_118, (v_117 != 0u)); + } + let v_119 = (r6.xyz + v_73.xyz); + r6 = vec4(v_119.xyz, r6.w); + let v_120 = (r6.xyz * cb9_9.tint_symbol_5[14u].zzw); + r6 = vec4(v_120.xyz, r6.w); + r2.x = dot(r6.xyz, r3.xyz); + r2.y = dot(r6.xyz, r4.xyz); + r2.z = dot(r6.xyz, r5.xyz); + } + r3 = (r2.yyyy * cb1_1.tint_symbol_1[9u]); + r3 = fma(r2.xxxx, cb1_1.tint_symbol_1[8u], r3); + r2 = fma(r2.zzzz, cb1_1.tint_symbol_1[10u], r3); + o0 = (r2 + cb1_1.tint_symbol_1[11u]); + let v_121 = (v4.xyz * cb11_11.tint_symbol_3[12u].xyz); + r2 = vec4(v_121.xyz, r2.w); + r0.x = max(v4.z, v4.x); + r1.w = fma((-(cb11_11.tint_symbol_3[4u].zzzz)).w, cb12_12.tint_symbol_6[2u].z, 1.0f); + r0.x = fma((-(r0.xxxx)).x, r1.w, 1.0f); + let v_122 = -(cb11_11.tint_symbol_3[13u].zzzz); + r0.x = fma(r0.x, cb11_11.tint_symbol_3[13u].x, v_122.x); + r1.w = (v_122.w + 1.0f); + r0.x = clamp(((r0.xxxx / r1.wwww)).x, 0.0f, 1.0f); + r1.w = ((-(r0.xxxx)).w + 1.0f); + let v_123 = fma(r1.www, r2.xyz, r0.xxx); + r2 = vec4(v_123.xyz, r2.w); + r0.x = ((-(cb11_11.tint_symbol_3[14u].wwww)).x + 1.0f); + let v_124 = (cb11_11.tint_symbol_3[14u].www * cb11_11.tint_symbol_3[14u].xyz); + r3 = vec4(v_124.xyz, r3.w); + let v_125 = fma(r0.xxx, r2.xyz, r3.xyz); + o5 = vec4(v_125.xyz, o5.w); + r0.x = bitcast(select(0u, 4294967295u, (0.0f < cb11_11.tint_symbol_3[12u].w))); + r1.w = bitcast(select(0u, 4294967295u, (cb11_11.tint_symbol_3[12u].w < 0.0f))); + let v_126 = -(bitcast>(r0.xxxx)); + r0.x = bitcast((bitcast(r1.w) + v_126.x)); + o5.w = f32(bitcast(r0.x)); + o1 = vec4(v6.xy, o1.zw); + o1.z = v4.w; + o1.w = cb12_12.tint_symbol_6[4u].y; + o2 = r0.yzw.xyzx; + o3 = r1.xyz.xyzx; +} + +struct tint_symbol_7 { + @builtin(position) + o0 : vec4, + @location(1u) + o1 : vec4, + @location(2u) + o2 : vec4, + @location(3u) + o3 : vec4, + @location(4u) + o4 : vec4, + @location(5u) + o5 : vec4, +} + +@vertex +fn main(@location(0u) v0 : vec3, @location(1u) v1 : vec4, @location(2u) v2 : vec4, @location(3u) v3 : vec3, @location(4u) v4 : vec4, @location(6u) v6 : vec2, @location(7u) v7 : vec4) -> tint_symbol_7 { + main_inner(v0, v1, v2, v3, v4, v6, v7); + return tint_symbol_7(o0, o1, o2, o3, o4, o5); +} diff --git a/b/8b0b5899ed/shaders/02838fb66b2552ee.consts.json b/b/8b0b5899ed/shaders/02838fb66b2552ee.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..1d66972864609a81c0df489230e1951a4dd5864c --- /dev/null +++ b/b/8b0b5899ed/shaders/02838fb66b2552ee.consts.json @@ -0,0 +1 @@ +[2, 6, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/02f627d274ec109d.consts.json b/b/8b0b5899ed/shaders/02f627d274ec109d.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/02f627d274ec109d.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/shaders/0381cf92f18d3c89.consts.json b/b/8b0b5899ed/shaders/0381cf92f18d3c89.consts.json new file mode 100644 index 0000000000000000000000000000000000000000..dbcfc521efda126b0a02b85ed33805eef92fd5be --- /dev/null +++ b/b/8b0b5899ed/shaders/0381cf92f18d3c89.consts.json @@ -0,0 +1 @@ +[2, 3, 1, 4294967295] \ No newline at end of file diff --git a/b/8b0b5899ed/wgpu_worker.js b/b/8b0b5899ed/wgpu_worker.js new file mode 100644 index 0000000000000000000000000000000000000000..34b868e57a771105b3fda1d27696402f750d9964 --- /dev/null +++ b/b/8b0b5899ed/wgpu_worker.js @@ -0,0 +1,2969 @@ +// wasm/platform/graphics/wgpu_worker.js +// +// The GPU worker of the wasm port: a plain JS worker (Node worker_threads or a browser dedicated worker) that owns the +// WebGPU device and executes the command stream the game writes into a ring buffer in the shared wasm memory. +// +// Why a separate worker and not calls from the game's render pthread: +// - WebGPU objects cannot cross threads, but D3D11 resources are created by any engine thread (streaming, main, render). +// The game threads only emit commands; every WebGPU object lives here. +// - WebGPU is asynchronous (device creation, mapAsync, onSubmittedWorkDone); this worker has a normal event loop, the +// game's blocking C++ threads never have to yield to JS. They wait on a futex/fence word in the ring when they need a +// result (readback, occlusion query). +// +// Protocol (see wgpu_backend.h for the C++ producer; keep both in sync): +// ring header, int32 words at the ring base address: +// [0] head byte offset of the next free byte (written by the producer(s) under a lock, published with release) +// [1] tail byte offset of the next unread command (written by this worker) +// [2] state 0 = starting, 1 = running, 2 = failed (commands are drained and dropped) +// [3] executed command counter (statistics) +// [4] error counter (WebGPU validation errors reported by the device) +// commands start at byte offset RING_DATA; each command = 2 header words (opcode, payload word count) + payload words. +// opcode WRAP: the producer continues at RING_DATA. +// +// Node needs the `webgpu` npm package (Dawn). Its location: env WGPU_NODE_MODULE, default D:/wasm_build/shaders/node/node_modules/webgpu. + +'use strict'; + +const RING_DATA = 64; +// keep in sync with wgpu_backend.h +const OP = { + NOP: 0, WRAP: 1, INIT: 2, CREATE_TEXTURE: 3, DESTROY_OBJECT: 4, CLEAR_RT: 5, CLEAR_DS: 6, PRESENT: 7, FENCE: 8, + SCREENSHOT: 9, LOG: 10, CREATE_BUFFER: 11, UPLOAD_BUFFER: 12, UPLOAD_TEXTURE: 13, CREATE_SHADER: 14, CREATE_LAYOUT: 15, + CREATE_STATE: 16, CREATE_SRV: 17, SET_SHADER: 18, SET_INPUT_LAYOUT: 19, SET_TOPOLOGY: 20, SET_VERTEX_BUFFERS: 21, + SET_INDEX_BUFFER: 22, SET_CBUFFERS: 23, SET_SRVS: 24, SET_SAMPLERS: 25, SET_RENDER_TARGETS: 26, SET_BLEND: 27, + SET_DEPTH_STENCIL: 28, SET_RASTER: 29, SET_VIEWPORTS: 30, SET_SCISSORS: 31, DRAW: 32, CLEAR_STATE: 33, + COPY_REGION: 34, COPY_RESOURCE: 35, RESOLVE: 36, CREATE_UAV: 37, SET_UAVS: 38, DISPATCH: 39, CLEAR_UAV: 40, GENERATE_MIPS: 41, READBACK: 42, COPY_COUNTER: 43, CREATE_QUERY: 44, BEGIN_QUERY: 45, END_QUERY: 46, UPLOAD_BUFFER_NO_OVERWRITE: 47, +}; + +const isNode = typeof process !== 'undefined' && !!(process.versions && process.versions.node); +let parentPort = null; +if (isNode) parentPort = require('worker_threads').parentPort; + +function post(msg) { if (parentPort) parentPort.postMessage(msg); else self.postMessage(msg); } +// fs.writeSync: process.stderr in a worker is proxied through the main thread, whose event loop the blocked game never runs +function logLine(s) { + if (isNode) { require('fs').writeSync(2, '[wgpu] ' + s + '\n'); return; } + console.log('[wgpu] ' + s); + // with ?log=1 on the page (loader.js puts it in this worker's URL) the page forwards it to the dev server (index.html, 'game-log'): a synchronous POST here stalled + // this worker for a network round trip (remote players: tens of ms) + if (logLine.remote === undefined) logLine.remote = new URLSearchParams(self.location.search).get('log') === '1'; + if (logLine.remote) try { (logLine.bc || (logLine.bc = new BroadcastChannel('game-log'))).postMessage('[wgpu] ' + s); } catch (e) { /* no channel */ } +} + +// ---- D3D11 (DXGI) -> WebGPU formats ---------------------------------------------------------------------------------- +// DXGI_FORMAT numbers. `ds` = the texture is bound as a depth-stencil target. Typeless formats pick the format the game +// most plausibly views them as; `views` are extra view formats (sRGB reinterpretation). +const DXGI = { + R32G32B32A32_FLOAT: 2, R32G32B32_FLOAT: 6, R16G16B16A16_TYPELESS: 9, R16G16B16A16_FLOAT: 10, R16G16B16A16_UNORM: 11, + R32G32_FLOAT: 16, R32G8X24_TYPELESS: 19, D32_FLOAT_S8X24_UINT: 20, R10G10B10A2_TYPELESS: 23, R10G10B10A2_UNORM: 24, + R11G11B10_FLOAT: 26, R8G8B8A8_TYPELESS: 27, R8G8B8A8_UNORM: 28, R8G8B8A8_UNORM_SRGB: 29, R16G16_TYPELESS: 33, + R16G16_FLOAT: 34, R16G16_UNORM: 35, R32_TYPELESS: 39, D32_FLOAT: 40, R32_FLOAT: 41, R24G8_TYPELESS: 44, + D24_UNORM_S8_UINT: 45, R8G8_TYPELESS: 48, R8G8_UNORM: 49, R16_TYPELESS: 53, R16_FLOAT: 54, D16_UNORM: 55, + R8_TYPELESS: 60, R8_UNORM: 61, BC1_TYPELESS: 70, BC1_UNORM: 71, BC1_UNORM_SRGB: 72, BC2_TYPELESS: 73, BC2_UNORM: 74, + BC2_UNORM_SRGB: 75, BC3_TYPELESS: 76, BC3_UNORM: 77, BC3_UNORM_SRGB: 78, BC4_TYPELESS: 79, BC4_UNORM: 80, + BC5_TYPELESS: 82, BC5_UNORM: 83, B8G8R8A8_UNORM: 87, B8G8R8X8_UNORM: 88, B8G8R8A8_TYPELESS: 90, + B8G8R8A8_UNORM_SRGB: 91, BC6H_TYPELESS: 94, BC6H_UF16: 95, BC7_TYPELESS: 97, BC7_UNORM: 98, BC7_UNORM_SRGB: 99, +}; +const BIND_SRV = 0x8, BIND_RT = 0x20, BIND_DS = 0x40, BIND_UAV = 0x80; + +function mapFormat(f, bind) { + const ds = (bind & BIND_DS) !== 0; + switch (f) { + case DXGI.R32G32B32A32_FLOAT: return { format: 'rgba32float' }; + case DXGI.R16G16B16A16_TYPELESS: case DXGI.R16G16B16A16_FLOAT: return { format: 'rgba16float' }; + case DXGI.R16G16B16A16_UNORM: return { format: 'rgba16float' }; // no core rgba16unorm: TODO texture-formats-tier1 + case DXGI.R32G32_FLOAT: return { format: 'rg32float' }; + case DXGI.R10G10B10A2_TYPELESS: case DXGI.R10G10B10A2_UNORM: return { format: 'rgb10a2unorm' }; + case DXGI.R11G11B10_FLOAT: return { format: 'rg11b10ufloat' }; + case DXGI.R8G8B8A8_TYPELESS: case DXGI.R8G8B8A8_UNORM: return { format: 'rgba8unorm', views: ['rgba8unorm-srgb'] }; + case DXGI.R8G8B8A8_UNORM_SRGB: return { format: 'rgba8unorm-srgb', views: ['rgba8unorm'] }; + case DXGI.B8G8R8A8_TYPELESS: case DXGI.B8G8R8A8_UNORM: case DXGI.B8G8R8X8_UNORM: return { format: 'bgra8unorm', views: ['bgra8unorm-srgb'] }; + case DXGI.B8G8R8A8_UNORM_SRGB: return { format: 'bgra8unorm-srgb', views: ['bgra8unorm'] }; + case DXGI.R16G16_TYPELESS: case DXGI.R16G16_FLOAT: case DXGI.R16G16_UNORM: return { format: 'rg16float' }; + case DXGI.R32_TYPELESS: return { format: ds ? 'depth32float' : 'r32float' }; + case DXGI.D32_FLOAT: return { format: 'depth32float' }; + case DXGI.R32_FLOAT: return { format: 'r32float' }; + case DXGI.R32G8X24_TYPELESS: case DXGI.D32_FLOAT_S8X24_UINT: return { format: 'depth32float-stencil8' }; + case DXGI.R24G8_TYPELESS: case DXGI.D24_UNORM_S8_UINT: return { format: 'depth24plus-stencil8' }; + case DXGI.R8G8_TYPELESS: case DXGI.R8G8_UNORM: return { format: 'rg8unorm' }; + case DXGI.R16_TYPELESS: return { format: ds ? 'depth16unorm' : 'r16float' }; + case DXGI.D16_UNORM: return { format: 'depth16unorm' }; + case DXGI.R16_FLOAT: return { format: 'r16float' }; + case DXGI.R8_TYPELESS: case DXGI.R8_UNORM: return { format: 'r8unorm' }; + case 63: return { format: 'r8snorm' }; + case 51: return { format: 'rg8snorm' }; + case 31: return { format: 'rgba8snorm' }; + case 67: return { format: 'rgb9e5ufloat' }; + case 65: return { format: 'rgba8unorm', a8: true }; // A8_UNORM: sampled as (0,0,0,a); expanded to rgba8 on upload (no texture swizzle in WebGPU) + case 56: return { format: 'depth16unorm' }; + case 21: case 22: case 46: case 47: return { format: 'depth24plus-stencil8' }; // depth/stencil views of a depth texture: the view aspect selects the plane + case DXGI.BC1_TYPELESS: case DXGI.BC1_UNORM: return { format: 'bc1-rgba-unorm', views: ['bc1-rgba-unorm-srgb'] }; + case DXGI.BC1_UNORM_SRGB: return { format: 'bc1-rgba-unorm-srgb', views: ['bc1-rgba-unorm'] }; + case DXGI.BC2_TYPELESS: case DXGI.BC2_UNORM: return { format: 'bc2-rgba-unorm', views: ['bc2-rgba-unorm-srgb'] }; + case DXGI.BC2_UNORM_SRGB: return { format: 'bc2-rgba-unorm-srgb', views: ['bc2-rgba-unorm'] }; + case DXGI.BC3_TYPELESS: case DXGI.BC3_UNORM: return { format: 'bc3-rgba-unorm', views: ['bc3-rgba-unorm-srgb'] }; + case DXGI.BC3_UNORM_SRGB: return { format: 'bc3-rgba-unorm-srgb', views: ['bc3-rgba-unorm'] }; + case DXGI.BC4_TYPELESS: case DXGI.BC4_UNORM: return { format: 'bc4-r-unorm' }; + case DXGI.BC5_TYPELESS: case DXGI.BC5_UNORM: return { format: 'bc5-rg-unorm' }; + case DXGI.BC6H_TYPELESS: case DXGI.BC6H_UF16: return { format: 'bc6h-rgb-ufloat' }; + case DXGI.BC7_TYPELESS: case DXGI.BC7_UNORM: return { format: 'bc7-rgba-unorm', views: ['bc7-rgba-unorm-srgb'] }; + case DXGI.BC7_UNORM_SRGB: return { format: 'bc7-rgba-unorm-srgb', views: ['bc7-rgba-unorm'] }; + default: logOnce('fmt' + f, 'no WebGPU format for DXGI ' + f + ' (using rgba8unorm)'); return { format: 'rgba8unorm' }; + } +} + +const hasStencil = (format) => format === 'depth24plus-stencil8' || format === 'depth32float-stencil8' || format === 'stencil8'; +const isDepth = (format) => format.startsWith('depth') || format === 'stencil8'; + +// ---- state -------------------------------------------------------------------------------------------------------------- +let gpu = null, adapter = null, device = null; +let mem = null, memBuffer = null, i32 = null, u32 = null, f32 = null, u8 = null, ringBase = 0, ringSize = 0; +let canvas = null, canvasCtx = null, canvasFormat = null, blit = null, canvasConfigured = false; +let fpsChannel = null, fpsOverlayN = 0, fpsOverlayT = 0; +let encoder = null, pass = null, passKey = ''; +let errorCount = 0, errorCount0 = 0, clampedDraws = 0, clampedDraws0 = 0; +const errorKinds = new Map(); // normalised message -> { n, msg } +function dumpErrors() { for (const [k, e] of [...errorKinds].sort((a, b) => b[1].n - a[1].n).slice(0, 15)) logLine(' error x' + e.n + ': ' + e.msg.slice(0, 300)); } +let drawCount = 0, skippedDraws = 0; +let lastPresentDraws = 0, progressChannel = null, worldSent = false; +let worldSince = 0, worldClean = 0, worldSkips0 = 0, worldNoteT = 0, skipsAtPresent = 0; // present(): the title screen stays up until frames stop skipping draws +// id -> object (texture, buffer, shader, layout, srv, state); ids are unique across kinds. Ids come from one counter in wgpu_backend.cpp (AllocId) and are never reused, so a plain +// array indexed by id holds them (dense, small gaps): a draw looks up ~15 objects, and an element load is several times cheaper than Map.get. +class IdTable { + constructor() { this.a = []; this.n = 0; } + get(id) { return this.a[id]; } + set(id, v) { if (this.a[id] === undefined) this.n++; this.a[id] = v; return this; } + delete(id) { if (this.a[id] === undefined) return false; this.a[id] = undefined; this.n--; return true; } + has(id) { return this.a[id] !== undefined; } + get size() { return this.n; } + *values() { for (const v of this.a) if (v !== undefined) yield v; } +} +const objs = new IdTable(); + +// Index into i32/u32 of a wasm memory address. Not a right shift by 2: JS shifts work on signed 32 bits, so every address at or above 2 GB (the memory starts at 3 GB and objects +// created later in a session live up there) became a negative index; event queries (the engine's GPU fences), occlusion queries and readback flags then never completed. +function w32(addr) { return Math.floor(addr / 4); } +let ringW = 0; // w32(ringBase) +function refreshViews() { + if (memBuffer === mem.buffer) return; + memBuffer = mem.buffer; + i32 = new Int32Array(memBuffer); + u32 = new Uint32Array(memBuffer); + f32 = new Float32Array(memBuffer); + u8 = new Uint8Array(memBuffer); +} + +function getEncoder() { return encoder || (encoder = device.createCommandEncoder()); } +function endPass() { if (pass) { endOcclusionInPass(); pass.end(); pass = null; passKey = ''; applied = {}; passSt = newPassSt(); } } +// What the current pass already has set: the same call twice is skipped (every WebGPU call costs a few microseconds of validation + serialisation) +function newPassSt() { return { pl: null, bg0: null, bg1: null, dyn0: -2, dyn1: -2, vb: [], vbo: [], ib: null, ibFmt: '', ibOff: -1, vp: null, sc: null, bf: null, sref: -1 }; } +let passSt = newPassSt(); +// Buffer/texture objects referenced by commands recorded since the last submit carry `enc === encEpoch`; flush() starts a new epoch. (A Set cost a hash insert for every bound +// buffer of every draw; nothing iterates it.) +let encEpoch = 1, submits = 0, submits0 = 0; +const usedInEncoder = { add(o) { if (o) o.enc = encEpoch; }, has(o) { return !!o && o.enc === encEpoch; }, clear() { encEpoch++; } }; +const flushReasons = new Map(); // submits per reason since the last fps line +function flush(reason) { + const tf0 = performance.now(); + if (encoder || pass) { const r = reason || 'other'; flushReasons.set(r, (flushReasons.get(r) || 0) + 1); } + endPass(); + if (dirtyChunks.size) flushUniforms(); + const resolves = pendingResolve.length ? recordResolves() : null; // into this encoder: no command buffer of its own + if (encoder) { device.queue.submit([encoder.finish()]); encoder = null; onSubmitted(); submits++; counterSlot = 0; } + if (resolves) mapResolves(resolves); + fr.flush += performance.now() - tf0; + usedInEncoder.clear(); +} +function logOnce(key, msg) { if (!logOnce.seen) logOnce.seen = new Set(); if (logOnce.seen.has(key)) return; logOnce.seen.add(key); logLine(msg); } + +// ---- D3D11 enums -> WebGPU ---------------------------------------------------------------------------------------------- +const CMP = [null, 'never', 'less', 'equal', 'less-equal', 'greater', 'not-equal', 'greater-equal', 'always']; +const STENCIL_OP = [null, 'keep', 'zero', 'replace', 'increment-clamp', 'decrement-clamp', 'invert', 'increment-wrap', 'decrement-wrap']; +const BLEND_FACTOR = [null, 'zero', 'one', 'src', 'one-minus-src', 'src-alpha', 'one-minus-src-alpha', 'dst-alpha', 'one-minus-dst-alpha', + 'dst', 'one-minus-dst', 'src-alpha-saturated', null, null, 'constant', 'one-minus-constant', 'src1', 'one-minus-src1', 'src1-alpha', 'one-minus-src1-alpha']; +const BLEND_OP = [null, 'add', 'subtract', 'reverse-subtract', 'min', 'max']; +const TOPOLOGY = { 1: ['point-list', false], 2: ['line-list', false], 3: ['line-strip', true], 4: ['triangle-list', false], 5: ['triangle-strip', true] }; +const ADDRESS = [null, 'repeat', 'mirror-repeat', 'clamp-to-edge', 'clamp-to-edge', 'mirror-repeat']; + +function vertexFormat(dxgi) { + switch (dxgi) { + case 2: return ['float32x4', 16, 'f']; case 6: return ['float32x3', 12, 'f']; case 16: return ['float32x2', 8, 'f']; case 41: return ['float32', 4, 'f']; + case 3: return ['uint32x4', 16, 'u']; case 7: return ['uint32x3', 12, 'u']; case 17: return ['uint32x2', 8, 'u']; case 42: return ['uint32', 4, 'u']; + case 4: return ['sint32x4', 16, 'i']; case 8: return ['sint32x3', 12, 'i']; case 18: return ['sint32x2', 8, 'i']; case 43: return ['sint32', 4, 'i']; + case 10: return ['float16x4', 8, 'f']; case 34: return ['float16x2', 4, 'f']; + case 11: return ['unorm16x4', 8, 'f']; case 35: return ['unorm16x2', 4, 'f']; + case 12: return ['uint16x4', 8, 'u']; case 36: return ['uint16x2', 4, 'u']; + case 13: return ['snorm16x4', 8, 'f']; case 37: return ['snorm16x2', 4, 'f']; + case 14: return ['sint16x4', 8, 'i']; case 38: return ['sint16x2', 4, 'i']; + case 28: return ['unorm8x4', 4, 'f']; case 30: return ['uint8x4', 4, 'u']; case 31: return ['snorm8x4', 4, 'f']; case 32: return ['sint8x4', 4, 'i']; + case 49: return ['unorm8x2', 2, 'f']; case 50: return ['uint8x2', 2, 'u']; case 51: return ['snorm8x2', 2, 'f']; case 52: return ['sint8x2', 2, 'i']; + case 87: return ['unorm8x4-bgra', 4, 'f']; case 24: return ['unorm10-10-10-2', 4, 'f']; + default: return null; + } +} + +// D3D11_FILTER: bits 4-5 min, 2-3 mag, 0-1 mip (bit set = linear); 0x80 = comparison; 0x55 with aniso. +function makeSampler(words) { + if ([1, 2, 3].some((i) => words[i] === 4)) noteApprox('sampler border addressing', 'border colour ' + [7, 8, 9, 10].map((i) => wf(words[i]).toFixed(2)).join(',') + (words[0] & 0x80 ? ' (comparison)' : '')); + if (wf(words[4]) !== 0) noteApprox('sampler MipLODBias', String(wf(words[4]).toFixed(2))); + // D3D11_SAMPLER_DESC: Filter, AddressU, AddressV, AddressW, MipLODBias, MaxAnisotropy, ComparisonFunc, BorderColor[4], MinLOD, MaxLOD + const filter = words[0], aniso = ((filter & 0x7f) === 0x55); + const d = { + addressModeU: ADDRESS[words[1]] || 'repeat', addressModeV: ADDRESS[words[2]] || 'repeat', addressModeW: ADDRESS[words[3]] || 'repeat', + magFilter: (filter >> 2) & 1 ? 'linear' : 'nearest', minFilter: (filter >> 4) & 1 ? 'linear' : 'nearest', + mipmapFilter: filter & 1 ? 'linear' : 'nearest', + lodMinClamp: Math.max(0, wf(words[11])), lodMaxClamp: Math.min(32, Math.max(0, wf(words[12]))), + }; + if (filter & 0x80) d.compare = CMP[words[6]] || 'always'; + if (aniso) { d.magFilter = d.minFilter = d.mipmapFilter = 'linear'; d.maxAnisotropy = Math.max(1, Math.min(16, words[5])); } + if (d.lodMaxClamp < d.lodMinClamp) d.lodMaxClamp = d.lodMinClamp; + return device.createSampler(d); +} +const wfBuf = new Float32Array(1), wuBuf = new Uint32Array(wfBuf.buffer); +function wf(w) { wuBuf[0] = w; return wfBuf[0]; } + +// ---- WGSL reflection (the translator emits plain declarations) ---------------------------------------------------------------- +const DECL = /@group\((\d+)u?\)\s*@binding\((\d+)u?\)\s*var(?:<([^>]*)>)?\s+(\w+)\s*:\s*([^;]+);/g; +function parseWgsl(text) { + const bindings = []; + for (const m of text.matchAll(DECL)) { + const group = +m[1], binding = +m[2], space = (m[3] || '').replace(/\s+/g, ''), type = m[5].trim(); + const b = { group, binding, name: m[4], type }; + if (space === 'uniform') b.kind = 'uniform'; + else if (space.startsWith('storage')) b.kind = space.includes('read_write') ? 'storage' : 'read-only-storage'; + else if (type === 'sampler') b.kind = 'sampler'; + else if (type === 'sampler_comparison') b.kind = 'sampler-comparison'; + else { + b.kind = 'texture'; + const t = /^texture_(\w+?)(?:<([^>]*)>)?$/.exec(type); + const name = t ? t[1] : '2d', arg = t && t[2] ? t[2] : 'f32'; + if (name.startsWith('storage_')) { b.kind = 'storage-texture'; b.dim = name.replace('storage_', ''); b.format = arg.split(',')[0].trim(); b.access = arg.includes('read_write') ? 'read-write' : (arg.includes('read') ? 'read-only' : 'write-only'); } + else if (name.startsWith('depth_')) { b.dim = name.replace('depth_', ''); b.sample = 'depth'; } + else if (name.startsWith('multisampled_')) { b.dim = '2d'; b.ms = true; b.sample = 'unfilterable-float'; } + else { b.dim = name; b.sample = arg === 'u32' ? 'uint' : arg === 'i32' ? 'sint' : 'float'; } + if (b.dim === 'depth_2d') b.dim = '2d'; + b.dim = ({ '2d': '2d', '2d_array': '2d-array', '3d': '3d', 'cube': 'cube', 'cube_array': 'cube-array', '1d': '1d' })[b.dim] || b.dim; + } + bindings.push(b); + } + // fragment outputs: locations of the return value of `fn main` + const outputs = []; + const sig = /@fragment\s*fn\s+main\s*\((?:[^()]|\([^)]*\))*\)\s*->\s*([^{]+)\{/.exec(text); // parameters contain @location(n) + if (sig) { + const r = sig[1]; + const inl = /@location\((\d+)u?\)/.exec(r); + if (inl) outputs.push(+inl[1]); + else { + const st = new RegExp('struct\\s+' + r.trim() + '\\s*\\{([^}]*)\\}').exec(text); + if (st) for (const m of st[1].matchAll(/@location\((\d+)u?\)/g)) outputs.push(+m[1]); + } + } + return { bindings, outputs }; +} + +const STAGE_VIS = { 0: 1 /*VERTEX*/, 1: 2 /*FRAGMENT*/, 2: 4 /*COMPUTE*/ }; +function layoutEntry(b, stage) { + const visibility = STAGE_VIS[stage]; + const e = { binding: b.binding, visibility }; + switch (b.kind) { + case 'uniform': e.buffer = { type: 'uniform', hasDynamicOffset: b.binding !== 15 }; break; // binding 0 = the packed constant buffers + case 'storage': e.buffer = { type: 'storage' }; break; + case 'read-only-storage': e.buffer = { type: 'read-only-storage' }; break; + case 'sampler': e.sampler = { type: 'filtering' }; break; + case 'sampler-comparison': e.sampler = { type: 'comparison' }; break; + case 'texture': e.texture = { sampleType: b.sample, viewDimension: b.dim, multisampled: !!b.ms }; break; + case 'storage-texture': e.storageTexture = { access: b.access, format: b.format, viewDimension: b.dim }; break; + } + return e; +} + +// D3D11 shaders use up to 7 constant buffers per stage, WebGPU allows 10 dynamic-offset uniform bindings per pipeline layout. +// Every stage's constant buffers (all the `var` except the special-constant table at binding 15) are therefore +// merged into ONE struct bound at binding 0 with one dynamic offset: `cbN_x` -> `cbpack_v.cbN_x`. The runtime copies the +// bound D3D constant buffers back to back into the uniform ring, in binding order, one 16-byte aligned block per member. +function packUniforms(text) { + const decl = /@group\((\d+)u?\)\s*@binding\((\d+)u?\)\s*var\s+(\w+)\s*:\s*(\w+)\s*;/g; + const members = []; + let group = 0; + let out = text.replace(decl, (m, g, b, name, type) => { + if (+b === 15) return m; + group = +g; + const st = new RegExp('struct\\s+' + type + '\\s*\\{([^}]*)\\}').exec(text); + const arr = st ? /array<[^>]*>,\s*(\d+)u?>/.exec(st[1]) : null; + members.push({ binding: +b, name, type, size: arr ? +arr[1] * 16 : 16, offset: 0 }); + return ''; + }); + if (!members.length) return { text, pack: null }; + members.sort((a, b) => a.binding - b.binding); + let off = 0; + for (const m of members) { m.offset = off; off += m.size; } + for (const m of members) out = out.replace(new RegExp('\\b' + m.name + '\\b', 'g'), 'cbpack_v.' + m.name); + const struct = 'struct cbpack_t {\n' + members.map((m) => ' ' + m.name + ' : ' + m.type + ',').join('\n') + '\n}\n@group(' + group + 'u) @binding(0u) var cbpack_v : cbpack_t;\n'; + // the struct must follow the member type definitions: insert before the first function / entry point + const at = out.search(/\n(?:@\w+|fn)\s/); + out = at < 0 ? out + struct : out.slice(0, at) + '\n' + struct + out.slice(at); + return { text: out, pack: { members, size: off, group } }; +} + +// ---- shaders ------------------------------------------------------------------------------------------------------------------ +let shaderIndex = null; // fnv1a64 hex -> { stage, effect, program, ok, consts } +let shaderDir = null; +let shaderUrl = './shaders'; // browser: base URL of the translated shaders (index.json, .wgsl, .consts.json) +function loadShaderIndex() { + if (shaderIndex) return; + shaderIndex = {}; + shaderDir = isNode ? (process.env.WGPU_SHADER_DIR || 'D:/wasm_build/web/shaders') : shaderUrl; + if (isNode) { + try { shaderIndex = JSON.parse(require('fs').readFileSync(shaderDir + '/index.json', 'utf8')); } + catch (e) { logLine('no shader index at ' + shaderDir + ': ' + e.message); } + } +} + +// Browser: fetch is asynchronous, so the sources of the shaders a draw/dispatch needs are awaited before it is executed. +// An overloaded host answers 503/500/429 (2026-10-06): a shader pack that came back as an error left every draw that needs it unshaded for good. Such an answer, or none, is retried up +// to 8 times with growing, jittered waits (~20 s in all). +async function fetchRetry(url, init) { + for (let attempt = 0; ; attempt++) { + let res = null, err = null; + try { res = await fetch(url, init); } catch (e) { err = e; } + if (res && res.status < 500 && res.status !== 429) return res; + if (attempt >= 7) { if (res) return res; throw err; } + await new Promise((r) => setTimeout(r, Math.min(5000, 300 * 2 ** attempt) * (0.5 + Math.random()))); + } +} +async function fetchText(url) { const r = await fetchRetry(url); return r.ok ? r.text() : null; } +// true when the shaders bound now need nothing fetched (always, once they have been seen): draws and dispatches then skip `await ensureShaderSources()`, which suspended the +// whole command loop for a microtask turn on every draw +function shaderSourcesReady() { + if (!shaderIndex) return false; + for (let i = 0; i < 3; i++) { const id = S.shader[i]; if (id) { const o = objs.get(id); if (o && o.fetched === undefined) return false; } } + return true; +} +// The index is loaded once (one promise shared by every fetch: shaderIndex is only set when it is complete). +let shaderIndexP = null; +function shaderIndexReady() { + return shaderIndexP || (shaderIndexP = (async () => { + let idx = {}; + try { idx = JSON.parse(await fetchText(shaderUrl + '/index.json')); } catch (e) { logLine('no shader index at ' + shaderUrl + ': ' + e.message); } + shaderDir = shaderUrl; + shaderIndex = idx; + })()); +} +// Shader packs (phase3/make_shader_pack.py): the translated shaders bundled into ~4 MB files grouped by effect (index.json: "p": [pack, offset, wgsl bytes, constants bytes]), so a +// browser makes ~20 requests instead of one or two per shader (~6,000 in a session, each a round trip: minutes against a distant host). A pack is dropped from memory 8 s after +// its last use (the engine creates a burst of shaders per effect; ~70 MB if all stayed); a shader asked for later refetches its pack, or falls back to its own files. +const packs = new Map(), fetchedByHash = new Map(); // pack number -> { p: Promise, last }; shader hash -> { text, consts } (shared by shader objects with the same hash) +let packDecoder = null, packSweep = 0; +function packBytes(k) { + let c = packs.get(k); + if (!c) { + c = { p: null, last: 0, done: false }; + c.p = fetchRetry(shaderUrl + '/' + (shaderIndex._packs && shaderIndex._packs[k] ? shaderIndex._packs[k].file : 'pack' + k + '.bin')).then((r) => (r.ok ? r.arrayBuffer() : null)).then((b) => (b ? new Uint8Array(b) : null)).catch(() => null).then((u8) => { c.done = true; c.last = performance.now(); return u8; }); + packs.set(k, c); + if (!packSweep) packSweep = setInterval(() => { const now = performance.now(); for (const [n, x] of packs) if (x.done && now - x.last > 8000) packs.delete(n); }, 4000); + } + c.last = performance.now(); + return c.p; +} +async function packShader(rec) { + const [k, off, wl, cl] = rec.p; + const u8 = await packBytes(k); + if (!u8 || u8.length < off + wl + cl) return null; + packs.get(k) && (packs.get(k).last = performance.now()); + const dec = packDecoder || (packDecoder = new TextDecoder()); + return { text: dec.decode(u8.subarray(off, off + wl)), consts: cl ? JSON.parse(dec.decode(u8.subarray(off + wl, off + wl + cl))) : null }; +} +// A shader's sources (WGSL, constant table); sh.fetched is set only when they are here (null: none). Started at most once per shader. +function fetchShaderSource(sh) { + if (!sh.fetchP) sh.fetchP = (async () => { + await shaderIndexReady(); + const rec = shaderIndex[sh.hash]; + let fetched = null; + if (rec && rec.ok) { + fetched = fetchedByHash.get(sh.hash) || null; + if (!fetched && rec.p && !(!isNode && new URLSearchParams(self.location.search).get('nopack') === '1')) { // ?nopack=1 (diagnostics): one request per shader file + try { fetched = await packShader(rec); } catch (e) { logOnce('packfail' + rec.p[0], 'shader pack ' + rec.p[0] + ' unusable (' + (e && e.message) + '): fetching shaders one by one'); } + } + if (!fetched) { + try { + const text = await fetchText(shaderDir + '/' + sh.hash + '.wgsl'); + let consts = null; + if (rec.consts) consts = JSON.parse(await fetchText(shaderDir + '/' + sh.hash + '.consts.json')); + fetched = { text, consts }; + } catch (e) { logOnce('shaderfetch' + sh.hash, 'shader ' + sh.hash + ' could not be fetched: ' + (e && e.message)); } + } + if (fetched) fetchedByHash.set(sh.hash, fetched); + } + sh.fetched = fetched; + shadersReady++; + })(); + return sh.fetchP; +} +// Prefetch: effects create their shaders long before the first draw that uses them, so the source is requested at creation (CREATE_SHADER) instead of by that draw, +// which suspended the command loop for a whole request per new shader (a network round trip each for remote players, hundreds in the first frames). At most +// SHADER_FETCHES are in flight; a draw that needs a shader not started yet starts it at once (ensureShaderSources). +const SHADER_FETCHES = 16, shaderQueue = []; +let shaderQueueHead = 0, shaderFetching = 0; +function pumpShaderQueue() { + while (shaderFetching < SHADER_FETCHES && shaderQueueHead < shaderQueue.length) { + const sh = shaderQueue[shaderQueueHead++]; + if (sh.fetchP) continue; + shaderFetching++; + fetchShaderSource(sh).finally(() => { shaderFetching--; pumpShaderQueue(); }); + } + if (shaderQueueHead === shaderQueue.length) { shaderQueue.length = 0; shaderQueueHead = 0; } +} +function prefetchShader(sh) { + if (isNode || sh.fetchP) return; + shaderQueue.push(sh); + pumpShaderQueue(); +} +async function ensureShaderSources() { + if (isNode) return; + if (!shaderIndex) await shaderIndexReady(); + for (const id of S.shader) { + const sh = id ? objs.get(id) : null; + if (!sh || sh.fetched !== undefined) continue; + await fetchShaderSource(sh); + } +} + +function a2cModule(prog) { + if (prog.a2c !== undefined) return prog.a2c; + prog.a2c = null; + const re = /(\n\s*main_inner\([^;]*\);)/; + if (re.test(prog.text)) { + try { prog.a2c = device.createShaderModule({ code: prog.text.replace(re, '$1\n if (o0.w < 0.5f) { discard; }') }); } catch (e) { logOnce('a2c' + prog.label, 'alpha-to-coverage variant of ' + prog.label + ' failed: ' + e.message); } + } else logOnce('a2c' + prog.label, 'alpha-to-coverage: no main_inner call to patch in ' + prog.label); + return prog.a2c; +} + +function shaderProgram(sh) { + // lazily load + compile the WGSL of a shader object; returns { module, info, consts } or null + if (sh.program !== undefined) return sh.program; + sh.program = null; + loadShaderIndex(); + const rec = shaderIndex[sh.hash]; + if (!rec || !rec.ok) { logOnce('noshader' + sh.hash, 'no WGSL for ' + STAGE_NAME[sh.stage] + ' shader ' + sh.hash + (rec ? ' (' + rec.effect + '::' + rec.program + ': ' + (rec.error || rec.stage_failed || 'untranslated') + ')' : ' (not in the index)')); return null; } + const fs = isNode ? require('fs') : null; + const source = isNode ? fs.readFileSync(shaderDir + '/' + sh.hash + '.wgsl', 'utf8') : (sh.fetched && sh.fetched.text); + if (!source) { logOnce('nosrc' + sh.hash, 'shader source of ' + sh.hash + ' was not fetched'); return null; } + const { text, pack } = packUniforms(source); + shaderModuleCount++; + const tm0 = performance.now(); + const module = device.createShaderModule({ code: text, label: rec.effect + '::' + rec.program }); + fr.mod += performance.now() - tm0; + const info = parseWgsl(text); + let consts = null; + if (rec.consts) { + const arr = isNode ? JSON.parse(fs.readFileSync(shaderDir + '/' + sh.hash + '.consts.json', 'utf8')) : sh.fetched.consts; + const n = Math.max(1, arr.length); + const data = new Uint32Array(n * 4); + arr.forEach((v, i) => { data[i * 4] = v >>> 0; }); + consts = device.createBuffer({ size: Math.max(16, data.byteLength), usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }); + device.queue.writeBuffer(consts, 0, data); + } + const flat = []; + for (const m of text.matchAll(/@location\((\d+)u?\)\s*@interpolate\(flat[^)]*\)/g)) flat.push(+m[1]); + const groupBindings = {}; + for (const b of info.bindings) (groupBindings[b.group] || (groupBindings[b.group] = [])).push(b); + for (const g in groupBindings) groupBindings[g].sort((a, b) => a.binding - b.binding); + // vid/iid: the shader reads vertex_index / instance_index (doDraw folds the draw's start into the buffer offsets only for those: 6 and 93 of ~4,800 shaders) + sh.program = { module, info, consts, pack, text, flat, groupBindings, variants: new Map(), bgls: [], label: rec.effect + '::' + rec.program, vid: /\bvertex_index\b/.test(text), iid: /\binstance_index\b/.test(text) }; + return sh.program; +} +const STAGE_NAME = ['vs', 'ps', 'cs']; + +async function initDevice(msg) { + if (isNode) { + const modPath = process.env.WGPU_NODE_MODULE || 'D:/wasm_build/shaders/node/node_modules/webgpu'; + const dawn = require(modPath); + Object.assign(globalThis, dawn.globals); + // FXC (the shader compiler of Dawn's D3D12 backend in this npm build; it has no DXC) rejects several translated compute kernels + // with X3694/X3695 "race condition" errors that come from its optimiser. emit_hlsl_debug_symbols compiles without optimisation + // (the driver still optimises). Chrome uses DXC where available, so this is a dev-loop workaround only. + gpu = dawn.create(process.env.WGPU_DAWN_FLAGS ? process.env.WGPU_DAWN_FLAGS.split(',') : ['enable-dawn-features=emit_hlsl_debug_symbols']); + } else { + gpu = self.navigator.gpu; + } + if (!gpu) throw new Error('no WebGPU'); + adapter = await gpu.requestAdapter({ powerPreference: 'high-performance' }); + if (!adapter) throw new Error('no WebGPU adapter'); + const want = ['texture-compression-bc', 'texture-compression-bc-sliced-3d', 'depth32float-stencil8', 'float32-filterable', 'indirect-first-instance', 'rg11b10ufloat-renderable', 'bgra8unorm-storage', 'depth-clip-control', 'clip-distances', 'texture-formats-tier1', 'dual-source-blending']; + const requiredFeatures = want.filter((f) => adapter.features.has(f)); + const limits = {}; + for (const k of ['maxBufferSize', 'maxStorageBufferBindingSize', 'maxUniformBufferBindingSize', 'maxTextureDimension2D', 'maxTextureArrayLayers', + 'maxColorAttachmentBytesPerSample', 'maxBindGroups', 'maxStorageBuffersPerShaderStage', 'maxSampledTexturesPerShaderStage', 'maxSamplersPerShaderStage', + 'maxStorageTexturesPerShaderStage', 'maxUniformBuffersPerShaderStage', 'maxVertexBuffers', 'maxVertexAttributes', 'maxBindingsPerBindGroup', + 'maxInterStageShaderVariables', 'maxDynamicUniformBuffersPerPipelineLayout', 'maxComputeInvocationsPerWorkgroup', 'maxComputeWorkgroupSizeX', 'maxComputeWorkgroupSizeY', 'maxComputeWorkgroupSizeZ', 'maxComputeWorkgroupStorageSize', 'maxComputeWorkgroupsPerDimension']) + if (adapter.limits[k] !== undefined) limits[k] = adapter.limits[k]; + // WGPU_LIMITS=name=value,... (Node, test aid): request a smaller device, e.g. a Chromebook's (maxInterStageShaderVariables=16) + if (isNode && process.env.WGPU_LIMITS) for (const kv of process.env.WGPU_LIMITS.split(',')) { const [k, v] = kv.split('='); limits[k] = +v; } + // ?limits=name:value,... (browser): the same, lowered to a weaker device's limits (never below the WebGPU defaults) + if (!isNode) for (const kv of (new URLSearchParams(self.location.search).get('limits') || '').split(',').filter(Boolean)) { const [k, v] = kv.split(':'); limits[k] = +v; } + device = await adapter.requestDevice({ requiredFeatures, requiredLimits: limits }); + device.addEventListener('uncapturederror', (ev) => { + errorCount++; + Atomics.add(i32, ringW + 4, 1); + const msg = ev.error.message; + const key = msg.replace(/0x[0-9a-f]+|\d+/g, 'N').slice(0, 200); + const e = errorKinds.get(key); + if (e) e.n++; + else { errorKinds.set(key, { n: 1, msg }); if (errorKinds.size <= 40) logLine('validation error: ' + msg.slice(0, 700)); } + }); + device.lost.then((info) => { + logLine('device lost: ' + info.reason + ' ' + info.message); + if (!isNode && info.reason !== 'destroyed') new BroadcastChannel('game-progress').postMessage({ gpuLost: info.message.split('\n')[0].slice(0, 160) }); + }); + logLine('limits: maxDynamicUniformBuffersPerPipelineLayout=' + device.limits.maxDynamicUniformBuffersPerPipelineLayout + ' maxBindGroups=' + device.limits.maxBindGroups + ' maxUniformBuffersPerShaderStage=' + device.limits.maxUniformBuffersPerShaderStage + ' maxVertexBuffers=' + device.limits.maxVertexBuffers + + ' maxInterStageShaderVariables=' + device.limits.maxInterStageShaderVariables + ' maxSampledTexturesPerShaderStage=' + device.limits.maxSampledTexturesPerShaderStage + ' maxColorAttachmentBytesPerSample=' + device.limits.maxColorAttachmentBytesPerSample); + logLine('device ready: ' + (adapter.info ? (adapter.info.description || adapter.info.vendor) : 'adapter') + ', features ' + requiredFeatures.join(',')); + if (msg.canvas) { + canvas = msg.canvas; + canvasCtx = canvas.getContext('webgpu'); + canvasFormat = gpu.getPreferredCanvasFormat(); + } +} + +// ---- objects ---------------------------------------------------------------------------------------------------------------- +// Rough GPU memory of a texture (all mips, all layers, samples), for the exit statistics: block-compressed formats by block size, others by texel size. +function textureBytes(desc) { + const f = desc.format; + let texel = 4; + const block = /^(bc1|bc4|etc2-rgb8|eac-r11)/.test(f) ? 8 : /^(bc|astc|etc2|eac)/.test(f) ? 16 : 0; + if (!block) texel = /r8|a8/.test(f) && !/rg8|rgba8|bgra8/.test(f) ? 1 : /rg8|r16|depth16/.test(f) ? 2 : /rgba16|rg32/.test(f) ? 8 : /rgba32/.test(f) ? 16 : 4; + let total = 0; + for (let m = 0; m < desc.mipLevelCount; m++) { + const mw = Math.max(1, desc.size.width >> m), mh = Math.max(1, desc.size.height >> m), md = desc.dimension === '3d' ? Math.max(1, desc.size.depthOrArrayLayers >> m) : desc.size.depthOrArrayLayers; + total += (block ? Math.ceil(mw / 4) * Math.ceil(mh / 4) * block : mw * mh * texel) * md; + } + return total * (desc.sampleCount || 1); +} +// Stutter diagnostics: what this worker spent time on since the last present; frames over SPIKE_MS are listed in the 10 s log line with the breakdown +const fr = { idle: 0, pipe: 0, mod: 0, up: 0, upBytes: 0, wait: 0, flush: 0 }; +const SPIKE_MS = 40; +let lastPresentT = 0, spikes = [], spikeCount = 0, frameMax = 0, over25 = 0; +let pipeMs = 0, pipeCreates = 0, pipeCreates0 = 0, busyMs = 0, idleMs = 0, shaderModuleCount = 0, fpsT0 = 0, fpsCount0 = 0, fpsDraw0 = 0; +let texBytesAlive = 0, texBytesPeak = 0, texCount = 0, bufBytesAlive = 0, bufBytesPeak = 0; + +function createTexture(id, dim, w, h, d, mips, arraySize, dxgi, bind, samples) { + const m = mapFormat(dxgi, bind); + let usage = GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST; + if (bind & BIND_SRV) usage |= GPUTextureUsage.TEXTURE_BINDING; + if (bind & (BIND_RT | BIND_DS)) usage |= GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING; + if (bind & BIND_UAV) usage |= GPUTextureUsage.STORAGE_BINDING; + if (!(bind & (BIND_SRV | BIND_RT | BIND_DS | BIND_UAV))) usage |= GPUTextureUsage.TEXTURE_BINDING; + const desc = { + size: { width: w, height: dim === 1 ? 1 : h, depthOrArrayLayers: dim === 3 ? d : arraySize }, + mipLevelCount: mips, sampleCount: samples, dimension: dim === 3 ? '3d' : (dim === 1 ? '1d' : '2d'), + format: m.format, usage, + }; + if (samples > 1) desc.usage &= ~(GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING); + if (m.views) desc.viewFormats = m.views.filter((v) => !v.startsWith('bc') || device.features.has('texture-compression-bc')); + const tex = device.createTexture(desc); + const bytes = textureBytes(desc); + texBytesAlive += bytes; texCount++; + if (texBytesAlive > texBytesPeak) texBytesPeak = texBytesAlive; + objs.set(id, { kind: 'texture', tex, desc, format: m.format, views: new Map(), a8: !!m.a8, bytes }); +} + +// Exit report: where the GPU-side memory of the mirror goes (diagnostics for the 4 GB target). +function dumpMemBreakdown() { + const bufs = [], byFmt = new Map(); + let nBuf = 0, shadow = 0; + for (const o of objs.values()) { + if (o.kind === 'buffer') { nBuf++; if (o.shadow) shadow += o.shadow.byteLength; if (o.gpu) bufs.push(o); } + else if (o.kind === 'texture' && o.bytes) { const k = o.desc.format + (o.desc.dimension === '3d' ? ' 3d' : '') + (o.desc.sampleCount > 1 ? ' msaa' : '') + ((o.desc.usage & GPUTextureUsage.RENDER_ATTACHMENT) ? ' rt' : ''); const e = byFmt.get(k) || [0, 0]; e[0] += o.bytes; e[1]++; byFmt.set(k, e); } + } + bufs.sort((a, b) => b.bytes - a.bytes); + logLine('mem: ' + nBuf + ' buffers (' + bufs.length + ' with GPU storage), constant-buffer shadows ' + (shadow / 1048576 | 0) + ' MB, pipelines ' + pipelineCount + ', uniform ring ' + (ubo.shared.length * FRAME_SLOTS * RING_CHUNK / 1048576 | 0) + ' MB, shader modules ' + shaderModuleCount); + logLine('mem: biggest buffers: ' + bufs.slice(0, 8).map((o) => (o.bytes / 1048576).toFixed(1) + 'MB bind=' + o.bind.toString(16) + (o.stride ? ' stride=' + o.stride : '')).join(' | ')); + logLine('mem: textures by format: ' + [...byFmt].sort((a, b) => b[1][0] - a[1][0]).slice(0, 10).map(([k, [b, n]]) => k + ' ' + (b / 1048576 | 0) + 'MB x' + n).join(' | ')); +} + +function createBuffer(id, size, bind, misc, stride) { + const o = { kind: 'buffer', uid: id, size, bind, misc, stride, gpu: null, shadow: null, version: 0 }; + if (bind & 4) { o.shadow = new Uint8Array(size); } // constant buffers live in this shadow and are copied to the uniform ring per draw + let usage = GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC; + if (bind & 1) usage |= GPUBufferUsage.VERTEX; + if (bind & 2) usage |= GPUBufferUsage.INDEX; + if (bind & (8 | 0x80)) usage |= GPUBufferUsage.STORAGE; + if (misc & 0x10) usage |= GPUBufferUsage.INDIRECT; // D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS + if ((bind & (1 | 2 | 8 | 0x80)) || (misc & 0x10)) { + o.bytes = Math.max(4, (size + 3) & ~3); // the GPU buffer's size (per-draw code reads this: GPUBuffer.size is a native getter, ~5 % of the worker read per draw) + o.gpu = device.createBuffer({ size: o.bytes, usage }); + bufBytesAlive += o.bytes; + if (bufBytesAlive > bufBytesPeak) bufBytesPeak = bufBytesAlive; + } + objs.set(id, o); +} + +function uploadBuffer(id, offset, size, dataOff, noOverwrite) { + const o = objs.get(id); + if (!o) return; + if (o.shadow) { o.shadow.set(u8.subarray(dataOff, dataOff + size), offset); o.version++; } + if (debugDraw && o.gpu && !o.shadow) { if (!o.dbg) o.dbg = new Uint8Array(o.size); o.dbg.set(u8.subarray(dataOff, dataOff + size), offset); } + if (o.gpu) { + if (!noOverwrite && usedInEncoder.has(o)) flush('buffer upload'); // a recorded draw still reads the old contents: D3D semantics need them (not after a no-overwrite map: the app promises those bytes are unused) + const n = size & ~3; + if (n) device.queue.writeBuffer(o.gpu, offset, u8, dataOff, n); + if (size & 3) { // tail bytes: merge into a padded 4-byte write + const tail = new Uint8Array(4); tail.set(u8.subarray(dataOff + n, dataOff + size)); + device.queue.writeBuffer(o.gpu, offset + n, tail); + } + } +} + +function uploadTexture(id, mip, slice, x, y, z, w, h, d, bytesPerRow, rowsPerImage, size, dataOff) { + const o = objs.get(id); + if (!o) return; + if (usedInEncoder.has(o)) flush('texture upload'); + markColorDirty(o); + if (debugDraw || debugPs) { o.uploads = (o.uploads || 0) + 1; o.lastUpload = 'mip' + mip + ' ' + w + 'x' + h + ' bpr' + bytesPerRow + ' first bytes ' + Array.from(u8.subarray(dataOff, dataOff + 8)).join(','); } // dumpDraw only: a string per upload otherwise + const three = o.desc.dimension === '3d'; + const origin = { x, y, z: three ? z : slice }; + let data = u8.subarray(dataOff, dataOff + size), bpr = bytesPerRow; + if (o.a8) { // expand one byte per texel to (0,0,0,a) + const out = new Uint8Array(w * h * 4); + for (let r = 0; r < h; r++) for (let c = 0; c < w; c++) out[(r * w + c) * 4 + 3] = data[r * bytesPerRow + c]; + data = out; bpr = w * 4; + } + device.queue.writeTexture({ texture: o.tex, mipLevel: mip, origin }, data, + { bytesPerRow: bpr, rowsPerImage }, { width: w, height: h, depthOrArrayLayers: d }); +} + +function createShader(p, n) { + const id = u32[p], stage = u32[p + 1], hash = u32[p + 3].toString(16).padStart(8, '0') + u32[p + 2].toString(16).padStart(8, '0'); + const nin = u32[p + 4]; + const sig = []; + for (let i = 0; i < nin; i++) sig.push({ sem: u32[p + 5 + i * 4], idx: u32[p + 6 + i * 4], reg: u32[p + 7 + i * 4], mask: u32[p + 8 + i * 4] }); + const o = { kind: 'shader', stage, hash, sig, program: undefined }; + objs.set(id, o); + shadersByHash.set(hash, o); + if (isNode) shadersReady++; // Node reads the sources from disk when needed + prefetchShader(o); +} + +function createLayout(p) { + // id, n, then n x [semHash, semIndex, dxgi, slot, offset, slotClass, stepRate] + const id = u32[p], n = u32[p + 1], els = []; + for (let i = 0; i < n; i++) { + const q = p + 2 + i * 7; + els.push({ sem: u32[q], idx: u32[q + 1], fmt: u32[q + 2], slot: u32[q + 3], offset: u32[q + 4], cls: u32[q + 5], rate: u32[q + 6] }); + } + objs.set(id, { kind: 'layout', els, slots: layoutSlots(els) }); +} +// each vertex buffer slot once, with the step class of its first element (per-draw loops walk this instead of de-duplicating els every time) +function layoutSlots(els) { + const slots = []; + let seen = 0; + for (const e of els) { if (e.slot < 32 && !((seen >>> e.slot) & 1)) { seen |= 1 << e.slot; slots.push({ slot: e.slot, cls: e.cls }); } } + return slots; +} + +function createState(p, n) { + const id = u32[p], kind = u32[p + 1], words = Array.from(u32.subarray(p + 2, p + n)); + const o = { kind: 'state', skind: kind, words }; + if (kind === 3) o.sampler = makeSampler(words); + objs.set(id, o); +} + +function createUav(p) { + // id, resKind(0 tex, 1 buf), resId, dxgi, viewDim, a, b, c, flags + objs.set(u32[p], { kind: 'uav', res: u32[p + 2], isBuf: u32[p + 1] === 1, fmt: u32[p + 3], vdim: u32[p + 4], a: u32[p + 5], b: u32[p + 6], c: u32[p + 7], flags: u32[p + 8], views: new Map() }); +} + +function createSrv(p) { + // id, resKind(0 tex, 1 buf), resId, dxgi, viewDim, a, b, c, d + objs.set(u32[p], { kind: 'srv', res: u32[p + 2], isBuf: u32[p + 1] === 1, fmt: u32[p + 3], vdim: u32[p + 4], a: u32[p + 5], b: u32[p + 6], c: u32[p + 7], d: u32[p + 8], views: new Map() }); +} + +// ---- pipeline state ----------------------------------------------------------------------------------------------------------- +const S = { + shader: [0, 0, 0], layout: 0, topo: 4, + vb: Array.from({ length: 16 }, () => ({ buf: 0, stride: 0, offset: 0 })), + ib: { buf: 0, fmt: 0, offset: 0 }, + cb: [0, 1, 2].map(() => Array.from({ length: 16 }, () => ({ buf: 0, first: 0, num: 0 }))), + srv: [0, 1, 2].map(() => new Array(128).fill(0)), + uav: [0, 1, 2].map(() => new Array(8).fill(0)), + smp: [0, 1, 2].map(() => new Array(16).fill(0)), + rt: Array.from({ length: 8 }, () => ({ tex: 0, mip: 0, slice: 0, fmt: 0 })), ds: { tex: 0, mip: 0, slice: 0, fmt: 0, flags: 0 }, + blend: { id: 0, factor: [1, 1, 1, 1], mask: 0xffffffff }, dss: { id: 0, ref: 0 }, rs: 0, + viewports: [], scissors: [], +}; +let applied = {}; +let pdirty = true, lastPl = null, lastPlPass = null; // pipeline memo: any command that changes the pipeline key sets pdirty + +function resetState() { + pdirty = true; + S.shader = [0, 0, 0]; S.layout = 0; S.topo = 4; + S.vb.forEach((v) => { v.buf = 0; v.stride = 0; v.offset = 0; }); + S.ib = { buf: 0, fmt: 0, offset: 0 }; + for (let s = 0; s < 3; s++) { S.cb[s].forEach((c) => { c.buf = 0; c.first = 0; c.num = 0; }); S.srv[s].fill(0); S.smp[s].fill(0); } + S.rt.forEach((r) => { r.tex = 0; r.mip = 0; r.slice = 0; r.fmt = 0; }); + S.ds = { tex: 0, mip: 0, slice: 0, fmt: 0, flags: 0 }; + rtKey = null; bindEpoch[0]++; bindEpoch[1]++; bindEpoch[2]++; gEpoch++; + S.blend = { id: 0, factor: [1, 1, 1, 1], mask: 0xffffffff }; S.dss = { id: 0, ref: 0 }; S.rs = 0; + S.viewports = []; S.scissors = []; + endPass(); +} + +function viewFormat(dxgi, tex) { return dxgi ? mapFormat(dxgi, 0).format : tex.format; } + +function targetView(t, dxgi, mip, slice, dimension) { + const fmt = viewFormat(dxgi, t); + const key = fmt + '|' + mip + '|' + slice; + let v = t.views.get(key); + if (!v) { + v = t.tex.createView({ format: fmt, baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: slice, arrayLayerCount: 1, dimension: t.desc.dimension === '3d' ? '3d' : '2d' }); + t.views.set(key, v); + } + return { view: v, format: fmt }; +} + +// ---- uniform ring: constant buffers are copied per draw (D3D11 semantics) and bound with dynamic offsets ---------------------------------- +const RING_CHUNK = 8 << 20, UBO_WINDOW = 65536; +// Frames in flight: the uniform ring has one slot per frame; before a slot is reused the GPU must be done with the frame that last used it. Chrome reports completion through the +// wire from the GPU process, so with 3 slots (2 frames in flight) the round trip, not the work, capped the frame rate. +const FRAME_SLOTS = (isNode ? +process.env.WGPU_SLOTS : +(new URLSearchParams(self.location.search).get('slots') || 0)) || 3; +// Chunk k of every frame slot is a RING_CHUNK region of one GPU buffer (`shared[k]`, FRAME_SLOTS regions): slot s's chunk object has the buffer, its id and base s * RING_CHUNK, and keeps +// its own mirror and dirty range. Bind groups name the buffer (and the id is part of their cache key), so one bind group serves every frame slot; with a buffer per slot and chunk each +// set of resources needed a bind group per frame in flight (three times the creations and the cache entries). Dynamic offsets are base + offset. +const ubo = { slots: Array.from({ length: FRAME_SLOTS }, () => []), shared: [], slot: 0, chunk: 0, off: 0, pending: Array(FRAME_SLOTS).fill(null), nextId: 1 }; +// returns the offset of `size` bytes in the current ring chunk (from the chunk's base), which it leaves in allocChunk (no result object: this runs for every pack) +let allocChunk = null; +function uniformAlloc(size) { + size = (size + 255) & ~255; + let list = ubo.slots[ubo.slot]; + let c = list[ubo.chunk]; + if (!c || ubo.off + size + UBO_WINDOW > RING_CHUNK) { + if (c) { ubo.chunk++; ubo.off = 0; c = list[ubo.chunk]; } + if (!c) { + const sh = ubo.shared[ubo.chunk] || (ubo.shared[ubo.chunk] = { buf: device.createBuffer({ size: RING_CHUNK * FRAME_SLOTS, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }), id: ubo.nextId++ }); + c = { buf: sh.buf, id: sh.id, base: ubo.slot * RING_CHUNK }; + list[ubo.chunk] = c; + } + } + const off = ubo.off; ubo.off += size; + allocChunk = c; + return off; +} +// The per-draw constant copies go into a JS mirror of the ring chunk and reach the GPU with one writeBuffer per chunk at the next flush (a queue.writeBuffer per draw was ~10 % +// of the worker's time at 1,700 draws per frame). Commands only execute at submit, which flush() does after these writes, so the order is the same. +const dirtyChunks = new Set(); +// marks [off, off + n) of the chunk's mirror as written and returns the mirror (grown if needed); the caller writes the bytes into it directly +function stageReserve(chunk, off, n) { + const end = off + n; + if (!chunk.stage || chunk.stage.length < end) { + const grown = new Uint8Array(Math.min(RING_CHUNK, Math.max(end, chunk.stage ? chunk.stage.length * 2 : 262144))); + if (chunk.stage) grown.set(chunk.stage.subarray(0, chunk.top)); + chunk.stage = grown; + chunk.top = chunk.top || 0; + } + if (end > (chunk.top || 0)) chunk.top = end; + if (chunk.lo === undefined || off < chunk.lo) chunk.lo = off; + if (end > (chunk.hi || 0)) chunk.hi = end; + dirtyChunks.add(chunk); + return chunk.stage; +} +function flushUniforms() { + for (const c of dirtyChunks) { + const hi = Math.min(c.stage.length, (c.hi + 3) & ~3); + device.queue.writeBuffer(c.buf, c.base + c.lo, c.stage, c.lo, hi - c.lo); + c.lo = undefined; c.hi = 0; + } + dirtyChunks.clear(); +} +const curObjs = [], curVers = [], curFirsts = []; // scratch: identity of the constant buffers a program's pack reads right now +function packCopy(prog, stage) { + const pack = prog.pack; + if (!pack) return null; + if (pack.size > UBO_WINDOW) { logOnce('packbig' + prog.label, prog.label + ': constant buffers total ' + pack.size + ' bytes (> 64 KB uniform binding limit)'); return null; } + const members = pack.members, n = members.length, cbs = S.cb[stage]; + for (let i = 0; i < n; i++) { + const c = cbs[members[i].binding], o = c.buf ? objs.get(c.buf) : null; + curObjs[i] = o; curVers[i] = o ? o.version : -1; curFirsts[i] = c.first; + } + // the same constants already packed this frame (by this program and stage): reuse that ring allocation. No string keys: the last few packs are compared member by member. + const ents = prog.packEnts || (prog.packEnts = [[], [], []]), list = ents[stage]; + for (let k = 0; k < list.length; k++) { + const en = list[k]; + if (en.frame !== ubo.frame) continue; + let same = true; + for (let i = 0; i < n; i++) if (en.objs[i] !== curObjs[i] || en.vers[i] !== curVers[i] || en.firsts[i] !== curFirsts[i]) { same = false; break; } + if (same) return en.alloc; + } + // members are contiguous (packUniforms): each is copied straight into the ring mirror, and only the part a constant buffer does not cover is zeroed (D3D reads zeros there) + const aOff = uniformAlloc(pack.size), aChunk = allocChunk; + const dst = stageReserve(aChunk, aOff, pack.size); + for (let i = 0; i < n; i++) { + const m = members[i], o = curObjs[i], at = aOff + m.offset; + let len = 0; + if (o && o.shadow) { + const from = curFirsts[i] * 16; + len = Math.min(m.size, o.size - from); + if (len > 0) { + // the whole shadow, or one cached view of it: a new subarray per member and draw was garbage + let src; + if (from === 0 && len === o.shadow.length) src = o.shadow; + else if (o.svFrom === from && o.svLen === len) src = o.sv; + else { src = o.sv = o.shadow.subarray(from, from + len); o.svFrom = from; o.svLen = len; } + dst.set(src, at); + } else len = 0; + } + if (len < m.size) dst.fill(0, at + len, at + m.size); + } + // the oldest entry of this (program, stage) is recycled in place: a pack per draw made ~6 short-lived objects each, which the garbage collector showed up for (~14 % of the worker) + let en; + if (list.length >= 6) { + en = list.shift(); + for (let i = 0; i < n; i++) { en.objs[i] = curObjs[i]; en.vers[i] = curVers[i]; en.firsts[i] = curFirsts[i]; } + en.alloc.chunk = aChunk; en.alloc.off = aOff; en.alloc.frame = ubo.frame; + } else en = { frame: 0, objs: curObjs.slice(0, n), vers: curVers.slice(0, n), firsts: curFirsts.slice(0, n), alloc: { chunk: aChunk, off: aOff, frame: ubo.frame } }; + en.frame = ubo.frame; + list.push(en); + return en.alloc; +} +ubo.frame = 0; + +// ---- dummies for unbound slots ------------------------------------------------------------------------------------------------------------ +const dummy = { tex: new Map(), smp: null, cmp: null, buf: null, uni: null }; +function dummyTexture(b) { + const key = b.dim + '|' + b.sample + '|' + (b.ms ? 'ms' : ''); + let v = dummy.tex.get(key); + if (v) return v; + const format = b.sample === 'uint' ? 'rgba8uint' : b.sample === 'sint' ? 'rgba8sint' : b.sample === 'depth' ? 'depth32float' : 'rgba8unorm'; + const layers = (b.dim === 'cube' || b.dim === 'cube-array') ? 6 * (b.dim === 'cube-array' ? 1 : 1) : 1; + const tex = device.createTexture({ size: { width: 1, height: b.dim === '1d' ? 1 : 1, depthOrArrayLayers: b.dim === '3d' ? 1 : layers }, + dimension: b.dim === '3d' ? '3d' : b.dim === '1d' ? '1d' : '2d', format, usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST, sampleCount: b.ms ? 4 : 1 }); + v = tex.createView({ dimension: b.dim }); + dummy.tex.set(key, v); + return v; +} +function dummySampler(cmp) { + if (cmp) return dummy.cmp || (dummy.cmp = device.createSampler({ compare: 'always' })); + return dummy.smp || (dummy.smp = device.createSampler({})); +} +// one per binding: writable storage buffers bound twice in a dispatch are an aliasing error +function dummyBuffer(binding) { + if (!dummy.bufs) dummy.bufs = new Map(); + let b = dummy.bufs.get(binding); + if (!b) { b = device.createBuffer({ size: 65536, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST }); dummy.bufs.set(binding, b); } + return b; +} + +function srvView(srv, b) { + // GPUTextureView of an SRV in the dimension the shader declares + let t = objs.get(srv.res); + if (!t || t.kind !== 'texture') return null; + let proxied = false; + if (isDepth(t.format) && b.sample !== 'depth') { + t = depthProxy(t, b.sample === 'uint' ? 'stencil' : 'depth'); + proxied = true; sawProxy = true; + } else if (!isDepth(t.format) && b.sample === 'depth') { + t = floatToDepthProxy(t); + proxied = true; sawProxy = true; + } + const key = b.dim + (proxied ? ':p' : ''); + let v = srv.views.get(key); + if (v && !proxied) return v; + if (v && proxied && !t.dirty && v.__proxyTex === t.tex) return v; + const total = t.desc.mipLevelCount; + const mipCount = srv.b === 0xffffffff || srv.b === 0 ? total - srv.a : srv.b; + const layers = t.desc.size.depthOrArrayLayers; + if ((b.dim === 'cube' && layers - srv.c < 6) || (b.dim === 'cube-array' && layers - srv.c < 6)) { + logOnce('cubeview' + srv.res, 'cube SRV over a texture with ' + layers + ' layer(s): bound as an empty cube'); + return null; // the caller binds a dummy cube: creating the view would invalidate the whole command buffer + } + const desc = { dimension: b.dim, baseMipLevel: Math.min(srv.a, total - 1), mipLevelCount: Math.max(1, Math.min(mipCount, total - srv.a)) }; + if (b.dim === '2d-array' || b.dim === 'cube' || b.dim === 'cube-array' || b.dim === '2d') { + const first = srv.c, cnt = (b.dim === 'cube') ? 6 : (b.dim === '2d' ? 1 : (srv.d || layers - first)); + desc.baseArrayLayer = Math.min(first, layers - 1); desc.arrayLayerCount = Math.max(1, Math.min(cnt, layers - first)); + } + const f = t.format; + if (srv.fmt && !isDepth(f)) { const mf = mapFormat(srv.fmt, 0).format; if (mf !== f && (f.includes('srgb') !== mf.includes('srgb'))) desc.format = mf; } + if (isDepth(f) && !proxied) desc.aspect = (srv.fmt === 47 || srv.fmt === 22) ? 'stencil-only' : 'depth-only'; + try { v = t.tex.createView(desc); } catch (e) { logOnce('srvview' + srv.res, 'SRV view failed: ' + e.message); return null; } + v.__proxyTex = t.tex; + srv.views.set(key, v); + return v; +} + +// ---- depth textures sampled as float ---------------------------------------------------------------------------------------------- +// D3D11 lets a shader read a depth texture as a float texture (Load / point Sample); WebGPU only binds it as `depth` +// (comparison or textureLoad of texture_depth_2d) and the translated code uses texture_2d. A proxy r32float (depth) or +// r8uint (stencil) texture is refreshed by a render pass whenever the depth texture was drawn into since the last read. +let proxyPipelines = {}; +function proxyPipeline(kind) { + if (proxyPipelines[kind]) return proxyPipelines[kind]; + const code = kind === 'depth' + ? `@group(0) @binding(0) var src: texture_depth_2d; + @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { var p = array(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3)); return vec4f(p[i], 0, 1); } + @fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f { return vec4f(textureLoad(src, vec2i(pos.xy), 0), 0, 0, 1); }` + : `@group(0) @binding(0) var src: texture_2d; + @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { var p = array(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3)); return vec4f(p[i], 0, 1); } + @fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4 { return textureLoad(src, vec2i(pos.xy), 0); }`; + const module = device.createShaderModule({ code }); + return (proxyPipelines[kind] = device.createRenderPipeline({ layout: 'auto', vertex: { module, entryPoint: 'vs' }, + fragment: { module, entryPoint: 'fs', targets: [{ format: kind === 'depth' ? 'r32float' : 'r8uint' }] } })); +} + +let f2dPipeline = null; +function floatToDepthProxy(t) { + // D3D11 SampleCmp works on any float texture; WebGPU comparison sampling needs a depth texture: keep a depth32float copy + let px = t.proxy_fdepth; + if (!px) { + const d = t.desc; + const tex = device.createTexture({ size: d.size, mipLevelCount: d.mipLevelCount, sampleCount: 1, dimension: '2d', format: 'depth32float', usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT }); + px = t.proxy_fdepth = { kind: 'texture', tex, desc: { size: d.size, mipLevelCount: d.mipLevelCount, dimension: '2d', sampleCount: 1 }, format: 'depth32float', views: new Map(), dirty: true }; + } + if (px.dirty) { + endPass(); + if (!f2dPipeline) { + const module = device.createShaderModule({ code: `@group(0) @binding(0) var src: texture_2d; + @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { var p = array(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3)); return vec4f(p[i], 0, 1); } + @fragment fn fs(@builtin(position) pos: vec4f) -> @builtin(frag_depth) f32 { return textureLoad(src, vec2i(pos.xy), 0).x; }` }); + f2dPipeline = device.createRenderPipeline({ layout: 'auto', vertex: { module, entryPoint: 'vs' }, fragment: { module, entryPoint: 'fs', targets: [] }, + depthStencil: { format: 'depth32float', depthWriteEnabled: true, depthCompare: 'always' } }); + } + const enc = getEncoder(), layers = t.desc.size.depthOrArrayLayers; + if (!px.passes) { // the views and bind groups of a refresh never change: made once (three new objects per mip and layer per refresh before) + px.passes = []; + for (let mip = 0; mip < t.desc.mipLevelCount; mip++) for (let layer = 0; layer < layers; layer++) { + const src = t.tex.createView({ dimension: '2d', baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: layer, arrayLayerCount: 1 }); + const dst = px.tex.createView({ baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: layer, arrayLayerCount: 1 }); + px.passes.push({ dst, bg: device.createBindGroup({ layout: f2dPipeline.getBindGroupLayout(0), entries: [{ binding: 0, resource: src }] }) }); + } + } + for (const r of px.passes) { + const p = enc.beginRenderPass({ colorAttachments: [], depthStencilAttachment: { view: r.dst, depthLoadOp: 'clear', depthStoreOp: 'store', depthClearValue: 1 } }); + p.setPipeline(f2dPipeline); + p.setBindGroup(0, r.bg); + p.draw(3); + p.end(); + } + usedInEncoder.add(t); + px.dirty = false; + } + return px; +} +function markColorDirty(t) { if (t && t.proxy_fdepth) t.proxy_fdepth.dirty = true; } + +function depthProxy(t, kind) { + // returns the proxy texture object of depth texture `t`, refreshed if the depth texture changed since the last refresh + const key = 'proxy_' + kind; + let px = t[key]; + if (!px) { + const d = t.desc; + const tex = device.createTexture({ size: d.size, mipLevelCount: d.mipLevelCount, sampleCount: 1, dimension: '2d', + format: kind === 'depth' ? 'r32float' : 'r8uint', usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT }); + px = t[key] = { kind: 'texture', tex, desc: { size: d.size, mipLevelCount: d.mipLevelCount, dimension: '2d', sampleCount: 1 }, format: tex.format, views: new Map(), dirty: true }; + } + if (px.dirty) { + endPass(); + const pl = proxyPipeline(kind), enc = getEncoder(); + const layers = t.desc.size.depthOrArrayLayers; + if (!px.passes) { // made once per proxy (see floatToDepthProxy) + px.passes = []; + for (let mip = 0; mip < t.desc.mipLevelCount; mip++) for (let layer = 0; layer < layers; layer++) { + const src = t.tex.createView({ dimension: '2d', baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: layer, arrayLayerCount: 1, aspect: kind === 'depth' ? 'depth-only' : 'stencil-only' }); + const dst = px.tex.createView({ baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: layer, arrayLayerCount: 1 }); + px.passes.push({ dst, bg: device.createBindGroup({ layout: pl.getBindGroupLayout(0), entries: [{ binding: 0, resource: src }] }) }); + } + } + for (const r of px.passes) { + const p = enc.beginRenderPass({ colorAttachments: [{ view: r.dst, loadOp: 'clear', storeOp: 'store' }] }); + p.setPipeline(pl); + p.setBindGroup(0, r.bg); + p.draw(3); + p.end(); + } + usedInEncoder.add(t); + px.dirty = false; + t['clean_' + kind] = true; + } + return px; +} + +function markDepthDirty(t) { t.proxy_depth && (t.proxy_depth.dirty = true); t.proxy_stencil && (t.proxy_stencil.dirty = true); } + +// ---- pipelines -------------------------------------------------------------------------------------------------------------------- +const layoutCache = new Map(); +// Pipelines are found by a tuple of small integers (shader hashes and pass formats interned) hashed to a number: building and hashing a string key took ~15 % of the worker, +// since the lookup runs whenever any pipeline state changed (most draws). Buckets hold [tuple, pipeline] pairs; null pipelines (creation failed) are cached too. +const pipelineBuckets = new Map(), pipeTuple = new Int32Array(64), internedHashes = new Map(), internedTails = new Map(); +let pipelineCount = 0; +function internHash(o) { + if (o.hid === undefined) { let h = internedHashes.get(o.hash); if (h === undefined) { h = internedHashes.size + 1; internedHashes.set(o.hash, h); } o.hid = h; } + return o.hid; +} +function bindGroupLayoutFor(prog, stage, group) { + const key = prog.label + '|' + stage; + let bgl = layoutCache.get(key); + if (!bgl) { + const entries = prog.info.bindings.filter((b) => b.group === group).map((b) => layoutEntry(b, stage)); + bgl = device.createBindGroupLayout({ entries }); + layoutCache.set(key, bgl); + } + return bgl; +} +const emptyBgl = () => emptyBgl.v || (emptyBgl.v = device.createBindGroupLayout({ entries: [] })); + +function depthStencilFor(dss, dsFormat, roDepth, roStencil) { + if (!dsFormat) return undefined; + const w = dss ? dss.words : null; + const stencilOn = dsFormat.includes('stencil'); + const d = { format: dsFormat, depthWriteEnabled: false, depthCompare: 'always' }; + if (w) { + if (w[0]) { d.depthWriteEnabled = w[1] === 1; d.depthCompare = CMP[w[2]] || 'less'; } + if (stencilOn && w[3]) { + d.stencilReadMask = w[4] & 0xff; d.stencilWriteMask = (w[4] >> 8) & 0xff; + d.stencilFront = { failOp: STENCIL_OP[w[5]], depthFailOp: STENCIL_OP[w[6]], passOp: STENCIL_OP[w[7]], compare: CMP[w[8]] }; + d.stencilBack = { failOp: STENCIL_OP[w[9]], depthFailOp: STENCIL_OP[w[10]], passOp: STENCIL_OP[w[11]], compare: CMP[w[12]] }; + } + } + if (roDepth) d.depthWriteEnabled = false; + if (roStencil && d.stencilFront) { d.stencilWriteMask = 0; } + return d; +} + +function blendFor(state, rtIndex) { + if (!state) return { write: 0xf }; + const w = state.words; // D3D11_BLEND_DESC: AlphaToCoverage, Independent, RT[8] x 8 words {enable, src, dst, op, srcA, dstA, opA, mask} + const rt = w[1] ? rtIndex : 0, q = 2 + rt * 8; + const out = { write: w[q + 7] & 0xf }; + if (w[q]) { + out.blend = { + color: { srcFactor: BLEND_FACTOR[w[q + 1]] || 'one', dstFactor: BLEND_FACTOR[w[q + 2]] || 'zero', operation: BLEND_OP[w[q + 3]] || 'add' }, + alpha: { srcFactor: BLEND_FACTOR[w[q + 4]] || 'one', dstFactor: BLEND_FACTOR[w[q + 5]] || 'zero', operation: BLEND_OP[w[q + 6]] || 'add' }, + }; + } + return out; +} + +function vertexFormatBytes(f) { + if (f.includes('10-10-10-2')) return 4; + const m = /(\d+)(?:x(\d))?$/.exec(f); + return m ? (m[1] / 8) * (+m[2] || 1) : 4; +} +const vbAvail = new Array(16).fill(0); // bytes from the bound offset to the end of the buffer, per vertex slot, for the current draw + +function vertexBuffersFor(vs, layout, strides) { + // D3D input layout elements matched to the vertex shader's input signature by semantic + const bySlot = new Map(), attrs = []; + const sigByKey = new Map(); + for (const s of vs.sig) sigByKey.set(s.sem + ':' + s.idx, s); + for (const e of layout.els) { + const s = sigByKey.get(e.sem + ':' + e.idx); + if (!s) continue; // element the shader does not read + const f = vertexFormat(e.fmt); + if (!f) { logOnce('vf' + e.fmt, 'unsupported vertex format DXGI ' + e.fmt); continue; } + let list = bySlot.get(e.slot); + if (!list) { list = { attributes: [], step: e.cls === 1 ? 'instance' : 'vertex' }; bySlot.set(e.slot, list); } + list.attributes.push({ shaderLocation: s.reg, offset: e.offset, format: f[0] }); + } + const buffers = []; + for (const [slot, l] of bySlot) { + while (buffers.length < slot) buffers.push(null); + buffers[slot] = { arrayStride: strides[slot], stepMode: l.step, attributes: l.attributes }; + } + return buffers; +} + +// WebGPU requires the interpolation of a varying to match between the stages; HLSL only declares `nointerpolation` on the +// pixel shader input. The vertex shader gets a variant with those outputs flat (and, with `remap`, its outputs moved: interStageRemap). +function vertexModule(vsProg, flat, remap) { + if (!flat.length && !remap) return vsProg.module; + const key = flat.join(',') + (remap ? '|' + remap.key : ''); + let m = vsProg.variants.get(key); + if (!m) { + let text = vsProg.text.replace(/@location\((\d+)u\)(\s*\n\s*\w+\s*:)/g, (all, loc, rest) => flat.includes(+loc) ? '@location(' + loc + 'u) @interpolate(flat)' + rest : all); + if (remap) { text = remapLocations(text, 'vs', remap.map); remapVariants[0]++; } + const tm0 = performance.now(); + m = device.createShaderModule({ code: text, label: vsProg.label + ' [flat ' + key + ']' }); + fr.mod += performance.now() - tm0; + vsProg.variants.set(key, m); + } + return m; +} +// WebGPU requires every inter-stage location to be below maxInterStageShaderVariables, and Dawn's Vulkan backend charges the clip distances against it (a Chromebook's +// Intel GPU: 16, so locations up to 14 next to clip distances). The translation keeps the D3D register as the location, so vertex shaders that write o15 next to +// SV_ClipDistance (cables, particles, clouds, the _DOF variants, vehicle parts) failed there with "location (15) that is too large", although they have only a few +// outputs. For such a pair, the outputs at or above the limit move to free low locations, in the vertex shader's output struct and in the pixel shader's inputs. +// null: nothing to move (always on GPUs with higher limits) or no room. +function interStageRemap(vsProg, psProg) { + const max = (isNode && process.env.WGPU_INTERSTAGE_MAX ? +process.env.WGPU_INTERSTAGE_MAX : device.limits.maxInterStageShaderVariables) || 16; // WGPU_INTERSTAGE_MAX (Node, test aid): remap below a lower limit + const lim = /@builtin\(clip_distances\)/.test(vsProg.text) ? max - 1 : max; + const outs = vsProg.outLocs || (vsProg.outLocs = locationsIn(vsProg.text, 'vs')); + if (!outs.some((l) => l >= lim)) return null; + const ins = psProg ? (psProg.inLocs || (psProg.inLocs = locationsIn(psProg.text, 'ps'))) : []; + const used = new Set(outs.concat(ins).filter((l) => l < lim)), map = new Map(); + let free = 0; + for (const l of outs) { + if (l < lim) continue; + while (used.has(free)) free++; + if (free >= lim) { logOnce('remap' + vsProg.label, vsProg.label + ': ' + outs.length + ' vertex outputs do not fit below location ' + lim); return null; } + map.set(l, free); used.add(free); + } + return { map, key: [...map].map(([a, b]) => a + '>' + b).join(','), ps: ins.some((l) => map.has(l)) }; +} +const remapVariants = [0, 0]; // vertex / pixel shader variants made for interStageRemap (in the "world shown" line) +// The vertex shader's outputs are the struct its main() returns; the pixel shader's inputs are main()'s parameters (the parameter lists contain `@location(Nu)`, so they +// are matched lazily up to ") ->"). +const VS_MAIN = /@vertex\s*fn\s+main\s*\([\s\S]*?\)\s*->\s*(\w+)\s*\{/, PS_MAIN = /(@fragment\s*fn\s+main\s*\()([\s\S]*?)(\)\s*->)/; +function vsOutputStruct(text) { + const m = VS_MAIN.exec(text); + return m ? new RegExp('(struct\\s+' + m[1] + '\\s*\\{)([^}]*)(\\})') : null; +} +function locationsIn(text, stage) { + let body = ''; + if (stage === 'vs') { const re = vsOutputStruct(text), m = re && re.exec(text); body = m ? m[2] : ''; } + else { const m = PS_MAIN.exec(text); body = m ? m[2] : ''; } + return [...body.matchAll(/@location\((\d+)u?\)/g)].map((x) => +x[1]); +} +function remapLocations(text, stage, map) { + const swap = (s) => s.replace(/@location\((\d+)(u?)\)/g, (all, n, u) => map.has(+n) ? '@location(' + map.get(+n) + u + ')' : all); + const re = stage === 'vs' ? vsOutputStruct(text) : PS_MAIN; + return re ? text.replace(re, (all, a, body, c) => a + swap(body) + c) : text; +} +// the pixel shader module for a pipeline: its alpha-to-coverage variant and/or the inputs moved by interStageRemap +function pixelModule(psProg, a2c, remap) { + if (!remap || !remap.ps) return a2c ? (a2cModule(psProg) || psProg.module) : psProg.module; + const key = 'remap|' + remap.key + (a2c ? '|a2c' : ''); + let m = psProg.variants.get(key); + if (!m) { + let text = psProg.text; + if (a2c) text = text.replace(/(\n\s*main_inner\([^;]*\);)/, '$1\n if (o0.w < 0.5f) { discard; }'); + text = remapLocations(text, 'ps', remap.map); remapVariants[1]++; + m = device.createShaderModule({ code: text, label: psProg.label + ' [' + key + ']' }); + psProg.variants.set(key, m); + } + return m; +} + +function getPipeline(vsObj, psObj, vsProg, psProg, layout, rtInfo, dsFormat) { + const passInfoNow = passInfo; + const topo = TOPOLOGY[S.topo] || TOPOLOGY[4]; + const stripFmt = topo[1] && S.ib.buf ? (S.ib.fmt === 57 ? 'uint16' : 'uint32') : undefined; + // key: only what the pipeline depends on, built without intermediate arrays (this runs whenever any pipeline state changed, i.e. for most draws) + const T = pipeTuple; + let n = 0; + T[n++] = internHash(vsObj); T[n++] = psObj ? internHash(psObj) : 0; T[n++] = S.layout; + const lslots = layout.slots; + for (let k = 0; k < lslots.length; k++) { + const v = S.vb[lslots[k].slot], o = v.buf ? objs.get(v.buf) : null; + T[n++] = o && o.gpu ? v.stride : 0; + } + if (!passInfoNow.tailId) { + const tail = rtInfo.map((r) => r ? r.format : '-').join(',') + '|' + (dsFormat || '-') + '|' + rtInfo.samples + '|' + (passInfoNow.roDepth ? 'rd' : '') + (passInfoNow.roStencil ? 'rs' : ''); + let id = internedTails.get(tail); + if (id === undefined) { id = internedTails.size + 1; internedTails.set(tail, id); } + passInfoNow.tailId = id; + } + T[n++] = S.topo; T[n++] = stripFmt === 'uint16' ? 1 : stripFmt ? 2 : 0; T[n++] = S.blend.id; T[n++] = S.dss.id; T[n++] = S.rs; T[n++] = passInfoNow.tailId; + let h = n * 0x9e3779b1; + for (let i = 0; i < n; i++) { h = Math.imul(h ^ T[i], 0x85ebca6b); h ^= h >>> 13; } + h &= 0x3fffffff; // a small integer (Smi): a full 32-bit key would be a heap number, allocated and hashed as a double on every lookup + let bucket = pipelineBuckets.get(h); + if (bucket) { + for (let b = 0; b < bucket.length; b += 2) { + const t = bucket[b]; + if (t.length !== n) continue; + let i = 0; + while (i < n && t[i] === T[i]) i++; + if (i === n) return bucket[b + 1]; + } + } else pipelineBuckets.set(h, bucket = []); + // not seen with these state objects: by content (an identical pipeline made for other state objects, or compiled ahead from a recipe: no draw is skipped for it) + const strides = S.vb.map((v) => (v.buf && objs.get(v.buf) && objs.get(v.buf).gpu) ? v.stride : 0); + const blendState = S.blend.id ? objs.get(S.blend.id) : null; + const dss = S.dss.id ? objs.get(S.dss.id) : null; + const rs = S.rs ? objs.get(S.rs) : null; + const rc = pipelineRecipe(vsObj, psObj, layout, strides, S.topo, stripFmt, blendState, dss, rs, rtInfo, dsFormat, passInfoNow.roDepth, passInfoNow.roStencil); + const key = recipeKey(rc); + let c = contentPipelines.get(key); + if (c) { + if (c.ahead) { c.ahead = false; aheadUsed++; } + if (c.p !== undefined) { bucket.push(T.slice(0, n), c.p); return c.p; } + bucket.push(T.slice(0, n), PIPELINE_PENDING); + c.waiters.push(bucket, bucket.length - 1); + return PIPELINE_PENDING; + } + recordRecipe(rc, key); + const { desc, vbReq } = pipelineDescFor(vsObj, psObj, vsProg, psProg, layout, strides, S.topo, stripFmt, blendState, dss, rs, rtInfo, dsFormat, passInfoNow.roDepth, passInfoNow.roStencil); + contentPipelines.set(key, c = { p: undefined, waiters: [], ahead: false }); + pipeCreates++; + if (asyncPipelines) { + // Compiled off the GPU process's command thread: a synchronous createRenderPipeline makes everything submitted after it wait for the shader compile (tens of ms per + // pipeline, hundreds of new pipelines when a new area streams in: the hitches). Draws needing it are skipped until it is ready (a new object appears a frame or two later). + bucket.push(T.slice(0, n), PIPELINE_PENDING); + c.waiters.push(bucket, bucket.length - 1); + compileAsync(c, desc, vbReq); + return PIPELINE_PENDING; + } + const pl = compileSync(c, desc, vbReq); + bucket.push(T.slice(0, n), pl); + return pl; +} +// The render pipeline for these shaders and states (shared by draws and the compile-ahead queue): { desc, vbReq }. +function pipelineDescFor(vsObj, psObj, vsProg, psProg, layout, strides, topoIdx, stripFmt, blendState, dss, rs, rtInfo, dsFormat, roDepth, roStencil) { + const bgl0 = vsProg.info.bindings.some((b) => b.group === 0) ? bindGroupLayoutFor(vsProg, 0, 0) : emptyBgl(); + const bgl1 = psProg ? (psProg.info.bindings.some((b) => b.group === 1) ? bindGroupLayoutFor(psProg, 1, 1) : emptyBgl()) : emptyBgl(); + const dynCount = (vsProg.info.bindings.filter((b) => b.kind === 'uniform' && b.binding !== 15 && b.group === 0).length) + (psProg ? psProg.info.bindings.filter((b) => b.kind === 'uniform' && b.binding !== 15 && b.group === 1).length : 0); + if (dynCount > (device.limits.maxDynamicUniformBuffersPerPipelineLayout || 8)) logOnce('dyn' + vsProg.label + psProg, 'pipeline ' + vsProg.label + ' + ' + (psProg ? psProg.label : '-') + ' needs ' + dynCount + ' dynamic uniform buffers (limit ' + device.limits.maxDynamicUniformBuffersPerPipelineLayout + ')'); + const remap = interStageRemap(vsProg, psProg); // null unless a vertex output is at or above the device's inter-stage limit + const desc = { + layout: device.createPipelineLayout({ bindGroupLayouts: [bgl0, bgl1] }), + vertex: { module: vertexModule(vsProg, psProg ? psProg.flat : [], remap), entryPoint: 'main', buffers: vertexBuffersFor(vsObj, layout, strides) }, + primitive: { topology: (TOPOLOGY[topoIdx] || TOPOLOGY[4])[0] }, + label: vsProg.label + ' + ' + (psProg ? psProg.label : '-'), + }; + if (stripFmt) desc.primitive.stripIndexFormat = stripFmt; + if (rs) { + const w = rs.words; // FillMode, CullMode, FrontCCW, DepthBias, DepthBiasClamp, SlopeScaledDepthBias, DepthClip, Scissor, MS, AA line + if (w[0] === 2) noteApprox('wireframe fill', desc.label); + if (w[6] === 0) noteApprox('DepthClipEnable=false', desc.label); + desc.primitive.cullMode = w[1] === 2 ? 'front' : w[1] === 3 ? 'back' : 'none'; + desc.primitive.frontFace = w[2] ? 'ccw' : 'cw'; + } else { desc.primitive.cullMode = 'back'; desc.primitive.frontFace = 'cw'; } + const ds = depthStencilFor(dss, dsFormat, roDepth, roStencil); + if (ds) { + if (rs) { ds.depthBias = rs.words[3] | 0; ds.depthBiasSlopeScale = wf(rs.words[5]); ds.depthBiasClamp = wf(rs.words[4]); } + desc.depthStencil = ds; + } + if (psProg) { + // the targets must match the pass attachments slot by slot; slots the shader does not write get a zero write mask + const targets = []; + for (let i = 0; i < rtInfo.length; i++) { + const r = rtInfo[i]; + if (!r) { targets.push(null); continue; } + if (!psProg.info.outputs.includes(i)) { targets.push({ format: r.format, writeMask: 0 }); continue; } + const b = blendFor(blendState, i); + targets.push({ format: r.format, writeMask: b.write, ...(b.blend ? { blend: b.blend } : {}) }); + } + const missing = psProg.info.outputs.filter((l) => !rtInfo[l]); + if (missing.length) logOnce('psout' + psProg.label, psProg.label + ' writes colour output(s) ' + missing.join(',') + ' with no render target bound'); + // D3D11 alpha-to-coverage on a single-sample target turns the alpha of target 0 into a coverage of 0 or 1 (alpha >= 0.5): the foliage (grass) shaders + // rely on it instead of clip(). WebGPU only honours the flag with MSAA, so the module gets an explicit alpha test. + const a2c = !!(blendState && blendState.words[0]) && rtInfo.samples <= 1 && psProg.info.outputs.includes(0); + desc.fragment = { module: pixelModule(psProg, a2c, remap), entryPoint: 'main', targets }; + } else if (rtInfo.length) { + desc.fragment = undefined; + } + if (blendState && blendState.words[0] && rtInfo.samples <= 1) noteApprox('alpha-to-coverage without MSAA', desc.label); + if (blendState) for (let rt = 0; rt < 8; rt++) { const q = 2 + rt * 8; if (blendState.words[q] && [1, 2, 4, 5, 6].some((o) => [16, 17, 18, 19].includes(blendState.words[q + o]))) noteApprox('dual-source blend', desc.label); } + if (rtInfo.samples > 1) desc.multisample = { count: rtInfo.samples, alphaToCoverageEnabled: !!(blendState && blendState.words[0]) }; + // what each vertex buffer slot must hold for n elements: (n - 1) * stride + last (doDraw clamps the counts to it) + const vbReq = []; + desc.vertex.buffers.forEach((b, slot) => { if (b) vbReq.push({ slot, instance: b.stepMode === 'instance', stride: b.arrayStride, last: b.attributes.reduce((m, a) => Math.max(m, a.offset + vertexFormatBytes(a.format)), 0) }); }); + return { desc, vbReq }; +} +function compileSync(c, desc, vbReq) { + let pl; + try { + const pt0 = performance.now(); + pl = device.createRenderPipeline(desc); + pipeMs += performance.now() - pt0; fr.pipe += performance.now() - pt0; + pl.vbReq = vbReq; + } catch (e) { + logLine('pipeline failed (' + desc.label + '): ' + e.message); + pl = null; + } + pipelineCount++; + c.p = pl; + return pl; +} +function compileAsync(c, desc, vbReq, onDone) { + pipelinesPending++; + const settle = (p) => { + c.p = p; + for (let i = 0; i < c.waiters.length; i += 2) c.waiters[i][c.waiters[i + 1]] = p; + c.waiters = null; + pipelinesPending--; pipelineCount++; + if (onDone) onDone(); + }; + device.createRenderPipelineAsync(desc).then((p) => { p.vbReq = vbReq; settle(p); }, (e) => { logLine('pipeline failed (' + desc.label + '): ' + (e && e.message)); settle(null); }); +} +// Browser: pipelines compile asynchronously (?syncpipelines=1: synchronously, as Node does by default for deterministic headless runs and screenshots; WGPU_ASYNC_PIPELINES=1 +// makes Node compile them asynchronously too, to measure the draws skipped meanwhile) +const asyncPipelines = isNode ? !!process.env.WGPU_ASYNC_PIPELINES : !new URLSearchParams(self.location.search).get('syncpipelines') && typeof GPUDevice !== 'undefined' && !!GPUDevice.prototype.createRenderPipelineAsync; +const PIPELINE_PENDING = { pending: true }; +let pipelinesPending = 0, pendingSkips = 0, pendingSkips0 = 0; + +// ---- pipelines by content, compiled ahead ------------------------------------------------------------------------------------------- +// A draw that needs a pipeline nobody compiled yet is skipped until its asynchronous compile finishes. On a slow GPU process (a 4-core Chromebook: ~250 pipelines for +// the first view of the world took seconds, 28,000 draws skipped in one second) that shows as holes (white) in the picture. So every pipeline is also known by its +// recipe: shader hashes, input layout, strides, topology, the blend/depth/raster state words, target formats; recipes seen are kept per browser (IndexedDB, no +// network) and, as a seed, in /shaders/pipelines.json (Node recordings, phase3/pipeline_seed.py). While the game loads, the recipes whose shaders have arrived are +// compiled ahead, a few at a time; a draw whose pipeline has the same recipe then uses it at once. +const contentPipelines = new Map(); // recipeKey -> { p: GPURenderPipeline | null (failed) | undefined (compiling), waiters: [bucket, index, ...], ahead: compiled ahead and not used yet } +const shadersByHash = new Map(); // DXBC hash -> shader object (createShader) +let shadersReady = 0; // shader objects whose sources are here (browser: fetched): unready recipes are retried when this grows +let aheadMade = 0, aheadUsed = 0, aheadInFlight = 0; +let aheadList = [], aheadPos = 0, aheadLater = [], aheadReadyAtPass = -1; +const AHEAD_MAX = isNode ? 1 : Math.max(2, Math.min(8, (self.navigator.hardwareConcurrency || 4) - 1)); // compiles in flight at once (the GPU process compiles them on its threads) +function pipelineRecipe(vsObj, psObj, layout, strides, topoIdx, stripFmt, blendState, dss, rs, rtInfo, dsFormat, roDepth, roStencil) { + return { + vs: vsObj.hash, ps: psObj ? psObj.hash : '', + el: layout.els.map((e) => [e.sem, e.idx, e.fmt, e.slot, e.offset, e.cls, e.rate]), st: layout.slots.map((s) => strides[s.slot] || 0), + tp: topoIdx, sf: stripFmt || '', b: blendState ? blendState.words : null, d: dss ? dss.words : null, r: rs ? rs.words : null, + rt: rtInfo.map((x) => x ? x.format : null), n: rtInfo.samples, ds: dsFormat || '', ro: (roDepth ? 1 : 0) | (roStencil ? 2 : 0), + }; +} +function recipeKey(rc) { + return JSON.stringify([rc.vs, rc.ps, rc.el, rc.st, rc.tp, rc.sf, rc.b, rc.d, rc.r, rc.rt, rc.n, rc.ds, rc.ro]); +} +// 'done' (compiling, compiled or not compilable) or 'later' (a shader is not here yet) +function compileAhead(rc, key) { + if (contentPipelines.has(key)) return 'done'; + const vsObj = shadersByHash.get(rc.vs), psObj = rc.ps ? shadersByHash.get(rc.ps) : null; + if (!vsObj || (rc.ps && !psObj)) return 'later'; + if (!isNode && (vsObj.fetched === undefined || (psObj && psObj.fetched === undefined))) return 'later'; // shaderProgram must not run before the fetch: it would cache a failure + const vsProg = shaderProgram(vsObj), psProg = psObj ? shaderProgram(psObj) : null; + if (!vsProg || (psObj && !psProg)) return 'done'; + const els = rc.el.map(([sem, idx, fmt, slot, offset, cls, rate]) => ({ sem, idx, fmt, slot, offset, cls, rate })); + const layout = { kind: 'layout', els, slots: layoutSlots(els) }; + const strides = new Array(16).fill(0); + layout.slots.forEach((s, i) => { strides[s.slot] = rc.st[i] || 0; }); + const rtInfo = rc.rt.map((f) => f ? { format: f } : null); + rtInfo.samples = rc.n; + const { desc, vbReq } = pipelineDescFor(vsObj, psObj, vsProg, psProg, layout, strides, rc.tp, rc.sf || undefined, rc.b ? { words: rc.b } : null, rc.d ? { words: rc.d } : null, rc.r ? { words: rc.r } : null, + rtInfo, rc.ds || null, (rc.ro & 1) !== 0, (rc.ro & 2) !== 0); + const c = { p: undefined, waiters: [], ahead: true }; + contentPipelines.set(key, c); + aheadMade++; + if (asyncPipelines) { aheadInFlight++; compileAsync(c, desc, vbReq, () => { aheadInFlight--; }); } + else compileSync(c, desc, vbReq); + return 'done'; +} +// Runs while the worker is idle and at every present: at most ~3 ms per call; a pass over the list ends when it is empty or the unready ones wait for new shaders. +function aheadStep() { + if (aheadPos >= aheadList.length && !aheadLater.length) return; + const t0 = performance.now(); + while (aheadInFlight < AHEAD_MAX && performance.now() - t0 < 3) { + if (aheadPos >= aheadList.length) { + if (!aheadLater.length || aheadReadyAtPass === shadersReady) break; + aheadReadyAtPass = shadersReady; aheadList = aheadLater; aheadLater = []; aheadPos = 0; + } + const it = aheadList[aheadPos++]; + if (compileAhead(it[0], it[1]) === 'later') aheadLater.push(it); + } +} +// Recipes: this browser's (IndexedDB 'gta-pipelines', newest session's new ones appended, at most RECIPES_MAX) first, then the seed's. Node: WGPU_PIPELINE_SEED= +// (a seed file) and WGPU_RECORD_PIPELINES= (appends every new recipe of the run, for pipeline_seed.py). +const RECIPES_MAX = 6000; +let recipesKnown = new Set(), recipesNew = [], recipesSaved = 0, recipesSaveT = 0; +function recordRecipe(rc, key) { + if (recipesKnown.has(key)) return; + recipesKnown.add(key); + if (isNode) { if (process.env.WGPU_RECORD_PIPELINES) require('fs').appendFileSync(process.env.WGPU_RECORD_PIPELINES, JSON.stringify(rc) + '\n'); return; } + recipesNew.push(rc); +} +function idbOpen() { + return new Promise((res, rej) => { const r = indexedDB.open('gta-pipelines', 1); r.onupgradeneeded = () => r.result.createObjectStore('recipes'); r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error); }); +} +async function idbList(db) { + return new Promise((res) => { const r = db.transaction('recipes').objectStore('recipes').get('list'); r.onsuccess = () => res(Array.isArray(r.result) ? r.result : []); r.onerror = () => res([]); }); +} +async function loadRecipes() { + let local = [], seed = []; + if (isNode) { + if (process.env.WGPU_PIPELINE_SEED) seed = JSON.parse(require('fs').readFileSync(process.env.WGPU_PIPELINE_SEED, 'utf8')); + } else { + try { local = await idbList(await idbOpen()); } catch (e) { logLine('pipeline recipes: no IndexedDB (' + (e && e.message) + ')'); } + try { const r = await fetch(shaderUrl + (new URLSearchParams(self.location.search).get('low') === '1' ? '/pipelines_low.json' : '/pipelines.json')); if (r.ok) seed = await r.json(); } catch (e) { /* no seed */ } // the page's low-memory profile has its own (no shadow pipelines) + } + for (const rc of local.concat(seed)) { + const key = recipeKey(rc); + if (recipesKnown.has(key)) continue; + recipesKnown.add(key); + aheadList.push([rc, key]); + } + recipesSaved = local.length; + logLine('pipeline recipes: ' + local.length + ' from this browser, ' + seed.length + ' in the seed, ' + aheadList.length + ' to compile ahead (' + AHEAD_MAX + ' at a time)'); +} +// The new recipes of this session go to IndexedDB every 20 s (a tab can be closed at any time). +async function saveRecipes() { + if (isNode || !recipesNew.length) return; + const add = recipesNew.splice(0); + try { + const db = await idbOpen(); + const list = (await idbList(db)).concat(add); + if (list.length > RECIPES_MAX) list.splice(0, list.length - RECIPES_MAX); + await new Promise((res, rej) => { const t = db.transaction('recipes', 'readwrite'); t.objectStore('recipes').put(list, 'list'); t.oncomplete = res; t.onerror = () => rej(t.error); }); + recipesSaved = list.length; + } catch (e) { logOnce('idbsave', 'pipeline recipes not saved: ' + (e && e.message)); } +} + +// ---- render pass + draw ----------------------------------------------------------------------------------------------------------- +let rtKey = null; // the render-target part of the pass key: rebuilt only after SET_RENDER_TARGETS / a state reset +function ensurePass() { + const key = rtKey || (rtKey = S.rt.map((r) => r.tex + ':' + r.mip + ':' + r.slice + ':' + r.fmt).join(',') + '/' + S.ds.tex + ':' + S.ds.mip + ':' + S.ds.slice + ':' + S.ds.fmt + ':' + S.ds.flags); + if (pass && key === passKey) return true; + endPass(); + const colorAttachments = [], rtInfo = []; + let samples = 1, any = false, passW = 1, passH = 1; + for (let i = 0; i < 8; i++) { + const r = S.rt[i]; + const t = r.tex ? objs.get(r.tex) : null; + if (!t) { colorAttachments.push(null); rtInfo.push(null); continue; } + const v = targetView(t, r.fmt, r.mip, r.slice); + colorAttachments.push({ view: v.view, loadOp: 'load', storeOp: 'store' }); + markColorDirty(t); + rtInfo.push({ format: v.format }); + samples = t.desc.sampleCount; any = true; passW = Math.max(1, t.desc.size.width >> r.mip); passH = Math.max(1, t.desc.size.height >> r.mip); + usedInEncoder.add(t); + } + while (colorAttachments.length && colorAttachments[colorAttachments.length - 1] === null) { colorAttachments.pop(); rtInfo.pop(); } + const desc = { colorAttachments }; + if (occlusion.set) desc.occlusionQuerySet = occlusion.set; + let dsFormat = null; + const dt = S.ds.tex ? objs.get(S.ds.tex) : null; + if (dt) { + const v = targetView(dt, 0, S.ds.mip, S.ds.slice); + const att = { view: v.view }; + const roDepth = (S.ds.flags & 1) !== 0, roStencil = (S.ds.flags & 2) !== 0; + if (roDepth) att.depthReadOnly = true; else { att.depthLoadOp = 'load'; att.depthStoreOp = 'store'; } + if (hasStencil(dt.format)) { if (roStencil) att.stencilReadOnly = true; else { att.stencilLoadOp = 'load'; att.stencilStoreOp = 'store'; } } + if (!roDepth && !roStencil) markDepthDirty(dt); + desc.depthStencilAttachment = att; dsFormat = dt.format; samples = dt.desc.sampleCount; any = true; + if (!S.rt.some((r) => r.tex)) { passW = Math.max(1, dt.desc.size.width >> S.ds.mip); passH = Math.max(1, dt.desc.size.height >> S.ds.mip); } + usedInEncoder.add(dt); + } + if (!any) return false; + rtInfo.samples = samples; + passKey = key; + pdirty = true; + pass = getEncoder().beginRenderPass(desc); + beginOcclusionInPass(); + passInfo = { rtInfo, dsFormat, colorCount: colorAttachments.length, roDepth: !!dt && (S.ds.flags & 1) !== 0, roStencil: !!dt && (S.ds.flags & 2) !== 0, width: passW, height: passH }; + applied = {}; + passSt = newPassSt(); + return true; +} +let passInfo = null; + +// refresh depth-as-float proxies before the render pass starts (a refresh is a pass of its own) +function prepareDepthProxies(prog, stage) { + const texs = prog.texBindings || (prog.texBindings = prog.info.bindings.filter((b) => b.kind === 'texture')); + if (!texs.length) return; + // Most draws bind no depth texture: once a scan found none, skip it until this stage's bindings or the set of resources change (a proxy that exists must be refreshed every time) + const dp = prog.dpScan || (prog.dpScan = [{ none: false, e: -1, g: -1 }, { none: false, e: -1, g: -1 }, { none: false, e: -1, g: -1 }]), sc = dp[stage]; + if (sc.none && sc.e === bindEpoch[stage] && sc.g === gEpoch) return; + let any = false; + for (let i = 0; i < texs.length; i++) { + const b = texs[i]; + const id = S.srv[stage][b.binding - 32], srv = id ? objs.get(id) : null; + const t = srv && !srv.isBuf ? objs.get(srv.res) : null; + if (t && t.kind === 'texture' && isDepth(t.format) && b.sample !== 'depth') { any = true; depthProxy(t, b.sample === 'uint' ? 'stencil' : 'depth'); } + else if (t && t.kind === 'texture' && !isDepth(t.format) && b.sample === 'depth') { any = true; floatToDepthProxy(t); } + } + sc.none = !any; sc.e = bindEpoch[stage]; sc.g = gEpoch; +} + +// Bind-group fast path: the result of stageBindGroup for a (program, stage) is reused while nothing it depends on changed. bindEpoch[stage] counts binding ops of that stage, gEpoch +// counts destructions of textures/buffers that some bind group referenced (bgUse marks them `inBG`), constant buffers are compared by version, and the ring frame must be the same (the +// packed constants live in it). Creations do not count: ids are never reused and an object's CREATE op precedes every op that binds it, so nothing a cached result references can +// change by a later creation (counting them made streaming, which creates and destroys objects all the time, invalidate every program's fast path). +const bindEpoch = [0, 0, 0]; +let gEpoch = 0, sawProxy = false; +let zeroVb = null; +const ZERO_VB_SIZE = 4096; +function zeroVertexBuffer() { return zeroVb || (zeroVb = device.createBuffer({ size: ZERO_VB_SIZE, usage: GPUBufferUsage.VERTEX })); } + +function replayBG(e) { + for (let i = 0; i < e.used.length; i++) e.used[i].enc = encEpoch; + for (let i = 0; i < e.dirty.length; i++) markColorDirty(e.dirty[i]); +} +// The ids a program's bind group for `group` is built from, as (slot kind, index) pairs: 0/1 constant buffer id/first constant of a pack member, 2 sampler, 3 SRV, 4 UAV. Equal ids +// give an equal bind group (objects never change under an id; destroyed ones bump gEpoch), so an entry whose stage epoch moved on (any binding op of the stage, by any program, +// invalidated it: a third of all lookups) is revalidated by comparing these few ids instead of rebuilding. +function idSources(prog, group) { + const src = [], bs = prog.groupBindings[group] || []; + if (prog.pack && bs.some((b) => b.kind === 'uniform' && b.binding !== 15)) for (const m of prog.pack.members) src.push(0, m.binding, 1, m.binding); + for (const b of bs) { + if (b.kind === 'sampler' || b.kind === 'sampler-comparison') src.push(2, b.binding - 16); + else if (b.kind === 'texture') src.push(3, b.binding - 32); + else if (b.kind === 'read-only-storage' || b.kind === 'storage') { if (b.binding >= 160) src.push(4, b.binding - (b.binding >= 176 ? 176 : 160)); else src.push(3, b.binding - 32); } + else if (b.kind === 'storage-texture') src.push(4, b.binding - 160); + } + return src; +} +function boundId(stage, k, x) { return k === 0 ? S.cb[stage][x].buf : k === 1 ? S.cb[stage][x].first : k === 2 ? S.smp[stage][x] : k === 3 ? S.srv[stage][x] : S.uav[stage][x]; } +function readIds(stage, src) { const out = new Array(src.length >> 1); for (let i = 0; i < src.length; i += 2) out[i >> 1] = boundId(stage, src[i], src[i + 1]); return out; } +function sameIds(stage, src, ids) { for (let i = 0; i < src.length; i += 2) if (boundId(stage, src[i], src[i + 1]) !== ids[i >> 1]) return false; return true; } +function stageBG(stage, prog, group) { + const e = prog.fast && prog.fast[stage]; + const src = (prog.idSrc || (prog.idSrc = []))[group] || (prog.idSrc[group] = idSources(prog, group)); + if (e && !e.noFast && e.gEpoch === gEpoch && (e.epoch === bindEpoch[stage] || (sameIds(stage, src, e.ids) && (e.epoch = bindEpoch[stage], true)))) { + // A result is tied to a frame only by its dynamic constant offset, which points into the ring slot of the frame that packed it. + if (e.frame === ubo.frame || !e.result.dyn.length) { + let ok = true; + for (let i = 0; i < e.objs.length; i++) { const o = e.objs[i]; if (o && o.version !== e.vers[i]) { ok = false; break; } } + if (ok) { replayBG(e); return e.result; } + } + // constants changed, or a new frame: the bind group is the same while the new constants land in the same ring chunk (the chunk is bound whole, the offset is dynamic, and + // chunk k of every frame slot is the same buffer) + if (e.chunkId) { + const a = packCopy(prog, stage); + if (a && a.chunk.id === e.chunkId) { + for (let i = 0; i < e.objs.length; i++) { const o = e.objs[i]; e.vers[i] = o ? o.version : -1; } + e.result.dyn[0] = a.chunk.base + a.off; // the same result object and offsets array (doDraw compares offsets by value, not identity) + e.frame = ubo.frame; + replayBG(e); + return e.result; + } + } + } + const epoch = bindEpoch[stage], g = gEpoch; + sawProxy = false; + const result = stageBindGroup(stage, prog, group, prog.bgls[group] || (prog.bgls[group] = bindGroupLayoutFor(prog, group, group))); + if (!prog.fast) { prog.fast = []; progsWithFast.add(prog); } + if (result && prog.pack && result.dyn.length === 1) { + const a = packCopy(prog, stage); // (a hit: the slow path just packed it) for the chunk the bind group was created with + const objsList = [], vers = []; + for (const m of prog.pack.members) { const c = S.cb[stage][m.binding], o = c.buf ? objs.get(c.buf) : null; objsList.push(o); vers.push(o ? o.version : -1); } + prog.fast[stage] = { epoch, gEpoch: g, frame: ubo.frame, objs: objsList, vers, result, noFast: sawProxy, chunkId: a ? a.chunk.id : 0, used: bgUsed.slice(), dirty: bgDirty.slice(), ids: readIds(stage, src) }; + } else if (result && prog.pack) { + const objsList = [], vers = []; + for (const m of prog.pack.members) { const c = S.cb[stage][m.binding], o = c.buf ? objs.get(c.buf) : null; objsList.push(o); vers.push(o ? o.version : -1); } + prog.fast[stage] = { epoch, gEpoch: g, frame: ubo.frame, objs: objsList, vers, result, noFast: sawProxy, chunkId: 0, used: bgUsed.slice(), dirty: bgDirty.slice(), ids: readIds(stage, src) }; + } else if (result) prog.fast[stage] = { epoch, gEpoch: g, frame: ubo.frame, objs: [], vers: [], result, noFast: sawProxy, chunkId: 0, used: bgUsed.slice(), dirty: bgDirty.slice(), ids: readIds(stage, src) }; + else prog.fast[stage] = null; + return result; +} + +// Bindings of the group being built, in flat scratch arrays: binding number, resource (sampler / texture view / GPUBuffer), buffer offset (-1: not a buffer binding) and size +// (-1: to the end). The GPUBindGroupEntry objects are only built when the cache misses; most calls hit and built them for nothing. +const sbB = [], sbR = [], sbO = [], sbS = []; +let sbN = 0; +function ent(binding, res, off, size) { sbB[sbN] = binding; sbR[sbN] = res; sbO[sbN] = off; sbS[sbN] = size; sbN++; } +function buildEntries() { + const entries = new Array(sbN); + for (let i = 0; i < sbN; i++) { + const off = sbO[i]; + entries[i] = { binding: sbB[i], resource: off < 0 ? sbR[i] : sbS[i] >= 0 ? { buffer: sbR[i], offset: off, size: sbS[i] } : off ? { buffer: sbR[i], offset: off } : { buffer: sbR[i] } }; + } + return entries; +} +function noteSamplerApprox(st, prog, slot) { + // once per sampler object (the approximated-features report; checked on every bind group build before) + if (st.approxSeen) return; + st.approxSeen = true; + const w = st.words; + if (w[1] === 4 || w[2] === 4 || w[3] === 4) noteApprox('border sampler bound by', prog.label + ' s' + slot); + if (wf(w[4]) !== 0) noteApprox('MipLODBias sampler bound by', prog.label + ' s' + slot + ' bias ' + wf(w[4]).toFixed(2)); +} +function stageBindGroup(stage, prog, group, bgl) { + // resources of one stage; returns { bg, dyn } or null + const dyn = []; + sbN = 0; + bgUsed.length = 0; bgDirty.length = 0; + const bindings = prog.groupBindings[group] || []; + // cache key: the layout, the program (its bindings and its constant table) and the stage, then the resource ids of the bindings in order + bgKeyN = 0; + bgKey[bgKeyN++] = bgl.__uid || (bgl.__uid = nextUid++); + bgKey[bgKeyN++] = prog.uid || (prog.uid = nextUid++); + bgKey[bgKeyN++] = stage; + for (let bi = 0; bi < bindings.length; bi++) { + const b = bindings[bi]; + if (b.kind === 'uniform') { + if (b.binding === 15) { + if (!prog.consts) { logOnce('c15' + prog.label, 'shader ' + prog.label + ' declares binding 15 but has no constant table'); return null; } + ent(15, prog.consts, 0, -1); + continue; + } + const a = packCopy(prog, stage); + if (!a) return null; + ent(0, a.chunk.buf, 0, prog.pack.size); + dyn.push(a.chunk.base + a.off); + bgKey[bgKeyN++] = a.chunk.id; + } else if (b.kind === 'sampler' || b.kind === 'sampler-comparison') { + const sid = S.smp[stage][b.binding - 16], st = sid ? objs.get(sid) : null; + const cmp = b.kind === 'sampler-comparison'; + if (st && st.words) noteSamplerApprox(st, prog, b.binding - 16); + ent(b.binding, st && st.sampler && !!(st.words[0] & 0x80) === cmp ? st.sampler : dummySampler(cmp), -1, -1); + bgKey[bgKeyN++] = st ? sid : 0; + } else if (b.kind === 'texture') { + const id = S.srv[stage][b.binding - 32]; + const srv = id ? objs.get(id) : null; + let v = null; + if (srv && !srv.isBuf) { v = srvView(srv, b); if (v) bgUse(objs.get(srv.res)); } + ent(b.binding, v || dummyTexture(b), -1, -1); + bgKey[bgKeyN++] = v ? id : 0; + } else if (b.kind === 'read-only-storage' || b.kind === 'storage') { + const isCounter = b.binding >= 176, isUav = b.binding >= 160; + const id = isUav ? S.uav[stage][b.binding - (isCounter ? 176 : 160)] : S.srv[stage][b.binding - 32]; + const view = id ? objs.get(id) : null; + const buf = view && view.isBuf ? objs.get(view.res) : null; + const gb = isCounter ? (buf ? counterBuffer(buf) : dummyBuffer(b.binding)) : (buf && buf.gpu ? buf.gpu : dummyBuffer(b.binding)); + let resOff = 0, resSize = -1; + if (buf && buf.gpu && !isCounter) { + const stride = buf.stride || 4, first = view.a, num = view.b; + const off = first * stride; + if (off && off % 256 === 0) { resOff = off; if (num && num !== 0xffffffff) resSize = Math.min(num * stride, buf.bytes - off); } + else if (off) logOnce('bufoff' + prog.label, prog.label + ': buffer view offset ' + off + ' is not 256-aligned; binding the whole buffer'); + } + ent(b.binding, gb, resOff, resSize); + if (buf) bgUse(buf); + bgKey[bgKeyN++] = buf ? id : 0; + bgKey[bgKeyN++] = resOff; + } else if (b.kind === 'storage-texture') { + const uav = S.uav[stage][b.binding - 160] ? objs.get(S.uav[stage][b.binding - 160]) : null; + const t = uav && !uav.isBuf ? objs.get(uav.res) : null; + if (!t) { logOnce('nouavtex' + prog.label, prog.label + ': storage texture u' + (b.binding - 160) + ' has no UAV bound'); return null; } + const key2 = b.dim + ':' + t.format; + let v = uav.views.get(key2); + if (!v) { + const d = { dimension: b.dim, baseMipLevel: uav.a, mipLevelCount: 1 }; + if (b.dim === '2d-array') { d.baseArrayLayer = uav.vdim === 5 ? uav.b : 0; d.arrayLayerCount = uav.vdim === 5 ? uav.c : t.desc.size.depthOrArrayLayers; } + else if (b.dim === '2d') d.baseArrayLayer = uav.vdim === 5 ? uav.b : 0; + try { v = t.tex.createView(d); } catch (e) { logOnce('uavview' + prog.label, 'UAV view failed: ' + e.message); return null; } + uav.views.set(key2, v); + } + ent(b.binding, v, -1, -1); + bgUse(t); markColorDirty(t); bgDirty.push(t); + bgKey[bgKeyN++] = S.uav[stage][b.binding - 160]; + } else { + logOnce('bk' + b.kind, 'unsupported binding kind ' + b.kind); + return null; + } + } + let h = 0x811c9dc5 | 0; + for (let i = 0; i < bgKeyN; i++) h = Math.imul(h ^ bgKey[i], 16777619); + h &= 0x3fffffff; + const head = bindGroupCache.get(h); + let e = head; + for (; e; e = e.next) { + const k = e.k; + if (k.length !== bgKeyN) continue; + let i = 0; + while (i < bgKeyN && k[i] === bgKey[i]) i++; + if (i === bgKeyN) break; + } + if (!e) { + e = { k: bgKey.slice(0, bgKeyN), bg: device.createBindGroup({ layout: bgl, entries: buildEntries() }), next: head || null }; + bgCreated++; + bindGroupCache.set(h, e); + trimBindGroups(); + } + return { bg: e.bg, dyn }; +} +// Side effects of building a bind group that must also happen when stageBG reuses it: the bound resources are in use by this encoder (an upload to them must flush first) +// and UAV textures were written (their depth proxies go stale). stageBindGroup collects them here, stageBG keeps a copy with the cached result and replays it. +const bgUsed = [], bgDirty = []; +function bgUse(o) { if (o) { usedInEncoder.add(o); bgUsed.push(o); o.inBG = true; } } +// Bind groups by a 30-bit hash of their numeric key (stageBindGroup), each bucket a chain of { k: key, bg, next }. The string keys this replaced (built by concatenation and +// hashed on every lookup) were ~40 % of stageBindGroup, which runs for every draw whose program's previous bindings changed. +const bindGroupCache = new Map(); +const bgKey = []; +let bgKeyN = 0, nextUid = 1; +let bgCreated = 0, bgCreated0 = 0, bgEvicted = 0; +// Every cached bind group holds Direct3D descriptors (and references to the views/textures in it) until the JS object is collected. Keys contain resource ids, which are never reused, +// so an entry whose texture was destroyed (streaming does this constantly) is dead weight that would otherwise live forever: in a long session that exhausted the descriptor heaps +// (`CreateDescriptorHeap failed with E_OUTOFMEMORY`, device lost, black screen). Keep the newest BG_LIMIT; older ones are rebuilt on demand (cheap). +const BG_LIMIT = 24000; +function trimBindGroups() { + if (bindGroupCache.size <= BG_LIMIT * 1.5) return; + let drop = bindGroupCache.size - BG_LIMIT; + for (const k of bindGroupCache.keys()) { bindGroupCache.delete(k); bgEvicted++; if (--drop <= 0) break; } + for (const prog of progsWithFast) prog.fast = null; // the fast path holds bind groups too +} +const progsWithFast = new Set(); + +// Draw isolation (page ?dbg=1): the page writes a draw limit N into the input block; only the first N draws of every frame run, and the pipeline of the +// last one that ran is reported back, so a user can find which draw paints an artifact. -1 = off. +let dbgIdx = 0, dbgFrameDraw = 0, dbgLastLabel = '', dbgChannel = null, dbgLastPost = 0; +const skipReasons = new Map(); +// D3D11 features the mirror approximates or ignores: what is used (by pipeline label / sampler), counted for the exit report +const approx = new Map(); +function noteApprox(feature, detail) { const k = feature + ': ' + detail; approx.set(k, (approx.get(k) || 0) + 1); } +function skipDraw(why) { skippedDraws++; skipReasons.set(why, (skipReasons.get(why) || 0) + 1); } + +// Dynamic offsets through the typed-array overload (spec: dynamicOffsetsData, start, length): Chrome converts a JS array argument to a new sequence on every call. Browser only: +// the Node binding is not known to implement that overload. +const dynOffsets = new Uint32Array(8); +function setBG(enc, index, g) { + const n = g.dyn.length; + if (!n) enc.setBindGroup(index, g.bg); + else if (isNode) enc.setBindGroup(index, g.bg, g.dyn); + else { for (let i = 0; i < n; i++) dynOffsets[i] = g.dyn[i]; enc.setBindGroup(index, g.bg, dynOffsets, 0, n); } +} +function isBound(id) { + if (S.layout === id || S.blend.id === id || S.dss.id === id || S.rs === id || S.ib.buf === id || S.shader[0] === id || S.shader[1] === id || S.shader[2] === id) return true; + for (let i = 0; i < S.vb.length; i++) if (S.vb[i].buf === id) return true; + return false; +} +function setScissorOnce(x, y, w, h) { + const o = passSt.sc; + if (o && o[0] === x && o[1] === y && o[2] === w && o[3] === h) return; + pass.setScissorRect(x, y, w, h); + const sc = passSt.sc || (passSt.sc = [0, 0, 0, 0]); sc[0] = x; sc[1] = y; sc[2] = w; sc[3] = h; +} + +function doDraw(p) { + // kind (0 draw, 1 indexed, 2 instanced, 3 indexed instanced), a..: vertexCount/indexCount, instanceCount, start, baseVertex, startInstance + let dbgLimit = -1; + if (dbgIdx) { + dbgLimit = Atomics.load(i32, dbgIdx); + if (dbgLimit >= 0 && dbgFrameDraw >= dbgLimit) { dbgFrameDraw++; return; } + dbgFrameDraw++; + } + const kind = u32[p], count = u32[p + 1], inst = u32[p + 2], start = u32[p + 3], baseVertex = u32[p + 4] | 0, startInstance = u32[p + 5]; + const vsObj = S.shader[0] ? objs.get(S.shader[0]) : null; + if (!vsObj) { skipDraw('if (!vsObj) { skippedDraws++; return; }'); return; } + const psObj = S.shader[1] ? objs.get(S.shader[1]) : null; + const layout = S.layout ? objs.get(S.layout) : null; + if (!layout) { skipDraw('if (!layout) { skippedDraws++; return; }'); return; } + const vsProg = shaderProgram(vsObj); + const psProg = psObj ? shaderProgram(psObj) : null; + if (!vsProg || (psObj && !psProg)) { skipDraw('if (!vsProg || (psObj && !psProg)) { skippedDraws++; return;'); return; } + prepareDepthProxies(vsProg, 0); + if (psProg) prepareDepthProxies(psProg, 1); + if (!ensurePass()) { skipDraw('if (!ensurePass()) { skippedDraws++; return; }'); return; } + let pl; + if (!pdirty && lastPl && lastPlPass === passInfo) pl = lastPl; + else { + pl = getPipeline(vsObj, psObj, vsProg, psProg, layout, passInfo.rtInfo, passInfo.dsFormat); + if (pl === PIPELINE_PENDING) { pendingSkips++; skippedDraws++; return; } // still compiling: looked up again by the next draw (pdirty stays set) + lastPl = pl; lastPlPass = passInfo; pdirty = false; + } + if (!pl) { skipDraw('if (!pl) { skippedDraws++; return; }'); return; } + if (passSt.pl !== pl) { pass.setPipeline(pl); passSt.pl = pl; } + if (dbgIdx && dbgLimit >= 0 && dbgFrameDraw === dbgLimit) { + const t0 = passInfo.rtInfo && passInfo.rtInfo[0]; + dbgLastLabel = '#' + (dbgFrameDraw - 1) + ' ' + (pl.label || '?') + ' target ' + (t0 ? t0.format : 'depth only') + ' ' + passInfo.width + 'x' + passInfo.height + ' n=' + count + (inst > 1 ? ' x' + inst : ''); + } + // bind groups + const g0 = vsProg.groupBindings[0] ? stageBG(0, vsProg, 0) : null; + const g1 = psProg && psProg.groupBindings[1] ? stageBG(1, psProg, 1) : null; + if (vsProg.groupBindings[0] && !g0) { skipDraw('if (vsProg.groupBindings[0] && !g0) { skippedDraws++; return'); return; } + if (psProg && psProg.groupBindings[1] && !g1) { skipDraw('if (psProg && psProg.groupBindings[1] && !g1) { skippedDraws'); return; } + if (g0) { const d = g0.dyn.length ? g0.dyn[0] : -1; if (passSt.bg0 !== g0.bg || passSt.dyn0 !== d) { setBG(pass, 0, g0); passSt.bg0 = g0.bg; passSt.dyn0 = d; } } + if (g1) { const d = g1.dyn.length ? g1.dyn[0] : -1; if (passSt.bg1 !== g1.bg || passSt.dyn1 !== d) { setBG(pass, 1, g1); passSt.bg1 = g1.bg; passSt.dyn1 = d; } } + // vertex / index buffers (baseVertex and startInstance are folded into the buffer offsets: SV_VertexID is zero based) + const indexed = kind === 4 || (kind < 4 && (kind & 1) !== 0); + // D3D's SV_VertexID / SV_InstanceID do not include the draw's base vertex / start instance (and this port treats StartVertexLocation the same); WebGPU's vertex_index / instance_index + // do. Only for vertex shaders that read them are the starts folded into the vertex buffer offsets, which re-binds the buffers whenever a start changes; every other draw passes the + // starts to the draw call and keeps its vertex buffers bound across draws. + const foldV = vsProg.vid, foldI = vsProg.iid; + const vFirst = indexed || foldV ? 0 : start, iFirst = foldI ? 0 : startInstance; + const lslots = layout.slots; + for (let k = 0; k < lslots.length; k++) { + const e = lslots[k]; + const vb = S.vb[e.slot], o = vb.buf ? objs.get(vb.buf) : null; + if (!o || !o.gpu) { // unbound vertex slot: D3D reads zeros + const z = zeroVertexBuffer(); + if (passSt.vb[e.slot] !== z || passSt.vbo[e.slot] !== 0) { pass.setVertexBuffer(e.slot, z); passSt.vb[e.slot] = z; passSt.vbo[e.slot] = 0; } + vbAvail[e.slot] = ZERO_VB_SIZE; + continue; + } + const shift = e.cls === 1 ? (foldI ? startInstance * vb.stride : 0) : (foldV ? (indexed ? baseVertex : start) * vb.stride : 0); + const voff = vb.offset + shift < 0 ? 0 : vb.offset + shift; + if (passSt.vb[e.slot] !== o.gpu || passSt.vbo[e.slot] !== voff) { pass.setVertexBuffer(e.slot, o.gpu, voff); passSt.vb[e.slot] = o.gpu; passSt.vbo[e.slot] = voff; } + vbAvail[e.slot] = o.bytes - voff; + usedInEncoder.add(o); + } + let ibMax = Infinity; + if (indexed) { + const ib = objs.get(S.ib.buf); + if (!ib || !ib.gpu) { skipDraw('if (!ib || !ib.gpu) { skippedDraws++; return; }'); return; } + const ifmt = S.ib.fmt === 57 ? 'uint16' : 'uint32'; + ibMax = Math.floor((ib.bytes - S.ib.offset) / (ifmt === 'uint16' ? 2 : 4)) - start; + if (passSt.ib !== ib.gpu || passSt.ibFmt !== ifmt || passSt.ibOff !== S.ib.offset) { pass.setIndexBuffer(ib.gpu, ifmt, S.ib.offset); passSt.ib = ib.gpu; passSt.ibFmt = ifmt; passSt.ibOff = S.ib.offset; } + usedInEncoder.add(ib); + } + // dynamic state + if (S.viewports.length) { + const v = S.viewports[0], o = passSt.vp; + if (!o || o[0] !== v[0] || o[1] !== v[1] || o[2] !== v[2] || o[3] !== v[3] || o[4] !== v[4] || o[5] !== v[5]) { + pass.setViewport(v[0], v[1], Math.max(1, v[2]), Math.max(1, v[3]), v[4], v[5]); + const vp = passSt.vp || (passSt.vp = [0, 0, 0, 0, 0, 0]); for (let i = 0; i < 6; i++) vp[i] = v[i]; + } + } + const rs = S.rs ? objs.get(S.rs) : null; + if (rs && rs.words[7] && S.scissors.length) { + const c = S.scissors[0], x0 = Math.min(passInfo.width, c[0]), y0 = Math.min(passInfo.height, c[1]), x1 = Math.min(passInfo.width, Math.max(x0, c[2])), y1 = Math.min(passInfo.height, Math.max(y0, c[3])); + setScissorOnce(x0, y0, x1 - x0, y1 - y0); + } else setScissorOnce(0, 0, passInfo.width, passInfo.height); + const bf = S.blend.factor, ob = passSt.bf; + if (!ob || ob[0] !== bf[0] || ob[1] !== bf[1] || ob[2] !== bf[2] || ob[3] !== bf[3]) { pass.setBlendConstant(bf); const sb = passSt.bf || (passSt.bf = [0, 0, 0, 0]); sb[0] = bf[0]; sb[1] = bf[1]; sb[2] = bf[2]; sb[3] = bf[3]; } + if (passSt.sref !== S.dss.ref) { pass.setStencilReference(S.dss.ref); passSt.sref = S.dss.ref; } + if (debugPs && psProg && psProg.label.includes(debugPs) && debugPsSeen < debugPsN) { debugPsSeen++; dumpDraw(kind, count, inst, start, baseVertex, vsProg, psProg, layout, g0, g1, true); debugPsProbe = { ps: psProg }; } + if (debugDraw && drawCount >= debugDraw && drawCount < debugDraw + debugDrawN) dumpDraw(kind, count, inst, start, baseVertex, vsProg, psProg, layout, g0, g1); + if (kind >= 4) { + const args = objs.get(u32[p + 1]); + if (!args || !args.gpu) { skipDraw('indirect draw without an argument buffer'); return; } + usedInEncoder.add(args); + if (kind === 4) pass.drawIndexedIndirect(args.gpu, u32[p + 2]); else pass.drawIndirect(args.gpu, u32[p + 2]); + indirectDraws++; + } else { + // D3D11 reads zeros past the end of a vertex/index buffer; WebGPU rejects the draw, and an invalid draw invalidates the whole command buffer: every draw of that submit + // is lost (seen in play: a frame's 3D vanished while the UI, submitted later, kept drawing over the stale image). Clamp the counts to what the bound buffers hold; the + // elements dropped are the ones D3D would have fed zeros. + let dCount = count, dInst = inst; + const req = pl.vbReq || []; + for (let i = 0; i < req.length; i++) { + const r = req[i], avail = vbAvail[r.slot]; + const n = avail < r.last ? 0 : (r.stride ? Math.floor((avail - r.last) / r.stride) + 1 : Infinity); + if (r.instance) { if (dInst > n - iFirst) dInst = n - iFirst; } else if (!indexed && dCount > n - vFirst) dCount = n - vFirst; + } + if (indexed && dCount > ibMax) dCount = Math.max(0, ibMax); + if (dCount !== count || dInst !== inst) { + clampedDraws++; + logOnce('clamp' + pl.label, 'draw clamped to its buffers (' + pl.label + '): ' + (indexed ? 'indexed ' : '') + count + ' x ' + inst + ' -> ' + dCount + ' x ' + dInst); + if (dCount <= 0 || dInst <= 0) { skipDraw('vertex/instance/index buffer smaller than the draw'); return; } + } + if (indexed) pass.drawIndexed(dCount, dInst, start, foldV ? 0 : baseVertex, iFirst); + else pass.draw(dCount, dInst, vFirst, iFirst); + } + drawCount++; + if (nanHuntState === 2) { nanHuntLabel = vsProg.label + ' + ' + (psProg ? psProg.label : '-') + ' (draw ' + drawCount + ')'; nanHuntPs = psProg; } + if (shotEvery || shotAllRt) { + const t0 = S.rt[0].tex ? objs.get(S.rt[0].tex) : null; + const tk = 'rt0=' + S.rt[0].tex + (t0 ? '(' + t0.desc.size.width + 'x' + t0.desc.size.height + ' ' + t0.format + ')' : '') + ' ds=' + S.ds.tex; + frameStats.targets.set(tk, (frameStats.targets.get(tk) || 0) + 1); + for (const r of S.rt) if (r.tex) frameStats.rts.add(r.tex); + frameStats.pipes.set(vsProg.label + ' + ' + (psProg ? psProg.label : '-'), (frameStats.pipes.get(vsProg.label + ' + ' + (psProg ? psProg.label : '-')) || 0) + 1); + } +} +const debugPs = isNode ? (process.env.WGPU_DEBUG_PS || '') : '', debugPsN = isNode ? +(process.env.WGPU_DEBUG_PS_N || 2) : 0; +let debugPsSeen = 0, debugPsProbe = null; +const debugDraw = isNode ? +(process.env.WGPU_DEBUG_DRAW || 0) : 0, debugDrawN = isNode ? +(process.env.WGPU_DEBUG_DRAW_N || 1) : 0; +function dumpDraw(kind, count, inst, start, baseVertex, vsProg, psProg, layout, g0, g1, allSrv) { + const rs = S.rs ? objs.get(S.rs) : null, bl = S.blend.id ? objs.get(S.blend.id) : null, ds = S.dss.id ? objs.get(S.dss.id) : null; + const lines = ['DRAW #' + drawCount + ' kind ' + kind + ' count ' + count + ' inst ' + inst + ' start ' + start + ' base ' + baseVertex + ' ' + vsProg.label + ' + ' + (psProg ? psProg.label : '-'), + ' viewport ' + JSON.stringify(S.viewports[0]) + ' scissor ' + JSON.stringify(S.scissors[0]) + ' topo ' + S.topo, + ' raster ' + (rs ? rs.words.join(',') : 'default') + ' | blend ' + (bl ? bl.words.slice(0, 10).join(',') : 'default') + ' | dss ' + (ds ? ds.words.join(',') : 'default'), + ' vs pack ' + (vsProg.pack ? vsProg.pack.members.map((m) => 'b' + m.binding + ':' + m.size).join(' ') : 'none') + ' | ps pack ' + (psProg && psProg.pack ? psProg.pack.members.map((m) => 'b' + m.binding + ':' + m.size).join(' ') : 'none')]; + for (const e of layout.els) { + const vb = S.vb[e.slot], o = vb.buf ? objs.get(vb.buf) : null; + if (o && o.dbg) lines.push(' vb bytes @' + vb.offset + ': ' + Array.from(o.dbg.subarray(vb.offset, vb.offset + 40)).join(',')); + lines.push(' el slot ' + e.slot + ' fmt ' + e.fmt + ' off ' + e.offset + ' vb ' + vb.buf + ' stride ' + vb.stride + ' voff ' + vb.offset + (o ? ' size ' + o.size : ' UNBOUND')); + } + for (const [st, prog] of [[0, vsProg], [1, psProg]]) { + if (!prog || !prog.pack) continue; + for (const m of prog.pack.members) { + const c = S.cb[st][m.binding], o = c.buf ? objs.get(c.buf) : null; + lines.push(' ' + STAGE_NAME[st] + ' cb b' + m.binding + ' buf ' + c.buf + (o && o.shadow ? ' v' + o.version + ' [' + Array.from(new Float32Array(o.shadow.buffer, o.shadow.byteOffset, Math.min(48, o.shadow.length >> 2))).map((x) => +x.toPrecision(4)).join(',') + ']' : ' NO SHADOW')); + } + } + for (let i = 0; i < (allSrv ? 32 : 8); i++) { + const sid = S.srv[1][i], srv = sid ? objs.get(sid) : null, t = srv ? objs.get(srv.res) : null; + if (t) lines.push(' ps srv t' + i + ' -> res ' + srv.res + ' ' + t.format + ' ' + t.desc.size.width + 'x' + t.desc.size.height + ' mips ' + t.desc.mipLevelCount + ' uploads ' + (t.uploads || 0) + ' ' + (t.lastUpload || '')); + } + lines.push(' srv ps ' + S.srv[1].slice(0, 8).join(',') + ' smp ' + S.smp[1].slice(0, 4).join(',')); + logLine(lines.join('\n')); +} +async function probeUavs() { + flush(); + for (let i = 0; i < 8; i++) { + const uid = S.uav[2][i], u = uid ? objs.get(uid) : null, t = u && !u.isBuf ? objs.get(u.res) : null; + if (!t || t.tex.width * t.tex.height > 4096 || !TEXTURE_PROBE[t.format]) continue; + const bpp = TEXTURE_PROBE[t.format], w = t.tex.width, h = t.tex.height, bpr = Math.ceil(w * bpp / 256) * 256; + const rb = device.createBuffer({ size: bpr * h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex }, { buffer: rb, bytesPerRow: bpr }, { width: w, height: h }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const raw = new DataView(rb.getMappedRange().slice(0)); + const vals = []; + for (let k = 0; k < Math.min(8, bpp / 4 * w * h); k++) vals.push(raw.getFloat32(k * 4, true)); + logLine(' after dispatch: uav u' + i + ' ' + t.format + ' ' + w + 'x' + h + ' first values ' + vals.map((v) => +v.toPrecision(5)).join(',')); + rb.unmap(); rb.destroy(); + } +} + +async function probeSmallSrvs() { + // print the contents of tiny bound textures (exposure/luminance values) for the draw dumped by WGPU_DEBUG_PS + if (!debugPsProbe) return; + debugPsProbe = null; + flush(); + const cand = []; + for (let i = 0; i < 32; i++) { const sid = S.srv[1][i], srv = sid ? objs.get(sid) : null; if (srv && !srv.isBuf) cand.push(['t' + i, objs.get(srv.res)]); } + for (let i = 0; i < 8; i++) if (S.rt[i].tex) cand.push(['RT' + i, objs.get(S.rt[i].tex)]); + for (const [name, t] of cand) { + if (!t || t.tex.width * t.tex.height > 1024 || !TEXTURE_PROBE[t.format]) continue; + const bpp = TEXTURE_PROBE[t.format], w = t.tex.width, h = t.tex.height, bpr = Math.ceil(w * bpp / 256) * 256; + const rb = device.createBuffer({ size: bpr * h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex }, { buffer: rb, bytesPerRow: bpr }, { width: w, height: h }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const raw = new DataView(rb.getMappedRange().slice(0)); + const vals = []; + for (let k = 0; k < Math.min(8, bpp / 4 * w * h); k++) vals.push(t.format.includes('16float') ? halfToFloat(raw.getUint16(k * 2, true)) : raw.getFloat32(k * 4, true)); + logLine(' small texture ' + name + ' ' + t.format + ' ' + w + 'x' + h + ' first values ' + vals.map((v) => +v.toPrecision(5)).join(',')); + rb.unmap(); rb.destroy(); + } +} +const TEXTURE_PROBE = { 'r32float': 4, 'rg32float': 8, 'rgba32float': 16, 'r16float': 2, 'rg16float': 4, 'rgba16float': 8 }; + +async function probeTarget() { + const r = S.rt[0], t = r.tex ? objs.get(r.tex) : null; + if (!t) return; + flush(); + const w = t.desc.size.width, h = t.desc.size.height, bpr = Math.ceil(w * 4 / 256) * 256; + const rb = device.createBuffer({ size: bpr * h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex }, { buffer: rb, bytesPerRow: bpr }, { width: w, height: h }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const src = new Uint8Array(rb.getMappedRange()); + let sum = 0, nz = 0; + for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) { const i = y * bpr + x * 4; const v = src[i] + src[i + 1] + src[i + 2]; sum += v; if (v) nz++; } + rb.unmap(); rb.destroy(); + logLine(' probe after draw #' + (drawCount - 1) + ': non-black pixels ' + nz + ' of ' + w * h); +} +const frameStats = { targets: new Map(), pipes: new Map(), rts: new Set() }; +function dumpFrameStats() { + if (approx.size) logLine('approximated D3D features: ' + [...approx].sort((a, b) => b[1] - a[1]).filter(([k]) => !k.startsWith('MipLODBias')).slice(0, 60).map(([k, n]) => k + ' x' + n).join(' | ')); + if (skipReasons.size) logLine('skipped draws by reason: ' + [...skipReasons].map(([k, n]) => k + ' x' + n).join(' | ')); + logLine('draws by target since last dump: ' + [...frameStats.targets].sort((a, b) => b[1] - a[1]).slice(0, 12).map(([k, n]) => k + ' x' + n).join(' | ')); + logLine('top pipelines: ' + [...frameStats.pipes].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([k, n]) => k + ' x' + n).join(' | ')); + frameStats.targets.clear(); frameStats.pipes.clear(); +} +async function dumpAllTargets() { + const ids = [...frameStats.rts]; + frameStats.rts.clear(); + for (const tid of ids.slice(0, 24)) { const t = objs.get(tid); if (t && t.desc.size.width >= 64) await screenshot(tid, shotPrefix + 'rt' + tid + '_' + String(presentCount).padStart(6, '0') + '.png'); } +} + +// ---- copies (GPU to GPU) ------------------------------------------------------------------------------------------------------------ +function subresourceOf(t, sub) { + const mips = t.desc.mipLevelCount; + return { mip: sub % mips, layer: Math.floor(sub / mips) }; +} +function mipSize(t, mip) { + const d = t.desc; + return { w: Math.max(1, d.size.width >> mip), h: Math.max(1, d.size.height >> mip), d: d.dimension === '3d' ? Math.max(1, d.size.depthOrArrayLayers >> mip) : 1 }; +} +// D3D11 allows CopySubresourceRegion between a block-compressed texture and an uncompressed one whose texel size equals the block size (one texel = one +// block: the GPU block compressor of the head blend renders to a small R16G16B16A16/R32G32 target and copies it into a BC1/BC3 texture). WebGPU refuses +// texture-to-texture copies between the formats; the bytes go through a buffer, which is format agnostic. +function blockBytes(format) { return /^(bc1|bc4)/.test(format) ? 8 : /^bc/.test(format) ? 16 : 0; } +function texelBytesOf(format) { + if (/^(rgba32|rgba16|rg32|r32g32)/.test(format)) return format.startsWith('rgba32') ? 16 : 8; + if (/^(rgba8|bgra8|r32|rg16|rgb10|rg11|rgb9)/.test(format)) return 4; + if (/^(rg8|r16)/.test(format)) return 2; + return /^r8/.test(format) ? 1 : 0; +} +let scratchBuf = null; +function scratch(size) { + if (!scratchBuf || scratchBuf.size < size) scratchBuf = device.createBuffer({ size: Math.max(size, 1 << 16), usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST }); + return scratchBuf; +} +function copyThroughBuffer(s, ss, d, ds, w, h, hasBox, l, t, dx, dy) { + const sb = blockBytes(s.format), db = blockBytes(d.format); + const bytes = sb || db; // bytes per block == bytes per texel of the other side + // number of blocks/texels copied (in units of the *uncompressed* side) + const cw = sb ? Math.ceil(w / 4) : w, ch = sb ? Math.ceil(h / 4) : h; + const bpr = Math.ceil(cw * bytes / 256) * 256; + const buf = scratch(bpr * ch); + const so = { x: hasBox ? l : 0, y: hasBox ? t : 0, z: ss.layer }, dO = { x: dx, y: dy, z: ds.layer }; + const enc = getEncoder(); + enc.copyTextureToBuffer({ texture: s.tex, mipLevel: ss.mip, origin: so }, { buffer: buf, bytesPerRow: bpr, rowsPerImage: ch }, { width: sb ? cw * 4 : cw, height: sb ? ch * 4 : ch, depthOrArrayLayers: 1 }); + enc.copyBufferToTexture({ buffer: buf, bytesPerRow: bpr, rowsPerImage: ch }, { texture: d.tex, mipLevel: ds.mip, origin: dO }, { width: db ? cw * 4 : cw, height: db ? ch * 4 : ch, depthOrArrayLayers: 1 }); +} +function copyRegion(dstId, dstSub, dx, dy, dz, srcId, srcSub, hasBox, l, t, f, r, b, bk) { + const s = objs.get(srcId), d = objs.get(dstId); + if (!s || !d) return; + endPass(); + if (s.kind === 'buffer') { + if (!s.gpu || !d.gpu) return; + const size = hasBox ? r - l : Math.min(s.size, d.size); + getEncoder().copyBufferToBuffer(s.gpu, hasBox ? l : 0, d.gpu, dx, size & ~3); + usedInEncoder.add(s); usedInEncoder.add(d); + return; + } + if (s.kind !== 'texture' || d.kind !== 'texture') return; + const ss = subresourceOf(s, srcSub), ds = subresourceOf(d, dstSub); + const m = mipSize(s, ss.mip); + const w = hasBox ? r - l : m.w, h = hasBox ? b - t : m.h, dep = hasBox ? bk - f : m.d; + const three = s.desc.dimension === '3d'; + if (s.format !== d.format && !three && d.desc.dimension !== '3d' && (blockBytes(s.format) !== 0) !== (blockBytes(d.format) !== 0) + && (blockBytes(s.format) || blockBytes(d.format)) === (texelBytesOf(s.format) || texelBytesOf(d.format))) { + copyThroughBuffer(s, ss, d, ds, w, h, hasBox, l, t, dx, dy); + markDepthDirty(d); markColorDirty(d); + usedInEncoder.add(s); usedInEncoder.add(d); + return; + } + try { + getEncoder().copyTextureToTexture( + { texture: s.tex, mipLevel: ss.mip, origin: { x: hasBox ? l : 0, y: hasBox ? t : 0, z: three ? (hasBox ? f : 0) : ss.layer } }, + { texture: d.tex, mipLevel: ds.mip, origin: { x: dx, y: dy, z: d.desc.dimension === '3d' ? dz : ds.layer } }, + { width: w, height: h, depthOrArrayLayers: three ? dep : 1 }); + } catch (e) { logOnce('copyfail', 'copyTextureToTexture failed: ' + e.message); } + markDepthDirty(d); markColorDirty(d); + usedInEncoder.add(s); usedInEncoder.add(d); +} +function copyResource(dstId, srcId) { + const s = objs.get(srcId), d = objs.get(dstId); + if (!s || !d) return; + if (s.kind === 'buffer') { copyRegion(dstId, 0, 0, 0, 0, srcId, 0, 0, 0, 0, 0, 0, 0, 0); return; } + if (s.kind !== 'texture' || d.kind !== 'texture') return; + endPass(); + const mips = Math.min(s.desc.mipLevelCount, d.desc.mipLevelCount); + for (let mip = 0; mip < mips; mip++) { + const m = mipSize(s, mip); + const layers = s.desc.dimension === '3d' ? m.d : s.desc.size.depthOrArrayLayers; + try { + getEncoder().copyTextureToTexture({ texture: s.tex, mipLevel: mip }, { texture: d.tex, mipLevel: mip }, { width: m.w, height: m.h, depthOrArrayLayers: layers }); + } catch (e) { logOnce('copyfail2', 'copyTextureToTexture (resource) failed: ' + e.message); } + } + markDepthDirty(d); markColorDirty(d); + usedInEncoder.add(s); usedInEncoder.add(d); +} +function resolve(dstId, dstSub, srcId, srcSub) { + const s = objs.get(srcId), d = objs.get(dstId); + if (!s || !d || s.kind !== 'texture' || d.kind !== 'texture') return; + endPass(); + const ss = subresourceOf(s, srcSub), ds = subresourceOf(d, dstSub); + const sv = s.tex.createView({ baseMipLevel: ss.mip, mipLevelCount: 1, baseArrayLayer: ss.layer, arrayLayerCount: 1, dimension: '2d' }); + const dv = d.tex.createView({ baseMipLevel: ds.mip, mipLevelCount: 1, baseArrayLayer: ds.layer, arrayLayerCount: 1, dimension: '2d' }); + getEncoder().beginRenderPass({ colorAttachments: [{ view: sv, resolveTarget: dv, loadOp: 'load', storeOp: 'discard' }] }).end(); + markColorDirty(d); + usedInEncoder.add(s); usedInEncoder.add(d); +} + +// ---- queries ------------------------------------------------------------------------------------------------------------------------- +// Occlusion: the samples passed in the passes between Begin and End (WebGPU reports whether any sample passed, not a count, so the result is +// 0 or 1: fine for the engine's visibility tests, flare intensity is on/off). One query-set slot per (query, pass). Event/timestamp: complete +// when the GPU has finished everything submitted so far. A query's result is stored into a slot in the wasm memory (`done` written last). +// Dawn's D3D12 backend reports occlusion as binary (0 or 1) but the engine compares the count with pixel thresholds (`> 100`), so a query that +// passed reports this many samples: visibility tests work, partial-visibility fades (flares) saturate. +const OCCLUSION_VISIBLE_COUNT = 65536n; +const queries = new Map(); +const occlusion = { set: null, capacity: 2048, next: 0, active: null, passSlot: -1, inflight: [] }; +const pendingResolve = [], pendingEvents = []; +function queryStore(q, result, seq) { + refreshViews(); + const base = w32(q.addr); + // result: low/high words (offset 8), then done (offset 0) + const lo = Number(BigInt.asUintN(32, BigInt(result))), hi = Number(BigInt.asUintN(32, BigInt(result) >> 32n)); + Atomics.store(i32, base + 2, lo | 0); Atomics.store(i32, base + 3, hi | 0); + Atomics.store(i32, base, seq | 0); + Atomics.notify(i32, base); +} +function createQuery(id, type, addr) { + queries.set(id, { kind: 'query', type, addr, slots: [], seq: 0 }); + objs.set(id, queries.get(id)); + if (!occlusion.set) occlusion.set = device.createQuerySet({ type: 'occlusion', count: occlusion.capacity }); +} +// D3D11_QUERY: EVENT 0, OCCLUSION 1, TIMESTAMP 2, TIMESTAMP_DISJOINT 3, PIPELINE_STATISTICS 4, OCCLUSION_PREDICATE 5 +const isOcclusion = (q) => q.type === 1 || q.type === 5; +function beginOcclusionInPass() { + const q = occlusion.active; + if (!q || !pass || occlusion.passSlot >= 0) return; + if (occlusion.next >= occlusion.capacity) { logOnce('qfull', 'occlusion query set exhausted'); return; } + occlusion.passSlot = occlusion.next++; + q.slots.push(occlusion.passSlot); + pass.beginOcclusionQuery(occlusion.passSlot); +} +function endOcclusionInPass() { + if (pass && occlusion.passSlot >= 0) { pass.endOcclusionQuery(); occlusion.passSlot = -1; } +} +function beginQuery(id) { + const q = queries.get(id); + if (!q || !isOcclusion(q)) return; + q.slots = []; + occlusion.active = q; + beginOcclusionInPass(); +} +function endQuery(id, seq) { + const q = queries.get(id); + if (!q) return; + q.seq = seq; + if (isOcclusion(q)) { + if (occlusion.active === q) { endOcclusionInPass(); occlusion.active = null; } + pendingResolve.push({ q, seq, slots: q.slots }); + q.slots = []; + } else { + pendingEvents.push({ q, seq, time: BigInt(Math.round(performance.now() * 1e6)) }); + } +} +// Staging buffers that are created and dropped all the time (readbacks, occlusion resolves) are kept per (usage, size) and reused: createBuffer/destroy per use cost more than +// the copy. At most 4 per kind. +const bufferPool = new Map(); +function pooledBuffer(size, usage) { + const l = bufferPool.get(usage * 4294967296 + size); + return l && l.length ? l.pop() : device.createBuffer({ size, usage }); +} +function releaseBuffer(b, size, usage) { + const k = usage * 4294967296 + size; + let l = bufferPool.get(k); + if (!l) bufferPool.set(k, l = []); + if (l.length < 4) l.push(b); else b.destroy(); +} +// Occlusion queries ended since the last submit are resolved by commands recorded at the end of the encoder being submitted (they had a command buffer and two new buffers of +// their own per submit). A query's slots are consecutive (one active query at a time, slots taken in order, the wrap only happens with no query active): one resolve per query, +// its 8-byte results packed from a 256-aligned offset. +function recordResolves() { + const list = pendingResolve.splice(0); + const layout = []; + let bytes = 0; + for (const r of list) { + const k = r.slots.length; + if (!k) { queryStore(r.q, 0, r.seq); continue; } + const s0 = r.slots[0]; + let consecutive = true; + for (let i = 1; i < k; i++) if (r.slots[i] !== s0 + i) { consecutive = false; break; } + layout.push(r, bytes, consecutive); + bytes += consecutive ? Math.ceil(k * 8 / 256) * 256 : k * 256; + } + if (occlusion.next > occlusion.capacity - 256 && !occlusion.active) occlusion.next = 0; // slots are reusable once resolved (the resolves are recorded before any later pass) + if (!bytes) return null; + let size = 256; + while (size < bytes) size *= 2; + const RU = GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC, MU = GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ; + const rb = pooledBuffer(size, RU), map = pooledBuffer(size, MU); + const enc = getEncoder(); + for (let j = 0; j < layout.length; j += 3) { + const r = layout[j], at = layout[j + 1]; + if (layout[j + 2]) enc.resolveQuerySet(occlusion.set, r.slots[0], r.slots.length, rb, at); + else for (let i = 0; i < r.slots.length; i++) enc.resolveQuerySet(occlusion.set, r.slots[i], 1, rb, at + i * 256); + } + enc.copyBufferToBuffer(rb, 0, map, 0, bytes); + return { layout, rb, map, size, RU, MU }; +} +function mapResolves(res) { + res.map.mapAsync(GPUMapMode.READ).then(() => { + const v = new BigUint64Array(res.map.getMappedRange()); + const L = res.layout; + for (let j = 0; j < L.length; j += 3) { + const r = L[j], base = L[j + 1] / 8, step = L[j + 2] ? 1 : 32; + let sum = 0n; + for (let i = 0; i < r.slots.length; i++) sum += v[base + i * step]; + queryStore(r.q, sum !== 0n ? OCCLUSION_VISIBLE_COUNT : 0n, r.seq); + } + res.map.unmap(); + releaseBuffer(res.map, res.size, res.MU); releaseBuffer(res.rb, res.size, res.RU); + }, () => { res.map.destroy(); res.rb.destroy(); }); +} +// after a submit: complete events once the GPU has caught up +function onSubmitted() { + if (pendingEvents.length) { + const evs = pendingEvents.splice(0); + device.queue.onSubmittedWorkDone().then(() => { for (const e of evs) queryStore(e.q, e.q.type === 2 ? e.time : 1, e.seq); }); + } +} + +// ---- UAV counters (append/consume/counter buffers): vkd3d gives them a separate storage buffer; one per D3D buffer ------------------------ +function counterBuffer(bufObj) { + if (!bufObj.counter) bufObj.counter = device.createBuffer({ size: 16, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST }); + return bufObj.counter; +} +// Append/consume counter resets (D3D: initial counts in SetUnorderedAccessViews) happen at their place in the command stream: the value goes into its own slot of counterSrc +// (queue.writeBuffer lands before the command buffer submitted afterwards) and a copy into the counter is recorded, so earlier dispatches/draws still see the old value without a +// submit (one per reset before: 6-11 per frame in some scenes). Slots are reused after the next submit. +const COUNTER_SLOTS = 1024, counterVal = new Uint32Array(1); +let counterSrc = null, counterSlot = 0; +function setUavCounter(uavId, value) { + const uav = objs.get(uavId), buf = uav && uav.isBuf ? objs.get(uav.res) : null; + if (!buf) return; + if (!counterSrc) counterSrc = device.createBuffer({ size: COUNTER_SLOTS * 4, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST }); + if (counterSlot >= COUNTER_SLOTS) flush('uav counter'); // resets counterSlot + const slot = counterSlot++; + counterVal[0] = value >>> 0; + device.queue.writeBuffer(counterSrc, slot * 4, counterVal); + endPass(); + getEncoder().copyBufferToBuffer(counterSrc, slot * 4, counterBuffer(buf), 0, 4); + usedInEncoder.add(buf); +} +const debugCounters = isNode ? +(process.env.WGPU_DEBUG_COUNTERS || 0) : 0; +let counterLogged = 0, indirectDraws = 0; +async function logCounter(uavId) { + const uav = objs.get(uavId), buf = uav && uav.isBuf ? objs.get(uav.res) : null; + if (!buf || !buf.counter) { logLine('counter of uav ' + uavId + ': none'); return; } + flush(); + const rb = device.createBuffer({ size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyBufferToBuffer(buf.counter, 0, rb, 0, 16); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + logLine('counter of uav ' + uavId + ' (buffer ' + uav.res + ') = ' + new Uint32Array(rb.getMappedRange())[0] + '; indirect draws so far ' + indirectDraws); + rb.unmap(); rb.destroy(); +} +function copyCounter(dstId, offset, uavId) { + const dst = objs.get(dstId), uav = objs.get(uavId), src = uav && uav.isBuf ? objs.get(uav.res) : null; + if (!dst || !dst.gpu || !src) return; + endPass(); + getEncoder().copyBufferToBuffer(counterBuffer(src), 0, dst.gpu, offset, 4); + usedInEncoder.add(dst); usedInEncoder.add(src); +} + +// ---- compute -------------------------------------------------------------------------------------------------------------------------- +const computeCache = new Map(); +function computePipelineFor(csObj, prog) { + // the WGSL declares typed storage textures with a format guessed from the component count; the pipeline needs the real one + const subs = []; + for (const b of prog.groupBindings[0] || []) { + if (b.kind !== 'storage-texture') continue; + const uav = S.uav[2][b.binding - 160] ? objs.get(S.uav[2][b.binding - 160]) : null; + const t = uav && !uav.isBuf ? objs.get(uav.res) : null; + if (t && t.format !== b.format) subs.push([b.binding, b.format, t.format]); + } + const key = csObj.hash + '|' + subs.join(';'); + let pl = computeCache.get(key); + if (pl !== undefined) return pl; + let module = prog.module, bindings = prog.info.bindings; + if (subs.length) { + let text = prog.text; + for (const [binding, from, to] of subs) text = text.replace(new RegExp('(@binding\\(' + binding + 'u?\\)\\s*var\\s+\\w+\\s*:\\s*texture_storage_\\w+<)' + from), '$1' + to); + module = device.createShaderModule({ code: text, label: prog.label + ' [uav formats]' }); + bindings = parseWgsl(text).bindings; + } + const entries = bindings.filter((b) => b.group === 0).map((b) => layoutEntry(b, 2)); + const layout = device.createPipelineLayout({ bindGroupLayouts: [device.createBindGroupLayout({ entries })] }); + try { pl = device.createComputePipeline({ layout, compute: { module, entryPoint: 'main' }, label: prog.label }); } + catch (e) { logLine('compute pipeline failed (' + prog.label + '): ' + e.message); pl = null; } + computeCache.set(key, { pl, bgl: pl ? pl.getBindGroupLayout(0) : null, bindings }); + return computeCache.get(key); +} +let dispatchCount = 0, setCsLogged = 0; +const debugCs = isNode ? +(process.env.WGPU_DEBUG_CS || 0) : 0, debugCsN = debugCs; +let debugCsProbe = false; +function doDispatch(x, y, z) { + const cs = S.shader[2] ? objs.get(S.shader[2]) : null; + if (!cs) { skippedDraws++; logOnce('dispatch-nocs', 'Dispatch with no compute shader bound'); return; } + const prog = shaderProgram(cs); + if (!prog) { skippedDraws++; logOnce('dispatch-noprog' + cs.hash, 'Dispatch skipped: compute shader ' + cs.hash + ' has no WGSL'); return; } + prepareDepthProxies(prog, 2); + endPass(); + const cp = computePipelineFor(cs, prog); + if (!cp || !cp.pl) { skippedDraws++; logOnce('dispatch-nopl' + prog.label, 'Dispatch skipped: no compute pipeline for ' + prog.label); return; } + // the program view with the pipeline's bindings is made once per pipeline: a new object per dispatch defeated the per-program pack cache (constants re-packed every time) + const cprog = cp.prog || (cp.prog = { ...prog, groupBindings: { 0: cp.bindings.filter((b) => b.group === 0).sort((a, b) => a.binding - b.binding) }, packEnts: undefined, uid: 0, fast: undefined, idSrc: undefined, bgls: [] }); + const g0 = stageBindGroup(2, cprog, 0, cp.bgl); + if (!g0) { skippedDraws++; logOnce('dispatch-nobg' + prog.label, 'Dispatch skipped: bind group failed for ' + prog.label); return; } + const cpass = getEncoder().beginComputePass(); + cpass.setPipeline(cp.pl); + setBG(cpass, 0, g0); + cpass.dispatchWorkgroups(x, y, z); + cpass.end(); + dispatchCount++; + if (debugCs && dispatchCount <= debugCsN) { + const info = ['DISPATCH #' + dispatchCount + ' ' + prog.label + ' ' + x + 'x' + y + 'x' + z]; + for (let i = 0; i < 16; i++) { const sid = S.srv[2][i], srv = sid ? objs.get(sid) : null, t = srv && !srv.isBuf ? objs.get(srv.res) : null; if (t) info.push(' srv t' + i + ' ' + t.format + ' ' + t.desc.size.width + 'x' + t.desc.size.height + ' res ' + srv.res); else if (srv && srv.isBuf) info.push(' srv t' + i + ' buffer ' + srv.res); } + for (let i = 0; i < 8; i++) { const uid = S.uav[2][i], u = uid ? objs.get(uid) : null; if (u) { const t = objs.get(u.res); info.push(' uav u' + i + (u.isBuf ? ' buffer' : ' ' + (t ? t.format + ' ' + t.desc.size.width + 'x' + t.desc.size.height : '?')) + ' res ' + u.res); } } + logLine(info.join('\n')); + debugCsProbe = true; + } +} + +let zeroSrc = null; // never written: WebGPU buffers start zeroed +const TEXEL_BYTES = { 'r8unorm': 1, 'rg8unorm': 2, 'rgba8unorm': 4, 'bgra8unorm': 4, 'r16float': 2, 'rg16float': 4, 'rgba16float': 8, 'r32float': 4, 'r32uint': 4, 'r32sint': 4, 'rg32float': 8, 'rgba32float': 16, 'rgba32uint': 16, 'rgba8uint': 4, 'rg11b10ufloat': 4, 'rgb10a2unorm': 4 }; +function clearUav(id, isFloat, values) { + const uav = objs.get(id); + if (!uav) return; + if (uav.isBuf) { + const buf = objs.get(uav.res); + if (!buf || !buf.gpu) return; + if (usedInEncoder.has(buf)) { /* ordering: recorded commands are in the same encoder */ } + endPass(); + if (!(values[0] | values[1] | values[2] | values[3])) getEncoder().clearBuffer(buf.gpu); + else { flush('uav clear'); const n = buf.bytes >> 2, a = new Uint32Array(n); for (let i = 0; i < n; i++) a[i] = values[i & 3]; device.queue.writeBuffer(buf.gpu, 0, a); } + usedInEncoder.add(buf); + return; + } + const t = objs.get(uav.res); + if (!t) return; + const bpt = TEXEL_BYTES[t.format]; + if (!bpt) { logOnce('clearuav' + t.format, 'ClearUnorderedAccessView: texture format ' + t.format + ' not supported'); return; } + const mip = uav.a, w = Math.max(1, t.desc.size.width >> mip), h = Math.max(1, t.desc.size.height >> mip); + const layers = t.desc.dimension === '3d' ? Math.max(1, t.desc.size.depthOrArrayLayers >> mip) : t.desc.size.depthOrArrayLayers; + if (!(values[0] | values[1] | values[2] | values[3])) { + // zero: a copy from a buffer that stays zero, recorded in order (no submit, no texture-sized array per clear) + const bpr = Math.ceil(w * bpt / 256) * 256, need = bpr * h; + if (!zeroSrc || zeroSrc.size < need) zeroSrc = device.createBuffer({ size: Math.max(need, 1 << 20), usage: GPUBufferUsage.COPY_SRC }); + endPass(); + const enc = getEncoder(); + for (let l = 0; l < layers; l++) enc.copyBufferToTexture({ buffer: zeroSrc, bytesPerRow: bpr, rowsPerImage: h }, { texture: t.tex, mipLevel: mip, origin: { x: 0, y: 0, z: l } }, { width: w, height: h, depthOrArrayLayers: 1 }); + usedInEncoder.add(t); markColorDirty(t); + return; + } + flush('uav clear'); + const data = new Uint8Array(w * h * bpt); + if (values[0] | values[1] | values[2] | values[3]) { + const dv = new DataView(data.buffer); + for (let i = 0; i < w * h; i++) for (let c = 0; c < bpt / 4; c++) dv.setUint32(i * bpt + c * 4, values[c & 3], true); + } + for (let l = 0; l < layers; l++) device.queue.writeTexture({ texture: t.tex, mipLevel: mip, origin: { x: 0, y: 0, z: l } }, data, { bytesPerRow: w * bpt, rowsPerImage: h }, { width: w, height: h, depthOrArrayLayers: 1 }); +} + +// ---- mip generation and readback ------------------------------------------------------------------------------------------------------ +const mipPipelines = new Map(); +let mipSampler = null; +function generateMips(srvId) { + const srv = objs.get(srvId), t = srv ? objs.get(srv.res) : null; + if (!t || t.kind !== 'texture' || t.desc.mipLevelCount < 2) return; + const fmt = t.format; + if (isDepth(fmt) || fmt.startsWith('bc') || t.desc.dimension === '3d') { logOnce('mips' + fmt, 'GenerateMips: unsupported texture format/dimension ' + fmt + ' ' + t.desc.dimension); return; } + endPass(); + let pl = mipPipelines.get(fmt); + if (!pl) { + const module = device.createShaderModule({ code: `@group(0) @binding(0) var src: texture_2d; + @group(0) @binding(1) var smp: sampler; + @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { var p = array(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3)); return vec4f(p[i], 0, 1); } + @fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f { + let dst = max(vec2f(1.0), floor(vec2f(textureDimensions(src, 0)) * 0.5)); + return textureSampleLevel(src, smp, pos.xy / dst, 0.0); + }` }); + pl = device.createRenderPipeline({ layout: 'auto', vertex: { module, entryPoint: 'vs' }, fragment: { module, entryPoint: 'fs', targets: [{ format: fmt }] } }); + mipPipelines.set(fmt, pl); + } + if (!mipSampler) mipSampler = device.createSampler({ magFilter: 'linear', minFilter: 'linear', addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge' }); + const enc = getEncoder(), layers = t.desc.size.depthOrArrayLayers; + if (!t.mipPasses) { // per texture, made once (GenerateMips runs every frame on some targets, e.g. the reflection map's mip blur) + t.mipPasses = []; + for (let layer = 0; layer < layers; layer++) for (let mip = 1; mip < t.desc.mipLevelCount; mip++) { + const src = t.tex.createView({ dimension: '2d', baseMipLevel: mip - 1, mipLevelCount: 1, baseArrayLayer: layer, arrayLayerCount: 1 }); + const dst = t.tex.createView({ dimension: '2d', baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: layer, arrayLayerCount: 1 }); + t.mipPasses.push({ dst, bg: device.createBindGroup({ layout: pl.getBindGroupLayout(0), entries: [{ binding: 0, resource: src }, { binding: 1, resource: mipSampler }] }) }); + } + } + for (const r of t.mipPasses) { + const p = enc.beginRenderPass({ colorAttachments: [{ view: r.dst, loadOp: 'clear', storeOp: 'store' }] }); + p.setPipeline(pl); + p.setBindGroup(0, r.bg); + p.draw(3); + p.end(); + } + usedInEncoder.add(t); markColorDirty(t); +} + +function blockInfo(format) { + if (format.startsWith('bc')) return { bytes: /^bc(1|4)/.test(format) ? 8 : 16, bw: 4, bh: 4 }; + if (/^(r8|stencil8)/.test(format)) return { bytes: 1, bw: 1, bh: 1 }; + if (/^(rg8|r16)/.test(format)) return { bytes: 2, bw: 1, bh: 1 }; + if (/^(rgba16|rg32)/.test(format)) return { bytes: 8, bw: 1, bh: 1 }; + if (/^rgba32/.test(format)) return { bytes: 16, bw: 1, bh: 1 }; + return { bytes: 4, bw: 1, bh: 1 }; +} + +async function readback(p) { + // GPU resource -> the CPU storage of a D3D staging resource, written straight into the shared wasm memory + const src = objs.get(u32[p]); + const sub = u32[p + 1], hasBox = u32[p + 2]; + const l = u32[p + 3], t = u32[p + 4], f = u32[p + 5], r = u32[p + 6], b = u32[p + 7], bk = u32[p + 8]; + const addr = u32[p + 9] + u32[p + 10] * 4294967296, rowPitch = u32[p + 11], slicePitch = u32[p + 12], isBuf = u32[p + 13], size = u32[p + 14]; + if (!src) return; + // The copy is recorded into the open encoder, after the commands that produce the data, and that encoder is submitted at once: the engine maps the staging resource soon + // (often next frame) and deferring the submit to the present made it wait 50-300 ms. One submit per readback (it was the open encoder plus a separate one for the copy). + if (isBuf) { + if (!src.gpu) return; + const n = hasBox ? r - l : Math.min(size, src.size), padded = (n + 3) & ~3; + const MU = GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, rbSize = Math.max(4, padded); + const rb = pooledBuffer(rbSize, MU); + endPass(); + getEncoder().copyBufferToBuffer(src.gpu, hasBox ? l : 0, rb, 0, rbSize); + flush('readback'); + await rb.mapAsync(GPUMapMode.READ); + refreshViews(); + u8.set(new Uint8Array(rb.getMappedRange(), 0, n), addr); + rb.unmap(); releaseBuffer(rb, rbSize, MU); + return; + } + if (src.kind !== 'texture' || src.desc.sampleCount > 1 || isDepth(src.format)) { logOnce('rbfmt' + src.format, 'readback of ' + src.format + (src.desc.sampleCount > 1 ? ' (multisampled)' : '') + ' not supported'); return; } + const mips = src.desc.mipLevelCount, mip = sub % mips, layer = Math.floor(sub / mips); + const mw = Math.max(1, src.desc.size.width >> mip), mh = Math.max(1, src.desc.size.height >> mip); + const three = src.desc.dimension === '3d', md = three ? Math.max(1, src.desc.size.depthOrArrayLayers >> mip) : 1; + const bi = blockInfo(src.format); + const x0 = hasBox ? l : 0, y0 = hasBox ? t : 0, z0 = hasBox ? f : 0; + const w = hasBox ? r - l : mw, h = hasBox ? b - t : mh, d = hasBox ? bk - f : md; + const bx = Math.ceil(w / bi.bw), by = Math.ceil(h / bi.bh), rowBytes = bx * bi.bytes, bpr = Math.ceil(rowBytes / 256) * 256; + const MU = GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, rbSize = bpr * by * d; + const rb = pooledBuffer(rbSize, MU); + endPass(); + getEncoder().copyTextureToBuffer({ texture: src.tex, mipLevel: mip, origin: { x: x0, y: y0, z: three ? z0 : layer } }, { buffer: rb, bytesPerRow: bpr, rowsPerImage: by }, + { width: bx * bi.bw, height: by * bi.bh, depthOrArrayLayers: three ? d : 1 }); + flush('readback'); + await rb.mapAsync(GPUMapMode.READ); + refreshViews(); + const data = new Uint8Array(rb.getMappedRange()); + for (let z = 0; z < d; z++) for (let row = 0; row < by; row++) + u8.set(data.subarray((z * by + row) * bpr, (z * by + row) * bpr + rowBytes), addr + z * slicePitch + row * rowPitch); + rb.unmap(); releaseBuffer(rb, rbSize, MU); +} + +// ---- clears (own passes) ------------------------------------------------------------------------------------------------------------ +// views for clears come from the same per-texture cache as render-target views (a new GPUTextureView per clear before) +function clearView(t, mip, slice) { + if (t.desc.dimension === '3d') return t.tex.createView({ baseMipLevel: mip, mipLevelCount: 1, baseArrayLayer: slice, arrayLayerCount: 1, dimension: '2d' }); + return targetView(t, 0, mip, slice).view; +} +function clearRT(id, mip, slice, r, g, b, a) { + const t = objs.get(id); + if (!t || t.kind !== 'texture') return; + markColorDirty(t); + endPass(); + const view = clearView(t, mip, slice); + getEncoder().beginRenderPass({ colorAttachments: [{ view, loadOp: 'clear', storeOp: 'store', clearValue: { r, g, b, a } }] }).end(); +} + +function clearDS(id, mip, slice, flags, depth, stencil) { + const t = objs.get(id); + if (!t || t.kind !== 'texture') return; + markDepthDirty(t); + endPass(); + const view = clearView(t, mip, slice); + const att = { view, depthLoadOp: (flags & 1) ? 'clear' : 'load', depthStoreOp: 'store', depthClearValue: depth }; + if (hasStencil(t.format)) Object.assign(att, { stencilLoadOp: (flags & 2) ? 'clear' : 'load', stencilStoreOp: 'store', stencilClearValue: stencil }); + getEncoder().beginRenderPass({ colorAttachments: [], depthStencilAttachment: att }).end(); +} + +// Present: in a browser, blit the back buffer into the canvas; in Node there is no surface (screenshots are explicit). +function makeBlit() { + const module = device.createShaderModule({ code: ` + @group(0) @binding(0) var src: texture_2d; + @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f { + var p = array(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3)); + return vec4f(p[i], 0, 1); + } + @fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f { + return textureLoad(src, vec2i(pos.xy), 0); + }` }); + blit = device.createRenderPipeline({ + layout: 'auto', + vertex: { module, entryPoint: 'vs' }, + fragment: { module, entryPoint: 'fs', targets: [{ format: canvasFormat }] }, + }); +} + + +// PNG writer (Node only; used by the headless verification). +function crc32(buf) { + let c, crc = ~0; + for (let n = 0; n < buf.length; n++) { + c = (crc ^ buf[n]) & 0xff; + for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; + crc = (crc >>> 8) ^ c; + } + return ~crc >>> 0; +} +function encodePng(w, h, rgba) { + const zlib = require('zlib'); + const raw = Buffer.alloc((w * 4 + 1) * h); + for (let y = 0; y < h; y++) { raw[y * (w * 4 + 1)] = 0; Buffer.from(rgba.buffer, rgba.byteOffset + y * w * 4, w * 4).copy(raw, y * (w * 4 + 1) + 1); } + const chunk = (type, data) => { + const len = Buffer.alloc(4); len.writeUInt32BE(data.length); + const td = Buffer.concat([Buffer.from(type), data]); + const crc = Buffer.alloc(4); crc.writeUInt32BE(crc32(td)); + return Buffer.concat([len, td, crc]); + }; + const ihdr = Buffer.alloc(13); ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4); ihdr[8] = 8; ihdr[9] = 6; + return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk('IHDR', ihdr), chunk('IDAT', zlib.deflateSync(raw)), chunk('IEND', Buffer.alloc(0))]); +} + + +function readString(w, lenBytes) { + const start = w * 4; + return new TextDecoder().decode(u8.slice(start, start + lenBytes)); +} + +const f16 = new Float32Array(1), u32v = new Uint32Array(f16.buffer); +function halfToFloat(h) { + const s = (h & 0x8000) ? -1 : 1, e = (h >> 10) & 31, m = h & 1023; + if (e === 0) return s * m * 5.960464477539063e-8; + if (e === 31) return m ? NaN : s * Infinity; + return s * Math.pow(2, e - 15) * (1 + m / 1024); +} +const clamp8 = (v) => Math.max(0, Math.min(255, Math.round((v > 0 ? v : 0) * 255))); +// texel -> [r,g,b,a] (0..255) for the formats the debugging dumps understand +const TEXEL = { + 'rgba8unorm': [4, (d, i) => [d[i], d[i + 1], d[i + 2], d[i + 3]]], + 'rgba8unorm-srgb': [4, (d, i) => [d[i], d[i + 1], d[i + 2], d[i + 3]]], + 'bgra8unorm': [4, (d, i) => [d[i + 2], d[i + 1], d[i], d[i + 3]]], + 'bgra8unorm-srgb': [4, (d, i) => [d[i + 2], d[i + 1], d[i], d[i + 3]]], + 'rgba16float': [8, (d, i) => [0, 2, 4, 6].map((o) => clamp8(halfToFloat(d[i + o] | (d[i + o + 1] << 8))))], + 'rgb10a2unorm': [4, (d, i) => { const v = (d[i] | (d[i + 1] << 8) | (d[i + 2] << 16) | (d[i + 3] << 24)) >>> 0; return [(v & 1023) / 1023 * 255, ((v >>> 10) & 1023) / 1023 * 255, ((v >>> 20) & 1023) / 1023 * 255, 255]; }], + 'rg11b10ufloat': [4, (d, i) => { const v = (d[i] | (d[i + 1] << 8) | (d[i + 2] << 16) | (d[i + 3] << 24)) >>> 0; const f11 = (x) => { const e = x >> 6, m = x & 63; return e === 0 ? m / 64 * Math.pow(2, -14) : Math.pow(2, e - 15) * (1 + m / 64); }; const f10 = (x) => { const e = x >> 5, m = x & 31; return e === 0 ? m / 32 * Math.pow(2, -14) : Math.pow(2, e - 15) * (1 + m / 32); }; return [clamp8(f11(v & 2047)), clamp8(f11((v >>> 11) & 2047)), clamp8(f10(v >>> 22)), 255]; }], + 'r32float': [4, (d, i) => { u32v[0] = d[i] | (d[i + 1] << 8) | (d[i + 2] << 16) | (d[i + 3] << 24); const x = clamp8(f16[0]); return [x, x, x, 255]; }], + 'rg16float': [4, (d, i) => [clamp8(halfToFloat(d[i] | (d[i + 1] << 8))), clamp8(halfToFloat(d[i + 2] | (d[i + 3] << 8))), 0, 255]], + 'r8unorm': [1, (d, i) => [d[i], d[i], d[i], 255]], + 'rg8unorm': [2, (d, i) => [d[i], d[i + 1], 0, 255]], +}; + +async function screenshot(id, path) { + const t = objs.get(id); + if (!t || t.kind !== 'texture') { logLine('screenshot: unknown texture ' + id); return; } + const fmt = TEXEL[t.format]; + if (!fmt || t.desc.sampleCount > 1) { logLine('screenshot: texture ' + id + ' is ' + t.format + (t.desc.sampleCount > 1 ? ' (multisampled)' : ' (format not decoded)')); return; } + flush(); + const w = t.desc.size.width, h = t.desc.size.height, bpp = fmt[0]; + const bpr = Math.ceil(w * bpp / 256) * 256; + const rb = device.createBuffer({ size: bpr * h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex }, { buffer: rb, bytesPerRow: bpr }, { width: w, height: h }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const src = new Uint8Array(rb.getMappedRange()); + const out = new Uint8Array(w * h * 4); + let nonBlack = 0; + for (let y = 0; y < h; y++) { + for (let x = 0; x < w; x++) { + const px = fmt[1](src, y * bpr + x * bpp), d = (y * w + x) * 4; + out[d] = px[0]; out[d + 1] = px[1]; out[d + 2] = px[2]; out[d + 3] = px[3]; + if (px[0] | px[1] | px[2]) nonBlack++; + } + } + rb.unmap(); rb.destroy(); + if (isNode) require('fs').writeFileSync(path, encodePng(w, h, out)); + else { + post({ screenshot: { path, w, h, format: t.format, pixels: out } }); + fetch('/shot?name=' + encodeURIComponent(String(path).replace(/^.*[\\/]/, '').replace(/\.png$/, '')) + '&w=' + w + '&h=' + h, { method: 'POST', body: out }).catch(() => {}); + } + dumpErrors(); + logLine('screenshot ' + path + ' ' + w + 'x' + h + ' ' + t.format + ' non-black ' + nonBlack + '; draws so far ' + drawCount + ', skipped ' + skippedDraws); +} + +// ?shotrt=1: the numbers behind a float render target (the lighting buffer is rgba16float; screenshot() clamps to 8 bits, so "white" there only says >= 1): per channel max and the +// mean of the finite texels, how many texels are NaN, +-Inf, above 1 and above 100, and the centre texel. A device that renders the world white shows here whether the lighting +// really produced huge/invalid values or the picture went white later (tone mapping). +const F11 = (x) => { const e = x >> 6, m = x & 63; return e === 0 ? m / 64 * 6.103515625e-5 : e === 31 ? (m ? NaN : Infinity) : Math.pow(2, e - 15) * (1 + m / 64); }; +const F10 = (x) => { const e = x >> 5, m = x & 31; return e === 0 ? m / 32 * 6.103515625e-5 : e === 31 ? (m ? NaN : Infinity) : Math.pow(2, e - 15) * (1 + m / 32); }; +const FLOAT_STAT_FORMATS = { // format: [channels, reader(DataView, byte offset, channel)] + rgba16float: [4, (dv, o, c) => halfToFloat(dv.getUint16(o + c * 2, true))], rg16float: [2, (dv, o, c) => halfToFloat(dv.getUint16(o + c * 2, true))], r16float: [1, (dv, o, c) => halfToFloat(dv.getUint16(o, true))], + rgba32float: [4, (dv, o, c) => dv.getFloat32(o + c * 4, true)], rg32float: [2, (dv, o, c) => dv.getFloat32(o + c * 4, true)], r32float: [1, (dv, o) => dv.getFloat32(o, true)], + rg11b10ufloat: [3, (dv, o, c) => { const v = dv.getUint32(o, true); return c === 0 ? F11(v & 2047) : c === 1 ? F11((v >>> 11) & 2047) : F10(v >>> 22); }], +}; +const rtListed = new Set(); +async function floatStats(id) { + const t = objs.get(id); + if (!t || t.kind !== 'texture') return; + const w = t.desc.size.width, h = t.desc.size.height; + if (!rtListed.has(id)) { rtListed.add(id); logLine('rt ' + id + ' ' + w + 'x' + h + ' ' + t.format + (t.desc.sampleCount > 1 ? ' x' + t.desc.sampleCount : '')); } + const fs = FLOAT_STAT_FORMATS[t.format]; + if (!fs || t.desc.sampleCount > 1) return; + flush(); + const ch = fs[0], read = fs[1], bpp = TEXEL_BYTES[t.format]; + const bpr = Math.ceil(w * bpp / 256) * 256; + const rb = device.createBuffer({ size: bpr * h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex }, { buffer: rb, bytesPerRow: bpr }, { width: w, height: h }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const range = rb.getMappedRange(), dv = new DataView(range); + const max = new Array(ch).fill(-Infinity), sum = new Array(ch).fill(0); + let nan = 0, inf = 0, gt1 = 0, gt100 = 0; + for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) { + const o = y * bpr + x * bpp; + for (let c = 0; c < ch; c++) { + const v = read(dv, o, c); + if (v !== v) { nan++; continue; } + if (v === Infinity || v === -Infinity) { inf++; continue; } + sum[c] += v; if (v > max[c]) max[c] = v; + if (c < 3) { if (v > 1) gt1++; if (v > 100) gt100++; } + } + } + const cx = ((h >> 1) * bpr) + (w >> 1) * bpp, centre = []; + for (let c = 0; c < ch; c++) centre.push(read(dv, cx, c).toPrecision(4)); + rb.unmap(); rb.destroy(); + const n = w * h; + logLine('rtstats ' + id + ' ' + w + 'x' + h + ' ' + t.format + ': max ' + max.map((v) => v.toPrecision(4)).join('/') + ', mean ' + sum.map((v) => (v / Math.max(1, n)).toPrecision(4)).join('/') + ', NaN ' + nan + ', Inf ' + inf + ', rgb>1 ' + gt1 + ', rgb>100 ' + gt100 + ' of ' + n + ' texels, centre ' + centre.join('/')); +} +let rtStatsT = 0; + +// ?shotrt=1, 30 s after the world's first frame: ONE frame is scanned draw by draw (nanHuntState 2, from present() to the next present()). After every draw into a large HDR target +// (rgba16float / rg11b10ufloat, 600 px or wider) a 64x40 grid of the target is read back and counted for texels with a NaN, an Inf or a value over 1000 in RGB; whenever the count +// of a target changes the draw's shaders are logged. Found on a Chromebook (Intel, Dawn/Vulkan, 2026-10-06): the lighting buffer was ~95 % NaN, which displays as white, and this PC's +// has none - so the first draw that introduces NaN names the shader whose maths differs on that GPU. +let nanHuntState = 0, nanHuntLabel = '', nanHuntLogged = 0, nanHuntScans = 0, nanHuntLastCount = -1, nanHuntPs = null, nanHuntDetails = 0; +const nanHuntPrev = new Map(); +const NAN_TEXEL = { r8uint: 1, r8unorm: 1, rg8unorm: 2, rgba8unorm: 4, bgra8unorm: 4, r16float: 2, rg16float: 4, rgba16float: 8, r32float: 4, rg32float: 8, rgba32float: 16, rg11b10ufloat: 4, rgb10a2unorm: 4 }; +// One texel of a texture (position given for a target of tw x th, scaled to the texture's size) as text: raw bytes, and decoded floats for the float formats. +async function nanReadTexel(t, x, y, tw, th, mip = 0) { + const bpp = NAN_TEXEL[t.format]; + if (!bpp || t.desc.sampleCount > 1) return t.format + (t.desc.sampleCount > 1 ? ' (multisampled)' : ' (not readable here)'); + const mw = Math.max(1, t.desc.size.width >> mip), mh = Math.max(1, t.desc.size.height >> mip); + const sx = Math.min(mw - 1, Math.floor((x + 0.5) * mw / tw)), sy = Math.min(mh - 1, Math.floor((y + 0.5) * mh / th)); + try { + const rb = device.createBuffer({ size: 256, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex, mipLevel: mip, origin: { x: sx, y: sy } }, { buffer: rb, bytesPerRow: 256 }, { width: 1, height: 1 }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const dv = new DataView(rb.getMappedRange().slice(0)); + rb.unmap(); rb.destroy(); + const bytes = []; for (let i = 0; i < bpp; i++) bytes.push(dv.getUint8(i)); + const fs = FLOAT_STAT_FORMATS[t.format]; + const vals = fs ? Array.from({ length: fs[0] }, (_, c) => fs[1](dv, 0, c)).map((v) => +v.toPrecision(7)) : null; + return t.format + ' ' + mw + 'x' + mh + ' mip ' + mip + '/' + t.desc.mipLevelCount + ' @' + sx + ',' + sy + ' bytes ' + bytes.join(',') + (vals ? ' = ' + vals.join(', ') : ''); + } catch (e) { return t.format + ' unreadable: ' + e; } +} +// The pixel shader's inputs for a draw whose output has NaN: every bound texture at the texel (a bad one and a good one), and the constant buffers (as floats). +async function nanDetail(bx, by, gx, gy, tw, th) { + const lines = ['nanhunt detail for ' + nanHuntLabel + ': bad texel ' + bx + ',' + by + ', good texel ' + gx + ',' + gy]; + for (let i = 0; i < 32; i++) { + const sid = S.srv[1][i], srv = sid ? objs.get(sid) : null, t = srv && !srv.isBuf ? objs.get(srv.res) : null; + if (!t || t.kind !== 'texture') continue; + lines.push(' t' + i + ' res ' + srv.res + ' bad : ' + await nanReadTexel(t, bx, by, tw, th)); + if (t.desc.mipLevelCount > 1 && FLOAT_STAT_FORMATS[t.format] && t.desc.size.width <= 512) for (let m = 1; m < t.desc.mipLevelCount; m++) lines.push(' t' + i + ' res ' + srv.res + ' centre of mip ' + m + ': ' + await nanReadTexel(t, tw >> 1, th >> 1, tw, th, m)); + if (gx >= 0) lines.push(' t' + i + ' res ' + srv.res + ' good : ' + await nanReadTexel(t, gx, gy, tw, th)); + } + if (nanHuntPs && nanHuntPs.pack) for (const m of nanHuntPs.pack.members) { + const c = S.cb[1][m.binding], o = c.buf ? objs.get(c.buf) : null; + lines.push(' ps cb b' + m.binding + (o && o.shadow ? ' [' + Array.from(new Float32Array(o.shadow.buffer, o.shadow.byteOffset, Math.min(256, o.shadow.length >> 2))).map((x) => +x.toPrecision(6)).join(',') + ']' : ' (no CPU copy)')); + } + logLine(lines.join('\n')); +} +async function nanScanAfterDraw() { + const r = S.rt[0], t = r.tex ? objs.get(r.tex) : null; + if (!t || drawCount === nanHuntLastCount || t.desc.sampleCount > 1 || (t.format !== 'rgba16float' && t.format !== 'rg11b10ufloat') || t.desc.size.width < 600) return; + nanHuntLastCount = drawCount; + if (++nanHuntScans > 900) { nanHuntState = 3; logLine('nanhunt: stopped after 900 scans'); return; } + const fs = FLOAT_STAT_FORMATS[t.format], read = fs[1], bpp = TEXEL_BYTES[t.format]; + flush(); + const w = t.desc.size.width, h = t.desc.size.height, bpr = Math.ceil(w * bpp / 256) * 256; + const rb = device.createBuffer({ size: bpr * h, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }); + const enc = device.createCommandEncoder(); + enc.copyTextureToBuffer({ texture: t.tex }, { buffer: rb, bytesPerRow: bpr }, { width: w, height: h }); + device.queue.submit([enc.finish()]); + await rb.mapAsync(GPUMapMode.READ); + const dv = new DataView(rb.getMappedRange()); + let bad = 0, firstBad = '', bx = -1, by = -1, gx = -1, gy = -1; + for (let gj = 0; gj < 40; gj++) for (let gi = 0; gi < 64; gi++) { + const x = Math.min(w - 1, Math.floor((gi + 0.5) * w / 64)), y = Math.min(h - 1, Math.floor((gj + 0.5) * h / 40)), o = y * bpr + x * bpp; + let b = false; + for (let c = 0; c < 3; c++) { const v = read(dv, o, c); if (v !== v || v === Infinity || v === -Infinity || v > 1000 || v < -1000) b = true; } + if (b) { bad++; if (!firstBad) { firstBad = x + ',' + y; bx = x; by = y; } } else if (gx < 0 && gi > 8 && gj > 8) { gx = x; gy = y; } + } + rb.unmap(); rb.destroy(); + const prev = nanHuntPrev.get(r.tex); + if (bad !== (prev || 0) || prev === undefined) { + nanHuntPrev.set(r.tex, bad); + if (nanHuntLogged++ < 100) logLine('nanhunt: ' + nanHuntLabel + ' -> target ' + r.tex + ' ' + w + 'x' + h + ' ' + t.format + ': bad texels ' + (prev === undefined ? 'first look ' : prev + ' -> ') + bad + ' of 2560' + (bad ? ' (first at ' + firstBad + ')' : '')); + if (bad && !prev && nanHuntDetails < 2) { nanHuntDetails++; try { await nanDetail(bx, by, gx, gy, w, h); } catch (e) { logLine('nanhunt detail failed: ' + e); } } + } +} + +let frameSlotDone = Array(FRAME_SLOTS).fill(null); +let presentCount = 0; +let shotEvery = isNode ? +(process.env.WGPU_SHOT_EVERY || 0) : 0; +const shotPrefix = isNode ? (process.env.WGPU_SHOT_PREFIX || 'D:/wasm_tmp/shot_') : 'present'; +const shotAllRt = !isNode && new URLSearchParams(self.location.search).get('shotrt') === '1'; // the page's ?shotrt=1 (with ?shot=N): see present() +let shotAllRtDone = false; +async function present(id) { + const t = objs.get(id); + if (t && canvasCtx) { + endPass(); + // configure() reallocates the canvas's swap-chain textures: only on the first present and when the back buffer size changes (it ran every frame) + if (!canvasConfigured || canvas.width !== t.desc.size.width || canvas.height !== t.desc.size.height) { + canvas.width = t.desc.size.width; canvas.height = t.desc.size.height; + canvasCtx.configure({ device, format: canvasFormat, alphaMode: 'opaque' }); + canvasConfigured = true; + } + if (!blit) makeBlit(); + const pass2 = getEncoder().beginRenderPass({ colorAttachments: [{ view: canvasCtx.getCurrentTexture().createView(), loadOp: 'clear', storeOp: 'store' }] }); + pass2.setPipeline(blit); + if (!t.blitBG) t.blitBG = device.createBindGroup({ layout: blit.getBindGroupLayout(0), entries: [{ binding: 0, resource: t.tex.createView({ dimension: '2d', baseMipLevel: 0, mipLevelCount: 1 }) }] }); + pass2.setBindGroup(0, t.blitBG); + pass2.draw(3); + pass2.end(); + } + // debugging aid: WGPU_SHOT_EVERY= WGPU_SHOT_PREFIX= writes .png every n-th present + presentCount++; + { + const tn = performance.now(); + if (lastPresentT) { + const dt = tn - lastPresentT; + if (dt > frameMax) frameMax = dt; + if (dt > 25) over25++; + if (dt > SPIKE_MS) { + spikeCount++; + spikes.push({ dt, idle: fr.idle, pipe: fr.pipe, mod: fr.mod, up: fr.up, mb: fr.upBytes / 1048576, wait: fr.wait, flush: fr.flush }); + } + } + lastPresentT = tn; + fr.idle = fr.pipe = fr.mod = fr.up = fr.upBytes = fr.wait = fr.flush = 0; + } + { // every 10 s: frame rate and work per frame (visible in the session log) + const now = performance.now(); + if (!fpsT0) { fpsT0 = now; fpsCount0 = presentCount; fpsDraw0 = drawCount; } + else if (now - fpsT0 >= 10000) { + const fr = presentCount - fpsCount0; + logLine('fps: ' + (fr * 1000 / (now - fpsT0)).toFixed(1) + ' (' + fr + ' frames, ' + (((drawCount - fpsDraw0) / Math.max(1, fr)) | 0) + ' draws/frame, ' + ((submits - submits0) / Math.max(1, fr)).toFixed(1) + ' submits/frame: ' + ([...flushReasons].sort((a, b) => b[1] - a[1]).map(([k, n]) => k + ' ' + (n / Math.max(1, fr)).toFixed(1)).join(', ') || 'none') + '), draws waiting for a compiling pipeline +' + (pendingSkips - pendingSkips0) + ', validation errors +' + (errorCount - errorCount0) + ', clamped draws +' + (clampedDraws - clampedDraws0) + ', bind groups +' + (bgCreated - bgCreated0) + ' (cache ' + bindGroupCache.size + ', evicted ' + bgEvicted + '), pipelines +' + (pipeCreates - pipeCreates0) + ' (' + pipeMs.toFixed(0) + ' ms), worker busy ' + (busyMs * 100 / Math.max(1, busyMs + idleMs)).toFixed(0) + '% (' + (busyMs / Math.max(1, fr)).toFixed(1) + ' ms/frame)'); + busyMs = idleMs = 0; pipeCreates0 = pipeCreates; pipeMs = 0; bgCreated0 = bgCreated; submits0 = submits; flushReasons.clear(); errorCount0 = errorCount; clampedDraws0 = clampedDraws; pendingSkips0 = pendingSkips; + if (spikeCount || over25) { + spikes.sort((a, b) => b.dt - a.dt); + logLine('stutter: ' + over25 + ' frames > 25 ms, ' + spikeCount + ' > ' + SPIKE_MS + ' ms, worst ' + frameMax.toFixed(0) + ' ms; worst frames (ms: worker idle/pipeline/modules/uploads MB/gpu wait/submit): ' + + spikes.slice(0, 4).map((x) => x.dt.toFixed(0) + ': ' + x.idle.toFixed(0) + '/' + x.pipe.toFixed(0) + '/' + x.mod.toFixed(0) + '/' + x.up.toFixed(0) + ' ' + x.mb.toFixed(1) + 'MB/' + x.wait.toFixed(0) + '/' + x.flush.toFixed(0)).join(' | ')); + } + spikes = []; spikeCount = 0; frameMax = 0; over25 = 0; + fpsT0 = now; fpsCount0 = presentCount; fpsDraw0 = drawCount; + } + } + if (dbgIdx) { + Atomics.store(i32, dbgIdx + 1, dbgFrameDraw); + dbgFrameDraw = 0; + const now = Date.now(); + if (now - dbgLastPost > 250) { + dbgLastPost = now; + if (!dbgChannel) dbgChannel = new BroadcastChannel('game-debug'); + dbgChannel.postMessage({ limit: Atomics.load(i32, dbgIdx), total: Atomics.load(i32, dbgIdx + 1), last: dbgLastLabel }); + } + } + if (!isNode) { // the page's FPS counter (index.html, '=' key): presented frames per second, twice a second + const tn = performance.now(); + fpsOverlayN++; + if (!fpsOverlayT) { fpsOverlayT = tn; fpsOverlayN = 0; } + else if (tn - fpsOverlayT >= 500) { + if (!fpsChannel) fpsChannel = new BroadcastChannel('game-fps'); + fpsChannel.postMessage({ fps: fpsOverlayN * 1000 / (tn - fpsOverlayT) }); + fpsOverlayN = 0; fpsOverlayT = tn; + } + } + { // loading progress for the page (phase3/index.html): first frame, then the world. The world starts with the first frame with a real scene (loading screens draw ~10 + // times), but the page drops its title screen only once 1.5 s of frames went by without a draw skipped for a compiling pipeline (60 s at most): the first view + // needs a few hundred new pipelines, and on a slow GPU process the picture has holes until they are compiled. Node computes it too (the log line) but posts nothing. + const d = drawCount - lastPresentDraws, now = performance.now(); + lastPresentDraws = drawCount; + if (!isNode && !progressChannel) progressChannel = new BroadcastChannel('game-progress'); + if (!isNode && presentCount === 1) progressChannel.postMessage({ pct: 76, label: 'First frame' }); + if (!worldSent && (worldSince || d > 300)) { + if (!worldSince) { worldSince = now; worldSkips0 = pendingSkips; } + if (pendingSkips !== skipsAtPresent) worldClean = 0; else if (!worldClean) worldClean = now; + if ((worldClean && now - worldClean >= 1500) || now - worldSince >= 60000) { + worldSent = true; + logLine('world shown: title screen held ' + ((now - worldSince) / 1000).toFixed(1) + ' s for compiling pipelines (' + (pendingSkips - worldSkips0) + ' draws skipped meanwhile, ' + pipelinesPending + ' still compiling); compiled ahead ' + aheadMade + ', used ' + aheadUsed + ', compiled when first drawn ' + pipeCreates + '; shader variants for the inter-stage limit: ' + remapVariants[0] + ' vertex, ' + remapVariants[1] + ' pixel'); + if (!isNode) progressChannel.postMessage({ pct: 100, label: 'Ready', world: true }); + } else if (!isNode && now - worldNoteT >= 1000) { worldNoteT = now; progressChannel.postMessage({ compiling: pipelinesPending }); } + } + skipsAtPresent = pendingSkips; + if (!isNode && now - recipesSaveT >= 20000) { recipesSaveT = now; saveRecipes(); } + } + aheadStep(); + // ?shotrt=1 (browser): the world as it is 20 s after its first real frame - the back buffer, then every render target - once, whatever shotEvery says. A slow device presents the world at a few + // frames per second, so waiting for a multiple of shotEvery took minutes and the tab died first (Chromebook session of 2026-10-06: world from 15:36:05, killed 15:37:15, no dump). + // And every 10 s from the world's first frame: floatStats() of the float render targets (the picture is cheap, the numbers are what shows why a device renders white). + if (!isNode && shotAllRt && worldSent && performance.now() - rtStatsT >= 10000) { + rtStatsT = performance.now(); + let n = 0; + for (const tid of [...frameStats.rts]) { const tt = objs.get(tid); if (tt && tt.desc.size.width >= 256 && n < 20) { n++; await floatStats(tid); } } + } + if (!isNode && shotAllRt) { // the NaN hunt's frame: from this present to the next + if (nanHuntState === 2) { nanHuntState = 3; logLine('nanhunt: frame finished, ' + nanHuntScans + ' draws into HDR targets scanned'); } + else if (nanHuntState === 0 && worldSince && performance.now() - worldSince >= 30000) { nanHuntState = 2; logLine('nanhunt: scanning the next frame draw by draw'); } + } + if (!isNode && shotAllRt && !shotAllRtDone && worldSince && performance.now() - worldSince >= 20000) { + shotAllRtDone = true; + logLine('shotrt: dumping the world, present ' + presentCount + ', ' + ((performance.now() - worldSince) / 1000).toFixed(1) + ' s after its first frame'); + await screenshot(id, 'world' + String(presentCount).padStart(6, '0') + '.png'); + const rtsCopy = new Set(frameStats.rts); dumpFrameStats(); frameStats.rts = rtsCopy; + await dumpAllTargets(); + } + // every shotEvery-th present: draw statistics; with WGPU_SHOT_ALLRT (Node) every render target of that frame, with ?shotrt=1 (browser: posted to the dev server's shots/) once, + // the first time after the world is shown (diagnosis of a device that renders differently) + const allRt = isNode ? !!process.env.WGPU_SHOT_ALLRT : (shotAllRt && worldSent && !shotAllRtDone); + if (shotEvery && t && presentCount % shotEvery === 0) { const rtsCopy = new Set(frameStats.rts); dumpFrameStats(); if (allRt) { shotAllRtDone = true; frameStats.rts = rtsCopy; await dumpAllTargets(); } } + if (shotEvery && t && presentCount % shotEvery === 0) { + await screenshot(id, shotPrefix + String(presentCount).padStart(6, '0') + '.png'); + for (const tid of (isNode ? process.env.WGPU_SHOT_TEXS || '' : '').split(',').filter(Boolean)) await screenshot(+tid, shotPrefix + 'tex' + tid + '_' + String(presentCount).padStart(6, '0') + '.png'); + } + flush('present'); + frameSlotDone[ubo.slot] = device.queue.onSubmittedWorkDone(); + ubo.slot = (ubo.slot + 1) % FRAME_SLOTS; ubo.chunk = 0; ubo.off = 0; ubo.frame++; + const tw0 = performance.now(); + if (frameSlotDone[ubo.slot]) await frameSlotDone[ubo.slot]; // the ring slot we are about to reuse must be idle + fr.wait += performance.now() - tw0; +} + +// ---- command dispatcher --------------------------------------------------------------------------------------------------------------- +function setRange(dst, start, n, src) { for (let i = 0; i < n; i++) dst[start + i] = src(i); } + +// Completion callbacks (onSubmittedWorkDone, mapAsync: they complete the engine's frame-latency fence and readbacks) are delivered as macrotasks, but this loop only awaits +// already-resolved promises, so under load it never let the event loop run: fences completed at the next idle gap and the engine polled them for ~25 ms per frame (a flat +// 25 fps with the worker half idle). A MessageChannel round trip is a cheap macrotask boundary. +const yieldChannel = new MessageChannel(); +let yieldResolve = null; +yieldChannel.port1.onmessage = () => { const r = yieldResolve; yieldResolve = null; if (r) r(); }; +if (yieldChannel.port1.unref) { yieldChannel.port1.unref(); yieldChannel.port2.unref(); } +function yieldTask() { return new Promise((res) => { yieldResolve = res; yieldChannel.port2.postMessage(0); }); } +let sinceYield = 0, executedLocal = 0, lastYieldT = 0; + +async function runCommands(tail, head) { + // executes [tail, head) (byte offsets relative to ringBase); returns the new tail + while (tail !== head) { + const base = ringW + (tail >> 2); + const op = u32[base], n = u32[base + 1]; + if (op === OP.WRAP) { tail = RING_DATA; continue; } + const p = base + 2; + switch (op) { // numeric labels (OP.* in comments): V8 compiles constant Smi cases to a jump table; `case OP.X` was a chain of property loads and compares per command + case 0 /* NOP */: case 2 /* INIT */: break; + case 3 /* CREATE_TEXTURE */: createTexture(u32[p], u32[p + 1], u32[p + 2], u32[p + 3], u32[p + 4], u32[p + 5], u32[p + 6], u32[p + 7], u32[p + 8], u32[p + 9]); break; + case 4 /* DESTROY_OBJECT */: { + // the pipeline lookup only has to run again if the object is bound now (a vertex buffer's presence is part of the key; the states and shaders are): streaming destroys + // objects all the time, and each forced a full lookup on the next draw + if (isBound(u32[p])) pdirty = true; + const o = objs.get(u32[p]); + if (o) { + if (o.inBG) gEpoch++; // a cached bind group may hold a view of it + if (usedInEncoder.has(o)) flush('destroy'); + if (o.tex) { o.tex.destroy(); texBytesAlive -= o.bytes || 0; texCount--; } + if (o.gpu) { o.gpu.destroy(); bufBytesAlive -= o.bytes || 0; } + objs.delete(u32[p]); + } + break; + } + case 5 /* CLEAR_RT */: clearRT(u32[p], u32[p + 1], u32[p + 2], f32[p + 3], f32[p + 4], f32[p + 5], f32[p + 6]); break; + case 6 /* CLEAR_DS */: clearDS(u32[p], u32[p + 1], u32[p + 2], u32[p + 3], f32[p + 4], u32[p + 5]); break; + case 7 /* PRESENT */: await present(u32[p]); refreshViews(); break; + case 8 /* FENCE */: { + flush('fence'); + await device.queue.onSubmittedWorkDone(); + refreshViews(); + const addr = u32[p] + u32[p + 1] * 4294967296; + Atomics.store(i32, w32(addr), u32[p + 2] | 0); + Atomics.notify(i32, w32(addr)); + break; + } + case 9 /* SCREENSHOT */: await screenshot(u32[p], readString(p + 2, u32[p + 1])); refreshViews(); break; + case 10 /* LOG */: { const text = readString(p + 1, u32[p]); if (text === 'stats') logLine('stats: GPU memory now: textures ' + (texBytesAlive / 1048576 | 0) + ' MB in ' + texCount + ' textures (peak ' + (texBytesPeak / 1048576 | 0) + ' MB), buffers ' + (bufBytesAlive / 1048576 | 0) + ' MB (peak ' + (bufBytesPeak / 1048576 | 0) + ' MB)'); if (text === 'stats') dumpMemBreakdown(); if (text === 'stats') dumpFrameStats(); if (text === 'stats') logLine('stats: draws ' + drawCount + ' (skipped ' + skippedDraws + '), indirect draws ' + indirectDraws + ', dispatches ' + dispatchCount + ', queries ' + queries.size + ', occlusion slots used ' + occlusion.next); else logLine(text); break; } + case 11 /* CREATE_BUFFER */: createBuffer(u32[p], u32[p + 1], u32[p + 2], u32[p + 3], u32[p + 4]); break; + case 12 /* UPLOAD_BUFFER */: case 47 /* UPLOAD_BUFFER_NO_OVERWRITE */: { + // timed only when large (the stutter breakdown): most uploads are small constant-buffer copies, thousands per frame, and two performance.now() each added up + const sz = u32[p + 2], big = sz >= 65536, t0 = big ? performance.now() : 0; + uploadBuffer(u32[p], u32[p + 1], sz, (p + 3) * 4, op === 47); + if (big) fr.up += performance.now() - t0; + fr.upBytes += sz; + break; + } + case 13 /* UPLOAD_TEXTURE */: { const t0 = performance.now(); fr.upBytes += u32[p + 11]; uploadTexture(u32[p], u32[p + 1], u32[p + 2], u32[p + 3], u32[p + 4], u32[p + 5], u32[p + 6], u32[p + 7], u32[p + 8], u32[p + 9], u32[p + 10], u32[p + 11], (p + 12) * 4); fr.up += performance.now() - t0; break; } + case 14 /* CREATE_SHADER */: createShader(p, n); break; + case 15 /* CREATE_LAYOUT */: createLayout(p); break; + case 16 /* CREATE_STATE */: createState(p, n); break; + case 17 /* CREATE_SRV */: createSrv(p); break; + case 18 /* SET_SHADER */: if (u32[p] === 2 && debugCs && (setCsLogged++ < 30)) logLine('SET_SHADER cs -> ' + u32[p + 1] + (objs.get(u32[p + 1]) ? ' (' + objs.get(u32[p + 1]).kind + ' ' + objs.get(u32[p + 1]).hash + ')' : ' (unknown object)')); + if (S.shader[u32[p]] !== u32[p + 1]) { S.shader[u32[p]] = u32[p + 1]; pdirty = true; } break; + case 19 /* SET_INPUT_LAYOUT */: if (S.layout !== u32[p]) { S.layout = u32[p]; pdirty = true; } break; + case 20 /* SET_TOPOLOGY */: if (S.topo !== u32[p]) { S.topo = u32[p]; pdirty = true; } break; + case 21 /* SET_VERTEX_BUFFERS */: { const s = u32[p], c = u32[p + 1]; for (let i = 0; i < c && s + i < 16; i++) { const v = S.vb[s + i]; const nb = u32[p + 2 + i * 3], ns = u32[p + 3 + i * 3]; if (v.stride !== ns || !v.buf !== !nb) pdirty = true; v.buf = nb; v.stride = ns; v.offset = u32[p + 4 + i * 3]; } break; } + case 22 /* SET_INDEX_BUFFER */: if (S.ib.fmt !== u32[p + 1] || !S.ib.buf !== !u32[p]) pdirty = true; S.ib.buf = u32[p]; S.ib.fmt = u32[p + 1]; S.ib.offset = u32[p + 2]; break; + case 23 /* SET_CBUFFERS */: { bindEpoch[u32[p]]++; const st = u32[p], s = u32[p + 1], c = u32[p + 2]; for (let i = 0; i < c && s + i < 16; i++) { const v = S.cb[st][s + i]; v.buf = u32[p + 3 + i * 3]; v.first = u32[p + 4 + i * 3]; v.num = u32[p + 5 + i * 3]; } break; } + case 24 /* SET_SRVS */: { bindEpoch[u32[p]]++; const st = u32[p], s = u32[p + 1], c = u32[p + 2]; for (let i = 0; i < c && s + i < 128; i++) S.srv[st][s + i] = u32[p + 3 + i]; break; } + case 25 /* SET_SAMPLERS */: { bindEpoch[u32[p]]++; const st = u32[p], s = u32[p + 1], c = u32[p + 2]; for (let i = 0; i < c && s + i < 16; i++) S.smp[st][s + i] = u32[p + 3 + i]; break; } + case 26 /* SET_RENDER_TARGETS */: { + for (let i = 0; i < 8; i++) { const r = S.rt[i]; r.tex = u32[p + i * 4]; r.mip = u32[p + 1 + i * 4]; r.slice = u32[p + 2 + i * 4]; r.fmt = u32[p + 3 + i * 4]; } + const q = p + 32, d = S.ds; d.tex = u32[q]; d.mip = u32[q + 1]; d.slice = u32[q + 2]; d.fmt = u32[q + 3]; d.flags = u32[q + 4]; + rtKey = null; + pdirty = true; + break; + } + case 27 /* SET_BLEND */: { if (S.blend.id !== u32[p]) pdirty = true; const b = S.blend, f = b.factor; b.id = u32[p]; f[0] = f32[p + 1]; f[1] = f32[p + 2]; f[2] = f32[p + 3]; f[3] = f32[p + 4]; b.mask = u32[p + 5]; break; } // in place: these state ops run between most draws, a new object each time fed the GC + case 28 /* SET_DEPTH_STENCIL */: if (S.dss.id !== u32[p]) pdirty = true; S.dss.id = u32[p]; S.dss.ref = u32[p + 1]; break; + case 29 /* SET_RASTER */: if (S.rs !== u32[p]) pdirty = true; S.rs = u32[p]; break; + case 30 /* SET_VIEWPORTS */: { const c = u32[p], vs = S.viewports; vs.length = c; for (let i = 0; i < c; i++) { const v = vs[i] || (vs[i] = [0, 0, 0, 0, 0, 0]); for (let k = 0; k < 6; k++) v[k] = f32[p + 1 + i * 6 + k]; } break; } + case 31 /* SET_SCISSORS */: { const c = u32[p], ss = S.scissors; ss.length = c; for (let i = 0; i < c; i++) { const r = ss[i] || (ss[i] = [0, 0, 0, 0]); for (let k = 0; k < 4; k++) r[k] = u32[p + 1 + i * 4 + k]; } break; } + case 32 /* DRAW */: if (!isNode && !shaderSourcesReady()) { await ensureShaderSources(); refreshViews(); } doDraw(p); if (debugPsProbe) { await probeSmallSrvs(); refreshViews(); } if (debugDraw && drawCount > debugDraw && drawCount <= debugDraw + debugDrawN) { await probeTarget(); refreshViews(); } if (nanHuntState === 2) { await nanScanAfterDraw(); refreshViews(); } break; + case 33 /* CLEAR_STATE */: resetState(); break; + case 37 /* CREATE_UAV */: createUav(p); break; + case 41 /* GENERATE_MIPS */: generateMips(u32[p]); break; + case 42 /* READBACK */: { // the copy is recorded and submitted now (queue order is kept); only the mapping is awaited, without blocking this command loop + const flagAddr = u32[p + 15] + u32[p + 16] * 4294967296; + const done = () => { if (flagAddr) { refreshViews(); Atomics.store(i32, w32(flagAddr), 0); Atomics.notify(i32, w32(flagAddr)); } }; + readback(p).catch((e) => logLine('readback failed: ' + (e && e.message || e))).finally(done); + break; + } + case 38 /* SET_UAVS */: { bindEpoch[u32[p]]++; const st = u32[p], s0 = u32[p + 1], c = u32[p + 2]; for (let i = 0; i < c && s0 + i < 8; i++) { S.uav[st][s0 + i] = u32[p + 3 + i]; if (u32[p + 3 + c + i] !== 0xffffffff) setUavCounter(u32[p + 3 + i], u32[p + 3 + c + i]); } break; } + case 44 /* CREATE_QUERY */: createQuery(u32[p], u32[p + 1], u32[p + 2] + u32[p + 3] * 4294967296); break; + case 45 /* BEGIN_QUERY */: beginQuery(u32[p]); break; + case 46 /* END_QUERY */: endQuery(u32[p], u32[p + 1]); break; + case 43 /* COPY_COUNTER */: copyCounter(u32[p], u32[p + 1], u32[p + 2]); if (debugCounters && counterLogged < debugCounters) { counterLogged++; await logCounter(u32[p + 2]); refreshViews(); } break; + case 39 /* DISPATCH */: if (!isNode && !shaderSourcesReady()) { await ensureShaderSources(); refreshViews(); } doDispatch(u32[p], u32[p + 1], u32[p + 2]); if (debugCsProbe) { debugCsProbe = false; await probeUavs(); refreshViews(); } break; + case 40 /* CLEAR_UAV */: clearUav(u32[p], u32[p + 1], [u32[p + 2], u32[p + 3], u32[p + 4], u32[p + 5]]); break; + case 34 /* COPY_REGION */: copyRegion(u32[p], u32[p + 1], u32[p + 2], u32[p + 3], u32[p + 4], u32[p + 5], u32[p + 6], u32[p + 7], u32[p + 8], u32[p + 9], u32[p + 10], u32[p + 11], u32[p + 12], u32[p + 13]); break; + case 35 /* COPY_RESOURCE */: copyResource(u32[p], u32[p + 1]); break; + case 36 /* RESOLVE */: resolve(u32[p], u32[p + 1], u32[p + 2], u32[p + 3]); break; + default: logLine('unknown opcode ' + op); break; + } + executedLocal++; // published in batches (statistics only): an atomic add per command was measurable at ~25,000 commands per frame + tail += n * 4 + 8; + if (++sinceYield >= 512) { + sinceYield = 0; + Atomics.add(i32, ringW + 3, executedLocal); executedLocal = 0; + Atomics.store(i32, ringW + 1, tail); // let the producers reuse the ring space already consumed + Atomics.notify(i32, ringW + 1); + // The event loop gets a turn at most every 2 ms (completion callbacks: fences, readbacks, queries): a MessageChannel round trip per 512 commands was ~50 per frame + const tn = performance.now(); + if (tn - lastYieldT >= 2) { + await yieldTask(); + refreshViews(); + lastYieldT = performance.now(); + } + } + // The views are refreshed after each await above (another thread may have grown the memory meanwhile), not after every command: the `mem.buffer` getter is a runtime + // call (~1 % of this worker). Between awaits the commands only touch the ring, which lies inside the views; paths that write to other addresses refresh themselves. + } + return tail; +} + +async function loop() { + const hi = ringW, ti = hi + 1; + let tail = RING_DATA; + Atomics.store(i32, ti, tail); + Atomics.store(i32, hi + 2, 1); + for (;;) { + refreshViews(); + const head = Atomics.load(i32, hi); + if (head === tail) { + if (pendingEvents.length || pendingResolve.length) { flush('idle'); onSubmitted(); } // nobody is producing: let waiting fences/queries finish + aheadStep(); // pipelines compiled ahead (while the game loads, the worker is mostly idle) + const w0 = performance.now(); + // producers only notify while `sleeping` (header word 5) is set (wgpu_backend.cpp Publish): set it, then re-read head so a command published in between is not missed + Atomics.store(i32, hi + 5, 1); + if (Atomics.load(i32, hi) !== tail) { Atomics.store(i32, hi + 5, 0); continue; } + const r = typeof Atomics.waitAsync === 'function' ? Atomics.waitAsync(i32, hi, tail, 100) : null; + if (r && r.async) await r.value; + else if (!r) await new Promise((res) => setTimeout(res, 1)); + Atomics.store(i32, hi + 5, 0); + idleMs += performance.now() - w0; fr.idle += performance.now() - w0; + continue; + } + const b0 = performance.now(); + tail = await runCommands(tail, head); + if (executedLocal) { Atomics.add(i32, ringW + 3, executedLocal); executedLocal = 0; } + busyMs += performance.now() - b0; + refreshViews(); + Atomics.store(i32, ti, tail); + Atomics.notify(i32, ti); + } +} + +async function start(msg) { + logLine('start: ring ' + msg.ring + ' size ' + msg.size + ' canvas ' + !!msg.canvas + ' shaders ' + msg.shaderUrl); + mem = msg.memory; + if (msg.shaderUrl) shaderUrl = msg.shaderUrl; + if (!isNode && msg.shotEvery) shotEvery = msg.shotEvery; + ringBase = msg.ring; + ringW = w32(ringBase); + ringSize = msg.size; + if (msg.dbg) dbgIdx = w32(msg.dbg + 424); // WasmInputBlock.dbgDrawLimit (platform/input/browser_input_wasm.cpp) + refreshViews(); + try { + await initDevice(msg); + } catch (e) { + logLine('init failed: ' + (e && e.stack || e)); + Atomics.store(i32, ringW + 2, 2); + // drain forever so the producers never block + for (;;) { + refreshViews(); + const h = Atomics.load(i32, ringW); + Atomics.store(i32, ringW + 1, h); + Atomics.notify(i32, ringW + 1); + await new Promise((res) => setTimeout(res, 5)); + } + } + post({ ready: true }); + loadRecipes().catch((e) => logLine('pipeline recipes not loaded: ' + (e && e.message))); + await loop(); +} + +if (!isNode) { + self.addEventListener('error', (e) => logLine('worker error: ' + e.message + ' ' + e.filename + ':' + e.lineno)); + self.addEventListener('unhandledrejection', (e) => logLine('worker rejection: ' + (e.reason && e.reason.stack || e.reason))); + logLine('worker script loaded'); + self.postMessage({ loaded: true }); // loader.js waits for this before it starts the engine (see there) +} +if (isNode && parentPort) parentPort.on('message', (m) => { start(m); }); +else if (!isNode) self.onmessage = (ev) => { start(ev.data); }; +if (typeof module !== 'undefined') module.exports = { packUniforms, parseWgsl }; diff --git a/favicon.ico b/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..7a6c6874616ee08a310cb53f0c724a2cf6a743ff Binary files /dev/null and b/favicon.ico differ diff --git a/index.html b/index.html new file mode 100644 index 0000000000000000000000000000000000000000..d9fda20a37f69c5fc96b013b26e8b77249ce1692 --- /dev/null +++ b/index.html @@ -0,0 +1,603 @@ + + + + +game + + + + +
+
Starting...0%
+
+ + + diff --git a/robots.txt b/robots.txt new file mode 100644 index 0000000000000000000000000000000000000000..7d329b1db3f0b9383f111d23fc0c945b7e957017 --- /dev/null +++ b/robots.txt @@ -0,0 +1 @@ +User-agent: *