`;
+ return div.firstElementChild;
+}
diff --git a/web/js/common/utils.js b/web/js/common/utils.js
new file mode 100644
index 0000000..cd7539d
--- /dev/null
+++ b/web/js/common/utils.js
@@ -0,0 +1,30 @@
+import { $el } from "../../../../scripts/ui.js";
+
+export function addStylesheet(url) {
+ if (url.endsWith(".js")) {
+ url = url.substr(0, url.length - 2) + "css";
+ }
+ $el("link", {
+ parent: document.head,
+ rel: "stylesheet",
+ type: "text/css",
+ href: url.startsWith("http") ? url : getUrl(url),
+ });
+}
+
+export function getUrl(path, baseUrl) {
+ if (baseUrl) {
+ return new URL(path, baseUrl).toString();
+ } else {
+ return new URL("../" + path, import.meta.url).toString();
+ }
+}
+
+export async function loadImage(url) {
+ return new Promise((res, rej) => {
+ const img = new Image();
+ img.onload = res;
+ img.onerror = rej;
+ img.src = url;
+ });
+}
diff --git a/web/js/libs/coloris.min.js b/web/js/libs/coloris.min.js
new file mode 100644
index 0000000..017d102
--- /dev/null
+++ b/web/js/libs/coloris.min.js
@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) 2021 Momo Bassit.
+ * Licensed under the MIT License (MIT)
+ * https://github.com/mdbassit/Coloris
+ */
+!function(u,d,s,c){var p,f,h,i,b,v,y,g,m,l,w,k,L,E,a,n,r=d.createElement("canvas").getContext("2d"),x={r:0,g:0,b:0,h:0,s:0,v:0,a:1},A={},S={el:"[data-coloris]",parent:"body",theme:"default",themeMode:"light",rtl:!1,wrap:!0,margin:2,format:"hex",formatToggle:!1,swatches:[],swatchesOnly:!1,alpha:!0,forceAlpha:!1,focusInput:!0,selectInput:!1,inline:!1,defaultColor:"#000000",clearButton:!1,clearLabel:"Clear",closeButton:!1,closeLabel:"Close",onChange:function(){return c},a11y:{open:"Open color picker",close:"Close color picker",clear:"Clear the selected color",marker:"Saturation: {s}. Brightness: {v}.",hueSlider:"Hue slider",alphaSlider:"Opacity slider",input:"Color value field",format:"Color format",swatch:"Color swatch",instruction:"Saturation and brightness selector. Use up, down, left and right arrow keys to select."}},o={},C="",T={},B=!1;function M(e){if("object"==typeof e)for(var t in e)switch(t){case"el":N(e.el),!1!==e.wrap&&j(e.el);break;case"parent":(p=d.querySelector(e.parent))&&(p.appendChild(f),S.parent=e.parent,p===d.body&&(p=c));break;case"themeMode":S.themeMode=e.themeMode,"auto"===e.themeMode&&u.matchMedia&&u.matchMedia("(prefers-color-scheme: dark)").matches&&(S.themeMode="dark");case"theme":e.theme&&(S.theme=e.theme),f.className="clr-picker clr-"+S.theme+" clr-"+S.themeMode,S.inline&&I();break;case"rtl":S.rtl=!!e.rtl,d.querySelectorAll(".clr-field").forEach(function(e){return e.classList.toggle("clr-rtl",S.rtl)});break;case"margin":e.margin*=1,S.margin=(isNaN(e.margin)?S:e).margin;break;case"wrap":e.el&&e.wrap&&j(e.el);break;case"formatToggle":S.formatToggle=!!e.formatToggle,z("clr-format").style.display=S.formatToggle?"block":"none",S.formatToggle&&(S.format="auto");break;case"swatches":Array.isArray(e.swatches)&&function(){var a=[];e.swatches.forEach(function(e,t){a.push('")}),z("clr-swatches").innerHTML=a.length?"
"+a.join("")+"
":"",S.swatches=e.swatches.slice()}();break;case"swatchesOnly":S.swatchesOnly=!!e.swatchesOnly,f.setAttribute("data-minimal",S.swatchesOnly);break;case"alpha":S.alpha=!!e.alpha,f.setAttribute("data-alpha",S.alpha);break;case"inline":S.inline=!!e.inline,f.setAttribute("data-inline",S.inline),S.inline&&(l=e.defaultColor||S.defaultColor,E=q(l),I(),W(l));break;case"clearButton":"object"==typeof e.clearButton&&(e.clearButton.label&&(S.clearLabel=e.clearButton.label,y.innerHTML=S.clearLabel),e.clearButton=e.clearButton.show),S.clearButton=!!e.clearButton,y.style.display=S.clearButton?"block":"none";break;case"clearLabel":S.clearLabel=e.clearLabel,y.innerHTML=S.clearLabel;break;case"closeButton":S.closeButton=!!e.closeButton,S.closeButton?f.insertBefore(g,b):b.appendChild(g);break;case"closeLabel":S.closeLabel=e.closeLabel,g.innerHTML=S.closeLabel;break;case"a11y":var a,l,r=e.a11y,n=!1;if("object"==typeof r)for(var o in r)r[o]&&S.a11y[o]&&(S.a11y[o]=r[o],n=!0);n&&(a=z("clr-open-label"),l=z("clr-swatch-label"),a.innerHTML=S.a11y.open,l.innerHTML=S.a11y.swatch,g.setAttribute("aria-label",S.a11y.close),y.setAttribute("aria-label",S.a11y.clear),m.setAttribute("aria-label",S.a11y.hueSlider),w.setAttribute("aria-label",S.a11y.alphaSlider),v.setAttribute("aria-label",S.a11y.input),h.setAttribute("aria-label",S.a11y.instruction));break;default:S[t]=e[t]}}function H(e,t){"string"==typeof e&&"object"==typeof t&&(o[e]=t,B=!0)}function O(e){delete o[e],0===Object.keys(o).length&&(B=!1,e===C&&D())}function t(l){if(B){var e,r=["el","wrap","rtl","inline","defaultColor","a11y"];for(e in o)if("break"===function(e){var t=o[e];if(l.matches(e)){for(var a in C=e,T={},r.forEach(function(e){return delete t[e]}),t)T[a]=Array.isArray(S[a])?S[a].slice():S[a];return M(t),"break"}}(e))break}}function D(){0r.clientWidth&&(a+=t.width-o,i.left=!0),l+c>r.clientHeight-e&&c+S.margin<=t.top-(s.y-n)&&(l-=t.height+c+2*S.margin,i.top=!0),l+=r.scrollTop):(a+o>d.documentElement.clientWidth&&(a+=t.width-o,i.left=!0),l+c-n>d.documentElement.clientHeight&&c+S.margin<=t.top&&(l=n+t.y-c-S.margin,i.top=!0)),f.classList.toggle("clr-left",i.left),f.classList.toggle("clr-top",i.top),f.style.left=a+"px",f.style.top=l+"px",s.x+=f.offsetLeft,s.y+=f.offsetTop),A={width:h.offsetWidth,height:h.offsetHeight,x:h.offsetLeft+s.x,y:h.offsetTop+s.y}}function j(e){d.querySelectorAll(e).forEach(function(e){var t,a,l=e.parentNode;l.classList.contains("clr-field")||(t=d.createElement("div"),a="clr-field",(S.rtl||e.classList.contains("clr-rtl"))&&(a+=" clr-rtl"),t.innerHTML='',l.insertBefore(t,e),t.setAttribute("class",a),t.style.color=e.value,t.appendChild(e))})}function R(e){var t;L&&!S.inline&&(t=L,e&&(L=c,a!==t.value&&(t.value=a,t.dispatchEvent(new Event("input",{bubbles:!0})))),setTimeout(function(){a!==t.value&&t.dispatchEvent(new Event("change",{bubbles:!0}))}),f.classList.remove("clr-open"),B&&D(),t.dispatchEvent(new Event("close",{bubbles:!0})),S.focusInput&&t.focus({preventScroll:!0}),L=c)}function W(e){var t=function(e){r.fillStyle="#000",r.fillStyle=e,e=(e=/^((rgba)|rgb)[\D]+([\d.]+)[\D]+([\d.]+)[\D]+([\d.]+)[\D]*?([\d.]+|$)/i.exec(r.fillStyle))?{r:+e[3],g:+e[4],b:+e[5],a:+e[6]}:(e=r.fillStyle.replace("#","").match(/.{2}/g).map(function(e){return parseInt(e,16)}),{r:e[0],g:e[1],b:e[2],a:1});return e}(e),e=function(e){var t=e.r/255,a=e.g/255,l=e.b/255,r=s.max(t,a,l),n=s.min(t,a,l),o=r-n,c=r,i=0,n=0;o&&(r===t&&(i=(a-l)/o),r===a&&(i=2+(l-t)/o),r===l&&(i=4+(t-a)/o),r&&(n=o/r));return{h:(i=s.floor(60*i))<0?i+360:i,s:s.round(100*n),v:s.round(100*c),a:e.a}}(t);P(e.s,e.v),G(t,e),m.value=e.h,f.style.color="hsl("+e.h+", 100%, 50%)",l.style.left=e.h/360*100+"%",i.style.left=A.width*e.s/100+"px",i.style.top=A.height-A.height*e.v/100+"px",w.value=100*e.a,k.style.left=100*e.a+"%"}function q(e){e=e.substring(0,3).toLowerCase();return"rgb"===e||"hsl"===e?e:"hex"}function F(e){e=e!==c?e:v.value,L&&(L.value=e,L.dispatchEvent(new Event("input",{bubbles:!0}))),S.onChange&&S.onChange.call(u,e,L),d.dispatchEvent(new CustomEvent("coloris:pick",{detail:{color:e,currentEl:L}}))}function Y(e,t){e={h:+m.value,s:e/A.width*100,v:100-t/A.height*100,a:w.value/100},t=function(e){var t=e.s/100,a=e.v/100,l=t*a,r=e.h/60,n=l*(1-s.abs(r%2-1)),o=a-l;l+=o,n+=o;t=s.floor(r)%6,a=[l,n,o,o,n,l][t],r=[n,l,l,n,o,o][t],t=[o,o,n,l,l,n][t];return{r:s.round(255*a),g:s.round(255*r),b:s.round(255*t),a:e.a}}(e);P(e.s,e.v),G(t,e),F()}function P(e,t){var a=S.a11y.marker;e=+e.toFixed(1),t=+t.toFixed(1),a=(a=a.replace("{s}",e)).replace("{v}",t),i.setAttribute("aria-label",a)}function U(e){var t={pageX:((a=e).changedTouches?a.changedTouches[0]:a).pageX,pageY:(a.changedTouches?a.changedTouches[0]:a).pageY},a=t.pageX-A.x,t=t.pageY-A.y;p&&(t+=p.scrollTop),X(a,t),e.preventDefault(),e.stopPropagation()}function X(e,t){e=e<0?0:e>A.width?A.width:e,t=t<0?0:t>A.height?A.height:t,i.style.left=e+"px",i.style.top=t+"px",Y(e,t),i.focus()}function G(e,t){void 0===t&&(t={});var a,l,r=S.format;for(a in e=void 0===e?{}:e)x[a]=e[a];for(l in t)x[l]=t[l];var n,o=function(e){var t=e.r.toString(16),a=e.g.toString(16),l=e.b.toString(16),r="";e.r<16&&(t="0"+t);e.g<16&&(a="0"+a);e.b<16&&(l="0"+l);S.alpha&&(e.a<1||S.forceAlpha)&&(e=255*e.a|0,r=e.toString(16),e<16&&(r="0"+r));return"#"+t+a+l+r}(x),c=o.substring(0,7);switch(i.style.color=c,k.parentNode.style.color=c,k.style.color=o,b.style.color=o,h.style.display="none",h.offsetHeight,h.style.display="",k.nextElementSibling.style.display="none",k.nextElementSibling.offsetHeight,k.nextElementSibling.style.display="","mixed"===r?r=1===x.a?"hex":"rgb":"auto"===r&&(r=E),r){case"hex":v.value=o;break;case"rgb":v.value=(n=x,!S.alpha||1===n.a&&!S.forceAlpha?"rgb("+n.r+", "+n.g+", "+n.b+")":"rgba("+n.r+", "+n.g+", "+n.b+", "+n.a+")");break;case"hsl":v.value=(n=function(e){var t,a=e.v/100,l=a*(1-e.s/100/2);0
'+S.a11y.open+''+S.a11y.swatch+"",d.body.appendChild(f),h=z("clr-color-area"),i=z("clr-color-marker"),y=z("clr-clear"),g=z("clr-close"),b=z("clr-color-preview"),v=z("clr-color-value"),m=z("clr-hue-slider"),l=z("clr-hue-marker"),w=z("clr-alpha-slider"),k=z("clr-alpha-marker"),N(S.el),j(S.el),J(f,"mousedown",function(e){f.classList.remove("clr-keyboard-nav"),e.stopPropagation()}),J(h,"mousedown",function(e){J(d,"mousemove",U)}),J(h,"touchstart",function(e){d.addEventListener("touchmove",U,{passive:!1})}),J(i,"mousedown",function(e){J(d,"mousemove",U)}),J(i,"touchstart",function(e){d.addEventListener("touchmove",U,{passive:!1})}),J(v,"change",function(e){var t=v.value;(L||S.inline)&&F(""===t?t:W(t))}),J(y,"click",function(e){F(""),R()}),J(g,"click",function(e){F(),R()}),J(z("clr-format"),"click",".clr-format input",function(e){E=e.target.value,G(),F()}),J(f,"click",".clr-swatches button",function(e){W(e.target.textContent),F(),S.swatchesOnly&&R()}),J(d,"mouseup",function(e){d.removeEventListener("mousemove",U)}),J(d,"touchend",function(e){d.removeEventListener("touchmove",U)}),J(d,"mousedown",function(e){n=!1,f.classList.remove("clr-keyboard-nav"),R()}),J(d,"keydown",function(e){var t,a=e.key,l=e.target,r=e.shiftKey;"Escape"===a?R(!0):["Tab","ArrowUp","ArrowDown","ArrowLeft","ArrowRight"].includes(a)&&(n=!0,f.classList.add("clr-keyboard-nav")),"Tab"===a&&l.matches(".clr-picker *")&&(a=(t=$()).shift(),t=t.pop(),r&&l===a?(t.focus(),e.preventDefault()):r||l!==t||(a.focus(),e.preventDefault()))}),J(d,"click",".clr-field button",function(e){B&&D(),e.target.nextElementSibling.dispatchEvent(new Event("click",{bubbles:!0}))}),J(i,"keydown",function(e){var t={ArrowUp:[0,-1],ArrowDown:[0,1],ArrowLeft:[-1,0],ArrowRight:[1,0]};Object.keys(t).includes(e.key)&&(!function(e,t){X(+i.style.left.replace("px","")+e,+i.style.top.replace("px","")+t)}.apply(void 0,t[e.key]),e.preventDefault())}),J(h,"click",U),J(m,"input",e),J(w,"input",K)})}(window,document,Math);
\ No newline at end of file
diff --git a/web/js/threeVisualizer.js b/web/js/threeVisualizer.js
new file mode 100644
index 0000000..7dd5fc5
--- /dev/null
+++ b/web/js/threeVisualizer.js
@@ -0,0 +1,177 @@
+import * as THREE from 'three';
+import { api } from '/scripts/api.js';
+import {getRGBValue} from '/extensions/Comfy-Rodin/js/sharedFunctions.js';
+
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { RoomEnvironment } from 'three/addons/environments/RoomEnvironment.js';
+
+import { MTLLoader } from 'three/addons/loaders/MTLLoader.js';
+import { OBJLoader } from 'three/addons/loaders/OBJLoader.js';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
+
+const visualizer = document.getElementById("visualizer");
+const container = document.getElementById( 'container' );
+const progressDialog = document.getElementById("progress-dialog");
+const progressIndicator = document.getElementById("progress-indicator");
+const colorPicker = document.getElementById("color-picker");
+const downloadButton = document.getElementById("download-button");
+
+const renderer = new THREE.WebGLRenderer( { antialias: true } );
+renderer.setPixelRatio( window.devicePixelRatio );
+renderer.setSize( window.innerWidth, window.innerHeight );
+container.appendChild( renderer.domElement );
+
+const pmremGenerator = new THREE.PMREMGenerator( renderer );
+
+// scene
+const scene = new THREE.Scene();
+scene.background = new THREE.Color( 0x000000 );
+scene.environment = pmremGenerator.fromScene( new RoomEnvironment( renderer ), 0.04 ).texture;
+
+const ambientLight = new THREE.AmbientLight( 0xffffff , 3.0 );
+
+const camera = new THREE.PerspectiveCamera( 40, window.innerWidth / window.innerHeight, 1, 100 );
+camera.position.set( 5, 2, 8 );
+const pointLight = new THREE.PointLight( 0xffffff, 15 );
+camera.add( pointLight );
+
+const controls = new OrbitControls( camera, renderer.domElement );
+controls.target.set( 0, 0.5, 0 );
+controls.update();
+controls.enablePan = true;
+controls.enableDamping = true;
+
+// Handle window reseize event
+window.onresize = function () {
+
+ camera.aspect = window.innerWidth / window.innerHeight;
+ camera.updateProjectionMatrix();
+
+ renderer.setSize( window.innerWidth, window.innerHeight );
+
+};
+
+const clock = new THREE.Clock();
+
+var lastTimestamp = "";
+var needUpdate = false;
+let mixer;
+let currentURL;
+var url = location.protocol + '//' + location.host;
+
+downloadButton.addEventListener('click', e => {
+ window.open(currentURL, '_blank');
+});
+
+function frameUpdate() {
+
+ var filepath = visualizer.getAttribute("filepath");
+ var timestamp = visualizer.getAttribute("timestamp");
+ if (timestamp == lastTimestamp){
+ if (needUpdate){
+ controls.update();
+ if (mixer !== undefined) {
+ const delta = clock.getDelta();
+ mixer.update(delta);
+ }
+ renderer.render( scene, camera );
+ }
+ requestAnimationFrame( frameUpdate );
+ } else {
+ needUpdate = false;
+ scene.clear();
+ progressDialog.open = true;
+ lastTimestamp = timestamp;
+ main(filepath);
+ }
+
+ var color = getRGBValue(colorPicker.value, true);
+ if (color[0] != scene.background.r || color[1] != scene.background.g || color[2] != scene.background.b){
+ scene.background.setStyle(colorPicker.value);
+ renderer.render( scene, camera ); // Force update background color in preview scene
+ }
+}
+
+const onProgress = function ( xhr ) {
+ if ( xhr.lengthComputable ) {
+ progressIndicator.value = xhr.loaded / xhr.total * 100;
+ }
+};
+const onError = function ( e ) {
+ console.error( e );
+};
+
+async function main(filepath="") {
+ // Check if file name is valid
+ if (/^.+\.[a-zA-Z]+$/.test(filepath)){
+
+ let params = {"filepath": filepath};
+ currentURL = api.apiURL('/viewfile?' + new URLSearchParams(params));
+
+ var filepathSplit = filepath.split('.');
+ var fileExt = filepathSplit.pop().toLowerCase();
+ var filepathNoExt = filepathSplit.join(".");
+
+ if (fileExt == "obj"){
+ const loader = new OBJLoader();
+
+ var mtlFolderpath = filepath.substring(0, Math.max(filepath.lastIndexOf("/"), filepath.lastIndexOf("\\"))) + "/";
+ var mtlFilepath = filepathNoExt.replace(/^.*[\\\/]/, '') + ".mtl";
+
+ const mtlLoader = new MTLLoader();
+ mtlLoader.setPath(api.apiURL('/viewfile?' + new URLSearchParams({"filepath": mtlFolderpath})));
+ mtlLoader.load( mtlFilepath, function ( mtl ) {
+ mtl.preload();
+ loader.setMaterials( mtl );
+ }, onProgress, onError );
+
+ loader.load( currentURL, function ( obj ) {
+ obj.scale.setScalar( 5 );
+ scene.add( obj );
+ obj.traverse(node => {
+ if (node.material && node.material.map == null) {
+ node.material.vertexColors = true;
+ }
+ });
+
+ }, onProgress, onError );
+
+ } else if (fileExt == "glb") {
+ const dracoLoader = new DRACOLoader();
+ dracoLoader.setDecoderPath( 'https://unpkg.com/three@latest/examples/jsm/libs/draco/gltf/' );
+ const loader = new GLTFLoader();
+ loader.setDRACOLoader( dracoLoader );
+
+ loader.load( currentURL, function ( gltf ) {
+ const model = gltf.scene;
+ //model.position.set( 1, 1, 0 );
+ model.scale.set( 3, 3, 3 );
+
+ scene.add( model );
+ mixer = new THREE.AnimationMixer(model);
+ gltf.animations.forEach((clip) => {
+ mixer.clipAction(clip).play();
+ });
+
+ }, onProgress, onError );
+
+ } else if (fileExt == "ply") {
+
+ } else {
+ throw new Error(`File extension name has to be either .ply or .splat, got .${fileExt}`);
+ }
+
+ needUpdate = true;
+ }
+
+ scene.add( ambientLight );
+ scene.add( camera );
+
+ progressDialog.close();
+
+ frameUpdate();
+}
+
+main("D:\\ComfyUI\\ComfyUI_windows_portable_nvidia_cu121_or_cpu\\ComfyUI_windows_portable\\ComfyUI\\output\\2024-09-12_17-52-06\\model.glb");
+//main();
diff --git a/web/style/gsStyle.css b/web/style/gsStyle.css
new file mode 100644
index 0000000..997fab4
--- /dev/null
+++ b/web/style/gsStyle.css
@@ -0,0 +1,12 @@
+body,
+html {
+ margin: 0;
+ padding: 0;
+ overflow: hidden;
+ background-color: #000;
+}
+
+canvas {
+ width: 100vw;
+ height: 100vh;
+}
\ No newline at end of file
diff --git a/web/style/libs/coloris.min.css b/web/style/libs/coloris.min.css
new file mode 100644
index 0000000..885df05
--- /dev/null
+++ b/web/style/libs/coloris.min.css
@@ -0,0 +1 @@
+.clr-picker{display:none;flex-wrap:wrap;position:absolute;width:200px;z-index:1000;border-radius:10px;background-color:#fff;justify-content:flex-end;direction:ltr;box-shadow:0 0 5px rgba(0,0,0,.05),0 5px 20px rgba(0,0,0,.1);-moz-user-select:none;-webkit-user-select:none;user-select:none}.clr-picker.clr-open,.clr-picker[data-inline=true]{display:flex}.clr-picker[data-inline=true]{position:relative}.clr-gradient{position:relative;width:100%;height:100px;margin-bottom:15px;border-radius:3px 3px 0 0;background-image:linear-gradient(rgba(0,0,0,0),#000),linear-gradient(90deg,#fff,currentColor);cursor:pointer}.clr-marker{position:absolute;width:12px;height:12px;margin:-6px 0 0 -6px;border:1px solid #fff;border-radius:50%;background-color:currentColor;cursor:pointer}.clr-picker input[type=range]::-webkit-slider-runnable-track{width:100%;height:16px}.clr-picker input[type=range]::-webkit-slider-thumb{width:16px;height:16px;-webkit-appearance:none}.clr-picker input[type=range]::-moz-range-track{width:100%;height:16px;border:0}.clr-picker input[type=range]::-moz-range-thumb{width:16px;height:16px;border:0}.clr-hue{background-image:linear-gradient(to right,red 0,#ff0 16.66%,#0f0 33.33%,#0ff 50%,#00f 66.66%,#f0f 83.33%,red 100%)}.clr-alpha,.clr-hue{position:relative;width:calc(100% - 40px);height:8px;margin:5px 20px;border-radius:4px}.clr-alpha span{display:block;height:100%;width:100%;border-radius:inherit;background-image:linear-gradient(90deg,rgba(0,0,0,0),currentColor)}.clr-alpha input[type=range],.clr-hue input[type=range]{position:absolute;width:calc(100% + 32px);height:16px;left:-16px;top:-4px;margin:0;background-color:transparent;opacity:0;cursor:pointer;appearance:none;-webkit-appearance:none}.clr-alpha div,.clr-hue div{position:absolute;width:16px;height:16px;left:0;top:50%;margin-left:-8px;transform:translateY(-50%);border:2px solid #fff;border-radius:50%;background-color:currentColor;box-shadow:0 0 1px #888;pointer-events:none}.clr-alpha div:before{content:'';position:absolute;height:100%;width:100%;left:0;top:0;border-radius:50%;background-color:currentColor}.clr-format{display:none;order:1;width:calc(100% - 40px);margin:0 20px 20px}.clr-segmented{display:flex;position:relative;width:100%;margin:0;padding:0;border:1px solid #ddd;border-radius:15px;box-sizing:border-box;color:#999;font-size:12px}.clr-segmented input,.clr-segmented legend{position:absolute;width:100%;height:100%;margin:0;padding:0;border:0;left:0;top:0;opacity:0;pointer-events:none}.clr-segmented label{flex-grow:1;margin:0;padding:4px 0;font-size:inherit;font-weight:400;line-height:initial;text-align:center;cursor:pointer}.clr-segmented label:first-of-type{border-radius:10px 0 0 10px}.clr-segmented label:last-of-type{border-radius:0 10px 10px 0}.clr-segmented input:checked+label{color:#fff;background-color:#666}.clr-swatches{order:2;width:calc(100% - 32px);margin:0 16px}.clr-swatches div{display:flex;flex-wrap:wrap;padding-bottom:12px;justify-content:center}.clr-swatches button{position:relative;width:20px;height:20px;margin:0 4px 6px 4px;padding:0;border:0;border-radius:50%;color:inherit;text-indent:-1000px;white-space:nowrap;overflow:hidden;cursor:pointer}.clr-swatches button:after{content:'';display:block;position:absolute;width:100%;height:100%;left:0;top:0;border-radius:inherit;background-color:currentColor;box-shadow:inset 0 0 0 1px rgba(0,0,0,.1)}input.clr-color{order:1;width:calc(100% - 80px);height:32px;margin:15px 20px 20px auto;padding:0 10px;border:1px solid #ddd;border-radius:16px;color:#444;background-color:#fff;font-family:sans-serif;font-size:14px;text-align:center;box-shadow:none}input.clr-color:focus{outline:0;border:1px solid #1e90ff}.clr-clear,.clr-close{display:none;order:2;height:24px;margin:0 20px 20px;padding:0 20px;border:0;border-radius:12px;color:#fff;background-color:#666;font-family:inherit;font-size:12px;font-weight:400;cursor:pointer}.clr-close{display:block;margin:0 20px 20px auto}.clr-preview{position:relative;width:32px;height:32px;margin:15px 0 20px 20px;border-radius:50%;overflow:hidden}.clr-preview:after,.clr-preview:before{content:'';position:absolute;height:100%;width:100%;left:0;top:0;border:1px solid #fff;border-radius:50%}.clr-preview:after{border:0;background-color:currentColor;box-shadow:inset 0 0 0 1px rgba(0,0,0,.1)}.clr-preview button{position:absolute;width:100%;height:100%;z-index:1;margin:0;padding:0;border:0;border-radius:50%;outline-offset:-2px;background-color:transparent;text-indent:-9999px;cursor:pointer;overflow:hidden}.clr-alpha div,.clr-color,.clr-hue div,.clr-marker{box-sizing:border-box}.clr-field{display:inline-block;position:relative;color:transparent}.clr-field input{margin:0;direction:ltr}.clr-field.clr-rtl input{text-align:right}.clr-field button{position:absolute;width:30px;height:100%;right:0;top:50%;transform:translateY(-50%);margin:0;padding:0;border:0;color:inherit;text-indent:-1000px;white-space:nowrap;overflow:hidden;pointer-events:none}.clr-field.clr-rtl button{right:auto;left:0}.clr-field button:after{content:'';display:block;position:absolute;width:100%;height:100%;left:0;top:0;border-radius:inherit;background-color:currentColor;box-shadow:inset 0 0 1px rgba(0,0,0,.5)}.clr-alpha,.clr-alpha div,.clr-field button,.clr-preview:before,.clr-swatches button{background-image:repeating-linear-gradient(45deg,#aaa 25%,transparent 25%,transparent 75%,#aaa 75%,#aaa),repeating-linear-gradient(45deg,#aaa 25%,#fff 25%,#fff 75%,#aaa 75%,#aaa);background-position:0 0,4px 4px;background-size:8px 8px}.clr-marker:focus{outline:0}.clr-keyboard-nav .clr-alpha input:focus+div,.clr-keyboard-nav .clr-hue input:focus+div,.clr-keyboard-nav .clr-marker:focus,.clr-keyboard-nav .clr-segmented input:focus+label{outline:0;box-shadow:0 0 0 2px #1e90ff,0 0 2px 2px #fff}.clr-picker[data-alpha=false] .clr-alpha{display:none}.clr-picker[data-minimal=true]{padding-top:16px}.clr-picker[data-minimal=true] .clr-alpha,.clr-picker[data-minimal=true] .clr-color,.clr-picker[data-minimal=true] .clr-gradient,.clr-picker[data-minimal=true] .clr-hue,.clr-picker[data-minimal=true] .clr-preview{display:none}.clr-dark{background-color:#444}.clr-dark .clr-segmented{border-color:#777}.clr-dark .clr-swatches button:after{box-shadow:inset 0 0 0 1px rgba(255,255,255,.3)}.clr-dark input.clr-color{color:#fff;border-color:#777;background-color:#555}.clr-dark input.clr-color:focus{border-color:#1e90ff}.clr-dark .clr-preview:after{box-shadow:inset 0 0 0 1px rgba(255,255,255,.5)}.clr-dark .clr-alpha,.clr-dark .clr-alpha div,.clr-dark .clr-preview:before,.clr-dark .clr-swatches button{background-image:repeating-linear-gradient(45deg,#666 25%,transparent 25%,transparent 75%,#888 75%,#888),repeating-linear-gradient(45deg,#888 25%,#444 25%,#444 75%,#888 75%,#888)}.clr-picker.clr-polaroid{border-radius:6px;box-shadow:0 0 5px rgba(0,0,0,.1),0 5px 30px rgba(0,0,0,.2)}.clr-picker.clr-polaroid:before{content:'';display:block;position:absolute;width:16px;height:10px;left:20px;top:-10px;border:solid transparent;border-width:0 8px 10px 8px;border-bottom-color:currentColor;box-sizing:border-box;color:#fff;filter:drop-shadow(0 -4px 3px rgba(0,0,0,.1));pointer-events:none}.clr-picker.clr-polaroid.clr-dark:before{color:#444}.clr-picker.clr-polaroid.clr-left:before{left:auto;right:20px}.clr-picker.clr-polaroid.clr-top:before{top:auto;bottom:-10px;transform:rotateZ(180deg)}.clr-polaroid .clr-gradient{width:calc(100% - 20px);height:120px;margin:10px;border-radius:3px}.clr-polaroid .clr-alpha,.clr-polaroid .clr-hue{width:calc(100% - 30px);height:10px;margin:6px 15px;border-radius:5px}.clr-polaroid .clr-alpha div,.clr-polaroid .clr-hue div{box-shadow:0 0 5px rgba(0,0,0,.2)}.clr-polaroid .clr-format{width:calc(100% - 20px);margin:0 10px 15px}.clr-polaroid .clr-swatches{width:calc(100% - 12px);margin:0 6px}.clr-polaroid .clr-swatches div{padding-bottom:10px}.clr-polaroid .clr-swatches button{width:22px;height:22px}.clr-polaroid input.clr-color{width:calc(100% - 60px);margin:10px 10px 15px auto}.clr-polaroid .clr-clear{margin:0 10px 15px 10px}.clr-polaroid .clr-close{margin:0 10px 15px auto}.clr-polaroid .clr-preview{margin:10px 0 15px 10px}.clr-picker.clr-large{width:275px}.clr-large .clr-gradient{height:150px}.clr-large .clr-swatches button{width:22px;height:22px}.clr-picker.clr-pill{width:380px;padding-left:180px;box-sizing:border-box}.clr-pill .clr-gradient{position:absolute;width:180px;height:100%;left:0;top:0;margin-bottom:0;border-radius:3px 0 0 3px}.clr-pill .clr-hue{margin-top:20px}
\ No newline at end of file
diff --git a/web/style/sharedStyle.css b/web/style/sharedStyle.css
new file mode 100644
index 0000000..ccd74d0
--- /dev/null
+++ b/web/style/sharedStyle.css
@@ -0,0 +1,74 @@
+dialog {
+ width: 100%;
+ text-align: center;
+ max-width: 20em;
+ color: white;
+ background-color: #000;
+ border: none;
+ position: relative;
+ transform: translate(-50%, -50%);
+}
+
+#progress-container {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+}
+
+progress {
+ width: 100%;
+ height: 1em;
+ border: none;
+ background-color: #fff;
+ color: #eee;
+}
+
+progress::-webkit-progress-bar {
+ background-color: #333;
+}
+
+progress::-webkit-progress-value {
+ background-color: #eee;
+}
+
+progress::-moz-progress-bar {
+ background-color: #eee;
+}
+
+
+#container {
+ position: absolute;
+ top: 0%;
+ left: 0%;
+ width: 100%;
+ height: 100%;
+}
+
+.clr-field {
+ margin-left: 5px;
+ margin-top: 5px;
+}
+
+.clr-field button {
+ width: 20px;
+ height: 20px;
+ left: 5px;
+ right: auto;
+ border-radius: 5px;
+}
+
+.clr-field input {
+ padding-left: 36px;
+ width: 120px;
+ height: 24px;
+ border: 2px solid #aaa;
+ border-radius: 5px;
+}
+
+#download-button {
+ margin-left: 5px;
+ margin-top: 10px;
+ position: absolute;
+ z-index: 10;
+ left: 180px;
+}
diff --git a/web/style/threeStyle.css b/web/style/threeStyle.css
new file mode 100644
index 0000000..dab2f09
--- /dev/null
+++ b/web/style/threeStyle.css
@@ -0,0 +1,91 @@
+body {
+ margin: 0;
+ background-color: #000;
+ color: #fff;
+ font-family: Monospace;
+ font-size: 13px;
+ line-height: 24px;
+ overscroll-behavior: none;
+}
+
+a {
+ color: #ff0;
+ text-decoration: none;
+}
+
+a:hover {
+ text-decoration: underline;
+}
+
+button {
+ cursor: pointer;
+ text-transform: uppercase;
+}
+
+#info {
+ position: absolute;
+ top: 0px;
+ width: 100%;
+ padding: 10px;
+ box-sizing: border-box;
+ text-align: center;
+ -moz-user-select: none;
+ -webkit-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ pointer-events: none;
+ z-index: 1; /* TODO Solve this in HTML */
+}
+
+a, button, input, select {
+ pointer-events: auto;
+}
+
+.lil-gui {
+ z-index: 2 !important; /* TODO Solve this in HTML */
+}
+
+@media all and ( max-width: 640px ) {
+ .lil-gui.root {
+ right: auto;
+ top: auto;
+ max-height: 50%;
+ max-width: 80%;
+ bottom: 0;
+ left: 0;
+ }
+}
+
+#overlay {
+ position: absolute;
+ font-size: 16px;
+ z-index: 2;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ flex-direction: column;
+ background: rgba(0,0,0,0.7);
+}
+
+ #overlay button {
+ background: transparent;
+ border: 0;
+ border: 1px solid rgb(255, 255, 255);
+ border-radius: 4px;
+ color: #ffffff;
+ padding: 12px 18px;
+ text-transform: uppercase;
+ cursor: pointer;
+ }
+
+#notSupported {
+ width: 50%;
+ margin: auto;
+ background-color: #f00;
+ margin-top: 20px;
+ padding: 10px;
+}
\ No newline at end of file
diff --git a/web/threeVisualizer/assets/emHdBindings-A46AWXYl.js b/web/threeVisualizer/assets/emHdBindings-A46AWXYl.js
new file mode 100644
index 0000000..b723afd
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings-A46AWXYl.js
@@ -0,0 +1 @@
+const e="/extensions/ComfyUI-Rodin/threeVisualizer/assets/emHdBindings-D9OMRJgz.data";export{e as default};
diff --git a/web/threeVisualizer/assets/emHdBindings-B2pBhR1n.js b/web/threeVisualizer/assets/emHdBindings-B2pBhR1n.js
new file mode 100644
index 0000000..1dda336
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings-B2pBhR1n.js
@@ -0,0 +1 @@
+const s="/extensions/ComfyUI-Rodin/threeVisualizer/assets/emHdBindings-CZBDkVTp.js";export{s as default};
diff --git a/web/threeVisualizer/assets/emHdBindings-BNKz2vMm.wasm b/web/threeVisualizer/assets/emHdBindings-BNKz2vMm.wasm
new file mode 100644
index 0000000..03f2b21
Binary files /dev/null and b/web/threeVisualizer/assets/emHdBindings-BNKz2vMm.wasm differ
diff --git a/web/threeVisualizer/assets/emHdBindings-CZBDkVTp.js b/web/threeVisualizer/assets/emHdBindings-CZBDkVTp.js
new file mode 100644
index 0000000..0df0321
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings-CZBDkVTp.js
@@ -0,0 +1,12022 @@
+var getUsdModule = ((args) => {
+ var _scriptDir =
+ typeof document !== "undefined" && document.currentScript
+ ? document.currentScript.src
+ : undefined;
+ if (typeof __filename !== "undefined") _scriptDir = _scriptDir || __filename;
+ return function (moduleArg = {
+ // module overrides can be supplied here
+ locateFile: (path, prefix) => {
+ if (!prefix && _scriptDir) prefix = _scriptDir.substr(0, _scriptDir.lastIndexOf('/') + 1);
+ return prefix + path;
+ },
+ ...args
+}) {
+ function GROWABLE_HEAP_I8() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAP8;
+ }
+ function GROWABLE_HEAP_U8() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAPU8;
+ }
+ function GROWABLE_HEAP_I16() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAP16;
+ }
+ function GROWABLE_HEAP_U16() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAPU16;
+ }
+ function GROWABLE_HEAP_I32() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAP32;
+ }
+ function GROWABLE_HEAP_U32() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAPU32;
+ }
+ function GROWABLE_HEAP_F32() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAPF32;
+ }
+ function GROWABLE_HEAP_F64() {
+ if (wasmMemory.buffer != HEAP8.buffer) {
+ updateMemoryViews();
+ }
+ return HEAPF64;
+ }
+ var Module = moduleArg;
+ var readyPromiseResolve, readyPromiseReject;
+ Module["ready"] = new Promise((resolve, reject) => {
+ readyPromiseResolve = resolve;
+ readyPromiseReject = reject;
+ });
+ if (!Module.expectedDataFileDownloads) {
+ Module.expectedDataFileDownloads = 0;
+ }
+ Module.expectedDataFileDownloads++;
+ (function () {
+ if (Module["ENVIRONMENT_IS_PTHREAD"] || Module["$ww"]) return;
+ var loadPackage = function (metadata) {
+ var PACKAGE_PATH = "";
+ if (typeof window === "object") {
+ PACKAGE_PATH = window["encodeURIComponent"](
+ window.location.pathname
+ .toString()
+ .substring(
+ 0,
+ window.location.pathname.toString().lastIndexOf("/"),
+ ) + "/",
+ );
+ } else if (
+ typeof process === "undefined" &&
+ typeof location !== "undefined"
+ ) {
+ PACKAGE_PATH = encodeURIComponent(
+ location.pathname
+ .toString()
+ .substring(0, location.pathname.toString().lastIndexOf("/")) +
+ "/",
+ );
+ }
+ var PACKAGE_NAME = "emHdBindings.data";
+ var REMOTE_PACKAGE_BASE = "emHdBindings.data";
+ if (
+ typeof Module["locateFilePackage"] === "function" &&
+ !Module["locateFile"]
+ ) {
+ Module["locateFile"] = Module["locateFilePackage"];
+ err(
+ "warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)",
+ );
+ }
+ var REMOTE_PACKAGE_NAME = Module["locateFile"]
+ ? Module["locateFile"](REMOTE_PACKAGE_BASE, "")
+ : REMOTE_PACKAGE_BASE;
+ var REMOTE_PACKAGE_SIZE = metadata["remote_package_size"];
+ function fetchRemotePackage(
+ packageName,
+ packageSize,
+ callback,
+ errback,
+ ) {
+ if (
+ typeof process === "object" &&
+ typeof process.versions === "object" &&
+ typeof process.versions.node === "string"
+ ) {
+ require("fs").readFile(packageName, function (err, contents) {
+ if (err) {
+ errback(err);
+ } else {
+ callback(contents.buffer);
+ }
+ });
+ return;
+ }
+ var xhr = new XMLHttpRequest();
+ xhr.open("GET", packageName, true);
+ xhr.responseType = "arraybuffer";
+ xhr.onprogress = function (event) {
+ var url = packageName;
+ var size = packageSize;
+ if (event.total) size = event.total;
+ if (event.loaded) {
+ if (!xhr.addedTotal) {
+ xhr.addedTotal = true;
+ if (!Module.dataFileDownloads) Module.dataFileDownloads = {};
+ Module.dataFileDownloads[url] = {
+ loaded: event.loaded,
+ total: size,
+ };
+ } else {
+ Module.dataFileDownloads[url].loaded = event.loaded;
+ }
+ var total = 0;
+ var loaded = 0;
+ var num = 0;
+ for (var download in Module.dataFileDownloads) {
+ var data = Module.dataFileDownloads[download];
+ total += data.total;
+ loaded += data.loaded;
+ num++;
+ }
+ total = Math.ceil(
+ (total * Module.expectedDataFileDownloads) / num,
+ );
+ if (Module["setStatus"])
+ Module["setStatus"](`Downloading data... (${loaded}/${total})`);
+ } else if (!Module.dataFileDownloads) {
+ if (Module["setStatus"])
+ Module["setStatus"]("Downloading data...");
+ }
+ };
+ xhr.onerror = function (event) {
+ throw new Error("NetworkError for: " + packageName);
+ };
+ xhr.onload = function (event) {
+ if (
+ xhr.status == 200 ||
+ xhr.status == 304 ||
+ xhr.status == 206 ||
+ (xhr.status == 0 && xhr.response)
+ ) {
+ var packageData = xhr.response;
+ callback(packageData);
+ } else {
+ throw new Error(xhr.statusText + " : " + xhr.responseURL);
+ }
+ };
+ xhr.send(null);
+ }
+ function handleError(error) {
+ console.error("package error:", error);
+ }
+ var fetchedCallback = null;
+ var fetched = Module["getPreloadedPackage"]
+ ? Module["getPreloadedPackage"](
+ REMOTE_PACKAGE_NAME,
+ REMOTE_PACKAGE_SIZE,
+ )
+ : null;
+ if (!fetched)
+ fetchRemotePackage(
+ REMOTE_PACKAGE_NAME,
+ REMOTE_PACKAGE_SIZE,
+ function (data) {
+ if (fetchedCallback) {
+ fetchedCallback(data);
+ fetchedCallback = null;
+ } else {
+ fetched = data;
+ }
+ },
+ handleError,
+ );
+ function runWithFS() {
+ function assert(check, msg) {
+ if (!check) throw msg + new Error().stack;
+ }
+ Module["FS_createPath"]("/", "usd", true, true);
+ Module["FS_createPath"]("/usd", "ar", true, true);
+ Module["FS_createPath"]("/usd/ar", "resources", true, true);
+ Module["FS_createPath"]("/usd", "hd", true, true);
+ Module["FS_createPath"]("/usd/hd", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/hd/resources",
+ "codegenTemplates",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "httpResolver", true, true);
+ Module["FS_createPath"]("/usd/httpResolver", "resources", true, true);
+ Module["FS_createPath"]("/usd", "ndr", true, true);
+ Module["FS_createPath"]("/usd/ndr", "resources", true, true);
+ Module["FS_createPath"]("/usd", "sdf", true, true);
+ Module["FS_createPath"]("/usd/sdf", "resources", true, true);
+ Module["FS_createPath"]("/usd", "usd", true, true);
+ Module["FS_createPath"]("/usd/usd", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usd/resources",
+ "codegenTemplates",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd/usd/resources", "usd", true, true);
+ Module["FS_createPath"]("/usd", "usdGeom", true, true);
+ Module["FS_createPath"]("/usd/usdGeom", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdGeom/resources",
+ "usdGeom",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdHydra", true, true);
+ Module["FS_createPath"]("/usd/usdHydra", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdHydra/resources",
+ "shaders",
+ true,
+ true,
+ );
+ Module["FS_createPath"](
+ "/usd/usdHydra/resources",
+ "usdHydra",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdImaging", true, true);
+ Module["FS_createPath"]("/usd/usdImaging", "resources", true, true);
+ Module["FS_createPath"]("/usd", "usdLux", true, true);
+ Module["FS_createPath"]("/usd/usdLux", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdLux/resources",
+ "usdLux",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdRender", true, true);
+ Module["FS_createPath"]("/usd/usdRender", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdRender/resources",
+ "usdRender",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdShade", true, true);
+ Module["FS_createPath"]("/usd/usdShade", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdShade/resources",
+ "usdShade",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdShaders", true, true);
+ Module["FS_createPath"]("/usd/usdShaders", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdShaders/resources",
+ "shaders",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdSkel", true, true);
+ Module["FS_createPath"]("/usd/usdSkel", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdSkel/resources",
+ "usdSkel",
+ true,
+ true,
+ );
+ Module["FS_createPath"]("/usd", "usdVol", true, true);
+ Module["FS_createPath"]("/usd/usdVol", "resources", true, true);
+ Module["FS_createPath"](
+ "/usd/usdVol/resources",
+ "usdVol",
+ true,
+ true,
+ );
+ function DataRequest(start, end, audio) {
+ this.start = start;
+ this.end = end;
+ this.audio = audio;
+ }
+ DataRequest.prototype = {
+ requests: {},
+ open: function (mode, name) {
+ this.name = name;
+ this.requests[name] = this;
+ Module["addRunDependency"](`fp ${this.name}`);
+ },
+ send: function () {},
+ onload: function () {
+ var byteArray = this.byteArray.subarray(this.start, this.end);
+ this.finish(byteArray);
+ },
+ finish: function (byteArray) {
+ var that = this;
+ Module["FS_createDataFile"](
+ this.name,
+ null,
+ byteArray,
+ true,
+ true,
+ true,
+ );
+ Module["removeRunDependency"](`fp ${that.name}`);
+ this.requests[this.name] = null;
+ },
+ };
+ var files = metadata["files"];
+ for (var i = 0; i < files.length; ++i) {
+ new DataRequest(
+ files[i]["start"],
+ files[i]["end"],
+ files[i]["audio"] || 0,
+ ).open("GET", files[i]["filename"]);
+ }
+ function processPackageData(arrayBuffer) {
+ assert(arrayBuffer, "Loading data file failed.");
+ assert(
+ arrayBuffer.constructor.name === ArrayBuffer.name,
+ "bad input to processPackageData",
+ );
+ var byteArray = new Uint8Array(arrayBuffer);
+ DataRequest.prototype.byteArray = byteArray;
+ var files = metadata["files"];
+ for (var i = 0; i < files.length; ++i) {
+ DataRequest.prototype.requests[files[i].filename].onload();
+ }
+ Module["removeRunDependency"]("datafile_emHdBindings.data");
+ }
+ Module["addRunDependency"]("datafile_emHdBindings.data");
+ if (!Module.preloadResults) Module.preloadResults = {};
+ Module.preloadResults[PACKAGE_NAME] = { fromCache: false };
+ if (fetched) {
+ processPackageData(fetched);
+ fetched = null;
+ } else {
+ fetchedCallback = processPackageData;
+ }
+ }
+ if (Module["calledRun"]) {
+ runWithFS();
+ } else {
+ if (!Module["preRun"]) Module["preRun"] = [];
+ Module["preRun"].push(runWithFS);
+ }
+ };
+ loadPackage({
+ files: [
+ { filename: "/usd/ar/resources/plugInfo.json", start: 0, end: 589 },
+ {
+ filename: "/usd/hd/resources/codegenTemplates/schemaClass.cpp",
+ start: 589,
+ end: 9620,
+ },
+ {
+ filename: "/usd/hd/resources/codegenTemplates/schemaClass.h",
+ start: 9620,
+ end: 20258,
+ },
+ {
+ filename: "/usd/hd/resources/plugInfo.json",
+ start: 20258,
+ end: 20483,
+ },
+ {
+ filename: "/usd/httpResolver/resources/plugInfo.json",
+ start: 20483,
+ end: 20823,
+ },
+ {
+ filename: "/usd/ndr/resources/plugInfo.json",
+ start: 20823,
+ end: 21397,
+ },
+ { filename: "/usd/plugInfo.json", start: 21397, end: 21448 },
+ {
+ filename: "/usd/sdf/resources/plugInfo.json",
+ start: 21448,
+ end: 22544,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/api.h",
+ start: 22544,
+ end: 24646,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/plugInfo.json",
+ start: 24646,
+ end: 25003,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/schemaClass.cpp",
+ start: 25003,
+ end: 37342,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/schemaClass.h",
+ start: 37342,
+ end: 54229,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/tokens.cpp",
+ start: 54229,
+ end: 55817,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/tokens.h",
+ start: 55817,
+ end: 59072,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/wrapSchemaClass.cpp",
+ start: 59072,
+ end: 68578,
+ },
+ {
+ filename: "/usd/usd/resources/codegenTemplates/wrapTokens.cpp",
+ start: 68578,
+ end: 71099,
+ },
+ {
+ filename: "/usd/usd/resources/generatedSchema.usda",
+ start: 71099,
+ end: 86803,
+ },
+ {
+ filename: "/usd/usd/resources/plugInfo.json",
+ start: 86803,
+ end: 92530,
+ },
+ {
+ filename: "/usd/usd/resources/usd/schema.usda",
+ start: 92530,
+ end: 110774,
+ },
+ {
+ filename: "/usd/usdGeom/resources/generatedSchema.usda",
+ start: 110774,
+ end: 355640,
+ },
+ {
+ filename: "/usd/usdGeom/resources/plugInfo.json",
+ start: 355640,
+ end: 371761,
+ },
+ {
+ filename: "/usd/usdGeom/resources/usdGeom/schema.usda",
+ start: 371761,
+ end: 500520,
+ },
+ {
+ filename: "/usd/usdHydra/resources/generatedSchema.usda",
+ start: 500520,
+ end: 501538,
+ },
+ {
+ filename: "/usd/usdHydra/resources/plugInfo.json",
+ start: 501538,
+ end: 502826,
+ },
+ {
+ filename: "/usd/usdHydra/resources/shaders/empty.glslfx",
+ start: 502826,
+ end: 504049,
+ },
+ {
+ filename: "/usd/usdHydra/resources/shaders/shaderDefs.usda",
+ start: 504049,
+ end: 510806,
+ },
+ {
+ filename: "/usd/usdHydra/resources/usdHydra/schema.usda",
+ start: 510806,
+ end: 518107,
+ },
+ {
+ filename: "/usd/usdImaging/resources/plugInfo.json",
+ start: 518107,
+ end: 531776,
+ },
+ {
+ filename: "/usd/usdLux/resources/generatedSchema.usda",
+ start: 531776,
+ end: 610666,
+ },
+ {
+ filename: "/usd/usdLux/resources/plugInfo.json",
+ start: 610666,
+ end: 620463,
+ },
+ {
+ filename: "/usd/usdLux/resources/usdLux/schema.usda",
+ start: 620463,
+ end: 662394,
+ },
+ {
+ filename: "/usd/usdRender/resources/generatedSchema.usda",
+ start: 662394,
+ end: 685685,
+ },
+ {
+ filename: "/usd/usdRender/resources/plugInfo.json",
+ start: 685685,
+ end: 688784,
+ },
+ {
+ filename: "/usd/usdRender/resources/usdRender/schema.usda",
+ start: 688784,
+ end: 705492,
+ },
+ {
+ filename: "/usd/usdShade/resources/generatedSchema.usda",
+ start: 705492,
+ end: 721492,
+ },
+ {
+ filename: "/usd/usdShade/resources/plugInfo.json",
+ start: 721492,
+ end: 727378,
+ },
+ {
+ filename: "/usd/usdShade/resources/usdShade/schema.usda",
+ start: 727378,
+ end: 754223,
+ },
+ {
+ filename: "/usd/usdShaders/resources/plugInfo.json",
+ start: 754223,
+ end: 754902,
+ },
+ {
+ filename: "/usd/usdShaders/resources/shaders/previewSurface.glslfx",
+ start: 754902,
+ end: 768823,
+ },
+ {
+ filename: "/usd/usdShaders/resources/shaders/primvarReader.glslfx",
+ start: 768823,
+ end: 770046,
+ },
+ {
+ filename: "/usd/usdShaders/resources/shaders/shaderDefs.usda",
+ start: 770046,
+ end: 784976,
+ },
+ {
+ filename: "/usd/usdShaders/resources/shaders/transform2d.glslfx",
+ start: 784976,
+ end: 786199,
+ },
+ {
+ filename: "/usd/usdShaders/resources/shaders/uvTexture.glslfx",
+ start: 786199,
+ end: 787422,
+ },
+ {
+ filename: "/usd/usdSkel/resources/generatedSchema.usda",
+ start: 787422,
+ end: 802913,
+ },
+ {
+ filename: "/usd/usdSkel/resources/plugInfo.json",
+ start: 802913,
+ end: 805907,
+ },
+ {
+ filename: "/usd/usdSkel/resources/usdSkel/schema.usda",
+ start: 805907,
+ end: 816312,
+ },
+ {
+ filename: "/usd/usdVol/resources/generatedSchema.usda",
+ start: 816312,
+ end: 840757,
+ },
+ {
+ filename: "/usd/usdVol/resources/plugInfo.json",
+ start: 840757,
+ end: 843193,
+ },
+ {
+ filename: "/usd/usdVol/resources/usdVol/schema.usda",
+ start: 843193,
+ end: 849069,
+ },
+ ],
+ remote_package_size: 849069,
+ });
+ })();
+ if (!Module["ENVIRONMENT_IS_PTHREAD"]) {
+ function isMobileDevice() {
+ return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+ navigator.userAgent,
+ );
+ }
+ const MAX_MEMORY_MOBILE = 1024 * 1024 * 1024;
+ const MAX_MEMORY_DESKTOP = 4 * 1024 * 1024 * 1024;
+ const MAX_DEVICE_MEMORY = isMobileDevice()
+ ? MAX_MEMORY_MOBILE
+ : MAX_MEMORY_DESKTOP;
+ Module["wasmMemory"] = new WebAssembly.Memory({
+ initial: 16777216 / 65536,
+ maximum: MAX_DEVICE_MEMORY / 65536,
+ shared: true,
+ });
+ }
+ var moduleOverrides = Object.assign({}, Module);
+ var arguments_ = [];
+ var thisProgram = "./this.program";
+ var quit_ = (status, toThrow) => {
+ throw toThrow;
+ };
+ var ENVIRONMENT_IS_WEB = typeof window == "object";
+ var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
+ var ENVIRONMENT_IS_NODE =
+ typeof process == "object" &&
+ typeof process.versions == "object" &&
+ typeof process.versions.node == "string";
+ var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;
+ var scriptDirectory = "";
+ function locateFile(path) {
+ if (Module["locateFile"]) {
+ return Module["locateFile"](path, scriptDirectory);
+ }
+ return scriptDirectory + path;
+ }
+ var read_, readAsync, readBinary;
+ if (ENVIRONMENT_IS_NODE) {
+ var fs = require("fs");
+ var nodePath = require("path");
+ if (ENVIRONMENT_IS_WORKER) {
+ scriptDirectory = nodePath.dirname(scriptDirectory) + "/";
+ } else {
+ scriptDirectory = __dirname + "/";
+ }
+ read_ = (filename, binary) => {
+ filename = isFileURI(filename)
+ ? new URL(filename)
+ : nodePath.normalize(filename);
+ return fs.readFileSync(filename, binary ? undefined : "utf8");
+ };
+ readBinary = (filename) => {
+ var ret = read_(filename, true);
+ if (!ret.buffer) {
+ ret = new Uint8Array(ret);
+ }
+ return ret;
+ };
+ readAsync = (filename, onload, onerror, binary = true) => {
+ filename = isFileURI(filename)
+ ? new URL(filename)
+ : nodePath.normalize(filename);
+ fs.readFile(filename, binary ? undefined : "utf8", (err, data) => {
+ if (err) onerror(err);
+ else onload(binary ? data.buffer : data);
+ });
+ };
+ if (!Module["thisProgram"] && process.argv.length > 1) {
+ thisProgram = process.argv[1].replace(/\\/g, "/");
+ }
+ arguments_ = process.argv.slice(2);
+ quit_ = (status, toThrow) => {
+ process.exitCode = status;
+ throw toThrow;
+ };
+ Module["inspect"] = () => "[Emscripten Module object]";
+ let nodeWorkerThreads;
+ try {
+ nodeWorkerThreads = require("worker_threads");
+ } catch (e) {
+ console.error(
+ 'The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?',
+ );
+ throw e;
+ }
+ global.Worker = nodeWorkerThreads.Worker;
+ } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ if (ENVIRONMENT_IS_WORKER) {
+ scriptDirectory = self.location.href;
+ } else if (typeof document != "undefined" && document.currentScript) {
+ scriptDirectory = document.currentScript.src;
+ }
+ if (_scriptDir) {
+ scriptDirectory = _scriptDir;
+ }
+ if (scriptDirectory.indexOf("blob:") !== 0) {
+ scriptDirectory = scriptDirectory.substr(
+ 0,
+ scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1,
+ );
+ } else {
+ scriptDirectory = "";
+ }
+ if (!ENVIRONMENT_IS_NODE) {
+ read_ = (url) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open("GET", url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+ 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 = (url, onload, onerror) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open("GET", url, true);
+ xhr.responseType = "arraybuffer";
+ xhr.onload = () => {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+ onload(xhr.response);
+ return;
+ }
+ onerror();
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ };
+ }
+ } else {
+ }
+ if (ENVIRONMENT_IS_NODE) {
+ if (typeof performance == "undefined") {
+ global.performance = require("perf_hooks").performance;
+ }
+ }
+ var defaultPrint = console.log.bind(console);
+ var defaultPrintErr = console.error.bind(console);
+ if (ENVIRONMENT_IS_NODE) {
+ defaultPrint = (...args) => fs.writeSync(1, args.join(" ") + "\n");
+ defaultPrintErr = (...args) => fs.writeSync(2, args.join(" ") + "\n");
+ }
+ var out = Module["print"] || defaultPrint;
+ var err = Module["printErr"] || defaultPrintErr;
+ Object.assign(Module, moduleOverrides);
+ moduleOverrides = null;
+ if (Module["arguments"]) arguments_ = Module["arguments"];
+ if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+ if (Module["quit"]) quit_ = Module["quit"];
+ var wasmBinary;
+ if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+ if (typeof WebAssembly != "object") {
+ abort("no native wasm support detected");
+ }
+ var wasmMemory;
+ var wasmModule;
+ var ABORT = false;
+ var EXITSTATUS;
+ function assert(condition, text) {
+ if (!condition) {
+ abort(text);
+ }
+ }
+ var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+ function updateMemoryViews() {
+ var b = wasmMemory.buffer;
+ Module["HEAP8"] = HEAP8 = new Int8Array(b);
+ Module["HEAP16"] = HEAP16 = new Int16Array(b);
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+ Module["HEAP32"] = HEAP32 = new Int32Array(b);
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
+ }
+ var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
+ assert(
+ INITIAL_MEMORY >= 5242880,
+ "INITIAL_MEMORY should be larger than STACK_SIZE, was " +
+ INITIAL_MEMORY +
+ "! (STACK_SIZE=" +
+ 5242880 +
+ ")",
+ );
+ if (ENVIRONMENT_IS_PTHREAD) {
+ wasmMemory = Module["wasmMemory"];
+ } else {
+ if (Module["wasmMemory"]) {
+ wasmMemory = Module["wasmMemory"];
+ } else {
+ wasmMemory = new WebAssembly.Memory({
+ initial: INITIAL_MEMORY / 65536,
+ maximum: 4294967296 / 65536,
+ shared: true,
+ });
+ if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
+ err(
+ "requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag",
+ );
+ if (ENVIRONMENT_IS_NODE) {
+ err(
+ "(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)",
+ );
+ }
+ throw Error("bad memory");
+ }
+ }
+ }
+ updateMemoryViews();
+ INITIAL_MEMORY = wasmMemory.buffer.byteLength;
+ var __ATPRERUN__ = [];
+ var __ATINIT__ = [];
+ var __ATPOSTRUN__ = [];
+ var runtimeInitialized = false;
+ function preRun() {
+ if (Module["preRun"]) {
+ if (typeof Module["preRun"] == "function")
+ Module["preRun"] = [Module["preRun"]];
+ while (Module["preRun"].length) {
+ addOnPreRun(Module["preRun"].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+ }
+ function initRuntime() {
+ runtimeInitialized = true;
+ if (ENVIRONMENT_IS_PTHREAD) return;
+ if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
+ FS.ignorePermissions = false;
+ TTY.init();
+ callRuntimeCallbacks(__ATINIT__);
+ }
+ function postRun() {
+ if (ENVIRONMENT_IS_PTHREAD) return;
+ if (Module["postRun"]) {
+ if (typeof Module["postRun"] == "function")
+ Module["postRun"] = [Module["postRun"]];
+ while (Module["postRun"].length) {
+ addOnPostRun(Module["postRun"].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+ }
+ function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+ }
+ function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+ }
+ function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+ }
+ var runDependencies = 0;
+ var runDependencyWatcher = null;
+ var dependenciesFulfilled = null;
+ function getUniqueRunDependency(id) {
+ return id;
+ }
+ function addRunDependency(id) {
+ runDependencies++;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies);
+ }
+ }
+ function removeRunDependency(id) {
+ runDependencies--;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback();
+ }
+ }
+ }
+ function abort(what) {
+ if (Module["onAbort"]) {
+ Module["onAbort"](what);
+ }
+ what = "Aborted(" + what + ")";
+ err(what);
+ // ABORT = true; // this does not allow anything to work after being set, however we're actually okay to try other assets so we shouldn't do this
+ EXITSTATUS = 1;
+ what += ". Build with -sASSERTIONS for more info.";
+ var e = new WebAssembly.RuntimeError(what);
+ readyPromiseReject(e);
+ throw e;
+ }
+ var dataURIPrefix = "data:application/octet-stream;base64,";
+ var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+ var isFileURI = (filename) => filename.startsWith("file://");
+ var wasmBinaryFile;
+ wasmBinaryFile = "emHdBindings.wasm";
+ if (!isDataURI(wasmBinaryFile)) {
+ wasmBinaryFile = locateFile(wasmBinaryFile);
+ }
+ function getBinarySync(file) {
+ if (file == wasmBinaryFile && wasmBinary) {
+ return new Uint8Array(wasmBinary);
+ }
+ if (readBinary) {
+ return readBinary(file);
+ }
+ throw "both async and sync fetching of the wasm failed";
+ }
+ function getBinaryPromise(binaryFile) {
+ if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+ if (typeof fetch == "function" && !isFileURI(binaryFile)) {
+ return fetch(binaryFile, { credentials: "same-origin" })
+ .then((response) => {
+ if (!response["ok"]) {
+ throw "failed to load wasm binary file at '" + binaryFile + "'";
+ }
+ return response["arrayBuffer"]();
+ })
+ .catch(() => getBinarySync(binaryFile));
+ } else if (readAsync) {
+ return new Promise((resolve, reject) => {
+ readAsync(
+ binaryFile,
+ (response) => resolve(new Uint8Array(response)),
+ reject,
+ );
+ });
+ }
+ }
+ return Promise.resolve().then(() => getBinarySync(binaryFile));
+ }
+ function instantiateArrayBuffer(binaryFile, imports, receiver) {
+ return getBinaryPromise(binaryFile)
+ .then((binary) => WebAssembly.instantiate(binary, imports))
+ .then((instance) => instance)
+ .then(receiver, (reason) => {
+ err(`failed to asynchronously prepare wasm: ${reason}`);
+ abort(reason);
+ });
+ }
+ function instantiateAsync(binary, binaryFile, imports, callback) {
+ if (
+ !binary &&
+ typeof WebAssembly.instantiateStreaming == "function" &&
+ !isDataURI(binaryFile) &&
+ !isFileURI(binaryFile) &&
+ !ENVIRONMENT_IS_NODE &&
+ typeof fetch == "function"
+ ) {
+ return fetch(binaryFile, { credentials: "same-origin" }).then(
+ (response) => {
+ var result = WebAssembly.instantiateStreaming(response, imports);
+ return result.then(callback, function (reason) {
+ err(`wasm streaming compile failed: ${reason}`);
+ err("falling back to ArrayBuffer instantiation");
+ return instantiateArrayBuffer(binaryFile, imports, callback);
+ });
+ },
+ );
+ }
+ return instantiateArrayBuffer(binaryFile, imports, callback);
+ }
+ function createWasm() {
+ var info = { a: wasmImports };
+ function receiveInstance(instance, module) {
+ wasmExports = instance.exports;
+ wasmExports = Asyncify.instrumentWasmExports(wasmExports);
+ wasmExports = applySignatureConversions(wasmExports);
+ registerTLSInit(wasmExports["Hd"]);
+ wasmTable = wasmExports["Dd"];
+ addOnInit(wasmExports["Bd"]);
+ wasmModule = module;
+ removeRunDependency("wasm-instantiate");
+ return wasmExports;
+ }
+ addRunDependency("wasm-instantiate");
+ function receiveInstantiationResult(result) {
+ receiveInstance(result["instance"], result["module"]);
+ }
+ if (Module["instantiateWasm"]) {
+ try {
+ return Module["instantiateWasm"](info, receiveInstance);
+ } catch (e) {
+ err(`Module.instantiateWasm callback failed with error: ${e}`);
+ readyPromiseReject(e);
+ }
+ }
+ instantiateAsync(
+ wasmBinary,
+ wasmBinaryFile,
+ info,
+ receiveInstantiationResult,
+ ).catch(readyPromiseReject);
+ return {};
+ }
+ var tempDouble;
+ var tempI64;
+ function __asyncjs__fetch_asset(route, dataPtr) {
+ return Asyncify.handleAsync(async () => {
+ const routeString = UTF8ToString(route);
+ const absoluteUrl = new URL(routeString);
+ try {
+ const response = await fetch(absoluteUrl);
+ if (!response.ok)
+ throw new Error("Fetch failed: " + response.statusText);
+ const buffer = await response.arrayBuffer();
+ const length = buffer.byteLength;
+ const ptr = _malloc(length);
+ GROWABLE_HEAP_U8().set(new Uint8Array(buffer), ptr >>> 0);
+ Module.HEAP32[dataPtr >> 2] = ptr;
+ Module.HEAP32[(dataPtr >> 2) + 1] = length;
+ } catch (err) {
+ console.error("Error in fetch_asset: ", err);
+ Module.HEAP32[dataPtr >> 2] = 0;
+ Module.HEAP32[(dataPtr >> 2) + 1] = 0;
+ }
+ });
+ }
+ function addToLoadedFiles(path) {
+ if (typeof self !== "undefined") {
+ if (typeof self.loadedFiles === "undefined") {
+ self.loadedFiles = [];
+ }
+ } else {
+ console.log("Neither window nor self is defined");
+ }
+ self.loadedFiles.push(UTF8ToString(path));
+ }
+ function downloadJS(data, filenamedata) {
+ const text = UTF8ToString(data);
+ const filename = UTF8ToString(filenamedata);
+ let element = document.createElement("a");
+ element.setAttribute(
+ "href",
+ "data:text/plain;charset=utf-8," + encodeURIComponent(text),
+ );
+ element.setAttribute("download", filename);
+ element.style.display = "none";
+ document.body.appendChild(element);
+ element.click();
+ document.body.removeChild(element);
+ }
+ function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = `Program terminated with exit(${status})`;
+ this.status = status;
+ }
+ var terminateWorker = (worker) => {
+ worker.terminate();
+ worker.onmessage = (e) => {};
+ };
+ var killThread = (pthread_ptr) => {
+ var worker = PThread.pthreads[pthread_ptr];
+ delete PThread.pthreads[pthread_ptr];
+ terminateWorker(worker);
+ __emscripten_thread_free_data(pthread_ptr);
+ PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker), 1);
+ worker.pthread_ptr = 0;
+ };
+ var cancelThread = (pthread_ptr) => {
+ var worker = PThread.pthreads[pthread_ptr];
+ worker.postMessage({ cmd: "cancel" });
+ };
+ var cleanupThread = (pthread_ptr) => {
+ var worker = PThread.pthreads[pthread_ptr];
+ assert(worker);
+ PThread.returnWorkerToPool(worker);
+ };
+ var zeroMemory = (address, size) => {
+ GROWABLE_HEAP_U8().fill(0, address, address + size);
+ return address;
+ };
+ var spawnThread = (threadParams) => {
+ var worker = PThread.getNewWorker();
+ if (!worker) {
+ return 6;
+ }
+ PThread.runningWorkers.push(worker);
+ PThread.pthreads[threadParams.pthread_ptr] = worker;
+ worker.pthread_ptr = threadParams.pthread_ptr;
+ var msg = {
+ cmd: "run",
+ start_routine: threadParams.startRoutine,
+ arg: threadParams.arg,
+ pthread_ptr: threadParams.pthread_ptr,
+ };
+ if (ENVIRONMENT_IS_NODE) {
+ worker.unref();
+ }
+ worker.postMessage(msg, threadParams.transferList);
+ return 0;
+ };
+ var runtimeKeepaliveCounter = 0;
+ var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+ 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.substr(-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.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },
+ basename: (path) => {
+ if (path === "/") return "/";
+ path = PATH.normalize(path);
+ path = path.replace(/\/$/, "");
+ var lastSlash = path.lastIndexOf("/");
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash + 1);
+ },
+ join: function () {
+ var paths = Array.prototype.slice.call(arguments);
+ return PATH.normalize(paths.join("/"));
+ },
+ join2: (l, r) => PATH.normalize(l + "/" + r),
+ };
+ var initRandomFill = () => {
+ if (
+ typeof crypto == "object" &&
+ typeof crypto["getRandomValues"] == "function"
+ ) {
+ return (view) => (
+ view.set(crypto.getRandomValues(new Uint8Array(view.byteLength))),
+ view
+ );
+ } else if (ENVIRONMENT_IS_NODE) {
+ try {
+ var crypto_module = require("crypto");
+ var randomFillSync = crypto_module["randomFillSync"];
+ if (randomFillSync) {
+ return (view) => crypto_module["randomFillSync"](view);
+ }
+ var randomBytes = crypto_module["randomBytes"];
+ return (view) => (view.set(randomBytes(view.byteLength)), view);
+ } catch (e) {}
+ }
+ abort("initRandomDevice");
+ };
+ var randomFill = (view) => (randomFill = initRandomFill())(view);
+ var PATH_FS = {
+ resolve: function () {
+ var resolvedPath = "",
+ resolvedAbsolute = false;
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = i >= 0 ? arguments[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).substr(1);
+ to = PATH_FS.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== "") break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 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 < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push("..");
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join("/");
+ },
+ };
+ var UTF8Decoder =
+ typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
+ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
+ idx >>>= 0;
+ var endIdx = idx + maxBytesToRead;
+ var endPtr = idx;
+ while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+ if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+ return UTF8Decoder.decode(heapOrArray.slice(idx, endPtr));
+ }
+ var str = "";
+ while (idx < endPtr) {
+ var u0 = heapOrArray[idx++];
+ if (!(u0 & 128)) {
+ str += String.fromCharCode(u0);
+ continue;
+ }
+ var u1 = heapOrArray[idx++] & 63;
+ if ((u0 & 224) == 192) {
+ str += String.fromCharCode(((u0 & 31) << 6) | u1);
+ continue;
+ }
+ var u2 = heapOrArray[idx++] & 63;
+ if ((u0 & 240) == 224) {
+ u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+ } else {
+ u0 =
+ ((u0 & 7) << 18) |
+ (u1 << 12) |
+ (u2 << 6) |
+ (heapOrArray[idx++] & 63);
+ }
+ if (u0 < 65536) {
+ str += String.fromCharCode(u0);
+ } else {
+ var ch = u0 - 65536;
+ str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+ }
+ }
+ return str;
+ };
+ var FS_stdin_getChar_buffer = [];
+ var lengthBytesUTF8 = (str) => {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+ var c = str.charCodeAt(i);
+ if (c <= 127) {
+ len++;
+ } else if (c <= 2047) {
+ len += 2;
+ } else if (c >= 55296 && c <= 57343) {
+ len += 4;
+ ++i;
+ } else {
+ len += 3;
+ }
+ }
+ return len;
+ };
+ var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+ outIdx >>>= 0;
+ if (!(maxBytesToWrite > 0)) return 0;
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1;
+ for (var i = 0; i < str.length; ++i) {
+ var u = str.charCodeAt(i);
+ if (u >= 55296 && u <= 57343) {
+ var u1 = str.charCodeAt(++i);
+ u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
+ }
+ if (u <= 127) {
+ if (outIdx >= endIdx) break;
+ heap[outIdx++ >>> 0] = u;
+ } else if (u <= 2047) {
+ if (outIdx + 1 >= endIdx) break;
+ heap[outIdx++ >>> 0] = 192 | (u >> 6);
+ heap[outIdx++ >>> 0] = 128 | (u & 63);
+ } else if (u <= 65535) {
+ if (outIdx + 2 >= endIdx) break;
+ heap[outIdx++ >>> 0] = 224 | (u >> 12);
+ heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63);
+ heap[outIdx++ >>> 0] = 128 | (u & 63);
+ } else {
+ if (outIdx + 3 >= endIdx) break;
+ heap[outIdx++ >>> 0] = 240 | (u >> 18);
+ heap[outIdx++ >>> 0] = 128 | ((u >> 12) & 63);
+ heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63);
+ heap[outIdx++ >>> 0] = 128 | (u & 63);
+ }
+ }
+ heap[outIdx >>> 0] = 0;
+ return outIdx - startIdx;
+ };
+ function 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 (ENVIRONMENT_IS_NODE) {
+ var BUFSIZE = 256;
+ var buf = Buffer.alloc(BUFSIZE);
+ var bytesRead = 0;
+ var fd = process.stdin.fd;
+ try {
+ bytesRead = fs.readSync(fd, buf);
+ } catch (e) {
+ if (e.toString().includes("EOF")) bytesRead = 0;
+ else throw e;
+ }
+ if (bytesRead > 0) {
+ result = buf.slice(0, bytesRead).toString("utf-8");
+ } else {
+ result = null;
+ }
+ } else if (
+ typeof window != "undefined" &&
+ typeof window.prompt == "function"
+ ) {
+ result = window.prompt("Input: ");
+ if (result !== null) {
+ result += "\n";
+ }
+ } else if (typeof readline == "function") {
+ result = readline();
+ if (result !== null) {
+ result += "\n";
+ }
+ }
+ 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: 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; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(6);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset + i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write(stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(60);
+ }
+ try {
+ for (var i = 0; i < length; i++) {
+ stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+ }
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ },
+ },
+ default_tty_ops: {
+ get_char(tty) {
+ return FS_stdin_getChar();
+ },
+ put_char(tty, val) {
+ if (val === null || val === 10) {
+ out(UTF8ArrayToString(tty.output, 0));
+ tty.output = [];
+ } else {
+ if (val != 0) tty.output.push(val);
+ }
+ },
+ fsync(tty) {
+ if (tty.output && tty.output.length > 0) {
+ out(UTF8ArrayToString(tty.output, 0));
+ 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, 0));
+ tty.output = [];
+ } else {
+ if (val != 0) tty.output.push(val);
+ }
+ },
+ fsync(tty) {
+ if (tty.output && tty.output.length > 0) {
+ err(UTF8ArrayToString(tty.output, 0));
+ tty.output = [];
+ }
+ },
+ },
+ };
+ var alignMemory = (size, alignment) =>
+ Math.ceil(size / alignment) * alignment;
+ var mmapAlloc = (size) => {
+ size = alignMemory(size, 65536);
+ var ptr = _emscripten_builtin_memalign(65536, size);
+ if (!ptr) return 0;
+ return zeroMemory(ptr, size);
+ };
+ var MEMFS = {
+ ops_table: null,
+ mount(mount) {
+ return MEMFS.createNode(null, "/", 16384 | 511, 0);
+ },
+ createNode(parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ throw new FS.ErrnoError(63);
+ }
+ if (!MEMFS.ops_table) {
+ 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,
+ allocate: MEMFS.stream_ops.allocate,
+ 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 = null;
+ } 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.timestamp = Date.now();
+ if (parent) {
+ parent.contents[name] = node;
+ parent.timestamp = node.timestamp;
+ }
+ return node;
+ },
+ getFileDataAsTypedArray(node) {
+ if (!node.contents) return new Uint8Array(0);
+ if (node.contents.subarray)
+ return node.contents.subarray(0, node.usedBytes);
+ return new Uint8Array(node.contents);
+ },
+ expandFileStorage(node, newCapacity) {
+ var prevCapacity = node.contents ? node.contents.length : 0;
+ if (prevCapacity >= newCapacity) return;
+ var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+ newCapacity = Math.max(
+ newCapacity,
+ (prevCapacity *
+ (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>>
+ 0,
+ );
+ if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
+ var oldContents = node.contents;
+ node.contents = new Uint8Array(newCapacity);
+ if (node.usedBytes > 0)
+ node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
+ },
+ resizeFileStorage(node, newSize) {
+ if (node.usedBytes == newSize) return;
+ if (newSize == 0) {
+ node.contents = null;
+ node.usedBytes = 0;
+ } else {
+ var oldContents = node.contents;
+ node.contents = new Uint8Array(newSize);
+ if (oldContents) {
+ 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.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },
+ setattr(node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.resizeFileStorage(node, attr.size);
+ }
+ },
+ lookup(parent, name) {
+ throw FS.genericErrors[44];
+ },
+ mknod(parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },
+ rename(old_node, new_dir, new_name) {
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {}
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(55);
+ }
+ }
+ }
+ delete old_node.parent.contents[old_node.name];
+ old_node.parent.timestamp = Date.now();
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ new_dir.timestamp = old_node.parent.timestamp;
+ old_node.parent = new_dir;
+ },
+ unlink(parent, name) {
+ delete parent.contents[name];
+ parent.timestamp = 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.timestamp = Date.now();
+ },
+ readdir(node) {
+ var entries = [".", ".."];
+ for (var key in node.contents) {
+ if (!node.contents.hasOwnProperty(key)) {
+ continue;
+ }
+ entries.push(key);
+ }
+ return entries;
+ },
+ 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);
+ if (size > 8 && contents.subarray) {
+ buffer.set(contents.subarray(position, position + size), offset);
+ } else {
+ for (var i = 0; i < size; i++)
+ buffer[offset + i] = contents[position + i];
+ }
+ return size;
+ },
+ write(stream, buffer, offset, length, position, canOwn) {
+ if (buffer.buffer === GROWABLE_HEAP_I8().buffer) {
+ canOwn = false;
+ }
+ if (!length) return 0;
+ var node = stream.node;
+ node.timestamp = Date.now();
+ if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+ if (canOwn) {
+ node.contents = buffer.subarray(offset, offset + length);
+ node.usedBytes = length;
+ return length;
+ } else if (node.usedBytes === 0 && position === 0) {
+ node.contents = buffer.slice(offset, offset + length);
+ node.usedBytes = length;
+ return length;
+ } else if (position + length <= node.usedBytes) {
+ node.contents.set(
+ buffer.subarray(offset, offset + length),
+ position,
+ );
+ return length;
+ }
+ }
+ MEMFS.expandFileStorage(node, position + length);
+ if (node.contents.subarray && buffer.subarray) {
+ node.contents.set(
+ buffer.subarray(offset, offset + length),
+ position,
+ );
+ } else {
+ for (var i = 0; i < length; i++) {
+ node.contents[position + i] = buffer[offset + i];
+ }
+ }
+ 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;
+ },
+ allocate(stream, offset, length) {
+ MEMFS.expandFileStorage(stream.node, offset + length);
+ stream.node.usedBytes = Math.max(
+ stream.node.usedBytes,
+ offset + length,
+ );
+ },
+ 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 === GROWABLE_HEAP_I8().buffer) {
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(
+ contents,
+ position,
+ position + length,
+ );
+ }
+ }
+ allocated = true;
+ ptr = mmapAlloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(48);
+ }
+ GROWABLE_HEAP_I8().set(contents, ptr >>> 0);
+ }
+ return { ptr: ptr, allocated: allocated };
+ },
+ msync(stream, buffer, offset, length, mmapFlags) {
+ MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+ return 0;
+ },
+ },
+ };
+ var asyncLoad = (url, onload, onerror, noRunDep) => {
+ var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : "";
+ readAsync(
+ url,
+ (arrayBuffer) => {
+ assert(
+ arrayBuffer,
+ `Loading data file "${url}" failed (no arrayBuffer).`,
+ );
+ onload(new Uint8Array(arrayBuffer));
+ if (dep) removeRunDependency(dep);
+ },
+ (event) => {
+ if (onerror) {
+ onerror();
+ } else {
+ throw `Loading data file "${url}" failed.`;
+ }
+ },
+ );
+ if (dep) addRunDependency(dep);
+ };
+ var FS_createDataFile = (
+ parent,
+ name,
+ fileData,
+ canRead,
+ canWrite,
+ canOwn,
+ ) => FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn);
+ var preloadPlugins = Module["preloadPlugins"] || [];
+ var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+ if (typeof Browser != "undefined") Browser.init();
+ var handled = false;
+ preloadPlugins.forEach((plugin) => {
+ if (handled) return;
+ if (plugin["canHandle"](fullname)) {
+ plugin["handle"](byteArray, fullname, finish, onerror);
+ handled = true;
+ }
+ });
+ return handled;
+ };
+ var FS_createPreloadedFile = (
+ parent,
+ name,
+ url,
+ canRead,
+ canWrite,
+ onload,
+ onerror,
+ dontCreateFile,
+ canOwn,
+ preFinish,
+ ) => {
+ var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+ var dep = getUniqueRunDependency(`cp ${fullname}`);
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (preFinish) preFinish();
+ if (!dontCreateFile) {
+ FS_createDataFile(
+ parent,
+ name,
+ byteArray,
+ canRead,
+ canWrite,
+ canOwn,
+ );
+ }
+ if (onload) onload();
+ removeRunDependency(dep);
+ }
+ if (
+ FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
+ if (onerror) onerror();
+ removeRunDependency(dep);
+ })
+ ) {
+ return;
+ }
+ finish(byteArray);
+ }
+ addRunDependency(dep);
+ if (typeof url == "string") {
+ asyncLoad(url, (byteArray) => processData(byteArray), onerror);
+ } else {
+ processData(url);
+ }
+ };
+ var FS_modeStringToFlags = (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_getMode = (canRead, canWrite) => {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ };
+ var FS = {
+ root: null,
+ mounts: [],
+ devices: {},
+ streams: [],
+ nextInode: 1,
+ nameTable: null,
+ currentPath: "/",
+ initialized: false,
+ ignorePermissions: true,
+ ErrnoError: null,
+ genericErrors: {},
+ filesystems: null,
+ syncFSRequests: 0,
+ lookupPath(path, opts = {}) {
+ path = PATH_FS.resolve(path);
+ if (!path) return { path: "", node: null };
+ var defaults = { follow_mount: true, recurse_count: 0 };
+ opts = Object.assign(defaults, opts);
+ if (opts.recurse_count > 8) {
+ throw new FS.ErrnoError(32);
+ }
+ var parts = path.split("/").filter((p) => !!p);
+ var current = FS.root;
+ var current_path = "/";
+ for (var i = 0; i < parts.length; i++) {
+ var islast = i === parts.length - 1;
+ if (islast && opts.parent) {
+ break;
+ }
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
+ var lookup = FS.lookupPath(current_path, {
+ recurse_count: opts.recurse_count + 1,
+ });
+ current = lookup.node;
+ if (count++ > 40) {
+ throw new FS.ErrnoError(32);
+ }
+ }
+ }
+ }
+ return { path: current_path, node: current };
+ },
+ getPath(node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length - 1] !== "/"
+ ? `${mount}/${path}`
+ : mount + path;
+ }
+ path = path ? `${node.name}/${path}` : node.name;
+ node = node.parent;
+ }
+ },
+ hashName(parentid, name) {
+ var hash = 0;
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 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, parent);
+ }
+ 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;
+ } else if (perms.includes("w") && !(node.mode & 146)) {
+ return 2;
+ } else if (perms.includes("x") && !(node.mode & 73)) {
+ return 2;
+ }
+ return 0;
+ },
+ mayLookup(dir) {
+ var errCode = FS.nodePermissions(dir, "x");
+ if (errCode) return errCode;
+ if (!dir.node_ops.lookup) return 2;
+ return 0;
+ },
+ mayCreate(dir, name) {
+ 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;
+ } else if (FS.isDir(node.mode)) {
+ if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
+ return 31;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },
+ 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) {
+ if (!FS.FSStream) {
+ FS.FSStream = function () {
+ this.shared = {};
+ };
+ FS.FSStream.prototype = {};
+ Object.defineProperties(FS.FSStream.prototype, {
+ object: {
+ get() {
+ return this.node;
+ },
+ set(val) {
+ this.node = val;
+ },
+ },
+ isRead: {
+ get() {
+ return (this.flags & 2097155) !== 1;
+ },
+ },
+ isWrite: {
+ get() {
+ return (this.flags & 2097155) !== 0;
+ },
+ },
+ isAppend: {
+ get() {
+ return this.flags & 1024;
+ },
+ },
+ flags: {
+ get() {
+ return this.shared.flags;
+ },
+ set(val) {
+ this.shared.flags = val;
+ },
+ },
+ position: {
+ get() {
+ return this.shared.position;
+ },
+ set(val) {
+ this.shared.position = val;
+ },
+ },
+ });
+ }
+ 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;
+ },
+ chrdev_stream_ops: {
+ open(stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ stream.stream_ops = device.stream_ops;
+ if (stream.stream_ops.open) {
+ 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.apply(check, 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);
+ }
+ }
+ mounts.forEach((mount) => {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },
+ 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: type,
+ opts: opts,
+ mountpoint: 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);
+ Object.keys(FS.nameTable).forEach((hash) => {
+ var current = FS.nameTable[hash];
+ 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 || name === "." || name === "..") {
+ throw new FS.ErrnoError(28);
+ }
+ 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);
+ },
+ create(path, mode) {
+ mode = mode !== undefined ? mode : 438;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },
+ mkdir(path, mode) {
+ mode = mode !== undefined ? mode : 511;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },
+ mkdirTree(path, mode) {
+ var dirs = path.split("/");
+ var d = "";
+ for (var i = 0; i < dirs.length; ++i) {
+ if (!dirs[i]) continue;
+ d += "/" + dirs[i];
+ 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);
+ },
+ 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);
+ } 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;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(54);
+ }
+ return node.node_ops.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 PATH_FS.resolve(
+ FS.getPath(link.parent),
+ link.node_ops.readlink(link),
+ );
+ },
+ stat(path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node) {
+ throw new FS.ErrnoError(44);
+ }
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(63);
+ }
+ return node.node_ops.getattr(node);
+ },
+ lstat(path) {
+ return FS.stat(path, true);
+ },
+ chmod(path, mode, dontFollow) {
+ var node;
+ if (typeof path == "string") {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(63);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now(),
+ });
+ },
+ lchmod(path, mode) {
+ FS.chmod(path, mode, true);
+ },
+ fchmod(fd, mode) {
+ var stream = FS.getStreamChecked(fd);
+ FS.chmod(stream.node, mode);
+ },
+ chown(path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path == "string") {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(63);
+ }
+ node.node_ops.setattr(node, { timestamp: Date.now() });
+ },
+ lchown(path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },
+ fchown(fd, uid, gid) {
+ var stream = FS.getStreamChecked(fd);
+ FS.chown(stream.node, uid, gid);
+ },
+ 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;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(63);
+ }
+ 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);
+ }
+ node.node_ops.setattr(node, { size: len, timestamp: Date.now() });
+ },
+ ftruncate(fd, len) {
+ var stream = FS.getStreamChecked(fd);
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(28);
+ }
+ FS.truncate(stream.node, len);
+ },
+ utime(path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) });
+ },
+ open(path, flags, mode) {
+ if (path === "") {
+ throw new FS.ErrnoError(44);
+ }
+ flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
+ mode = typeof mode == "undefined" ? 438 : mode;
+ if (flags & 64) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path == "object") {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, { follow: !(flags & 131072) });
+ node = lookup.node;
+ } catch (e) {}
+ }
+ var created = false;
+ if (flags & 64) {
+ if (node) {
+ if (flags & 128) {
+ throw new FS.ErrnoError(20);
+ }
+ } else {
+ node = FS.mknod(path, mode, 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: node,
+ path: FS.getPath(node),
+ flags: flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ ungotten: [],
+ error: false,
+ });
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module["logReadFiles"] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ }
+ }
+ return stream;
+ },
+ close(stream) {
+ if (FS.isClosed(stream)) {
+ throw new FS.ErrnoError(8);
+ }
+ if (stream.getdents) stream.getdents = null;
+ 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;
+ },
+ allocate(stream, offset, length) {
+ if (FS.isClosed(stream)) {
+ throw new FS.ErrnoError(8);
+ }
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(28);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(8);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(43);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(138);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },
+ mmap(stream, length, position, prot, flags) {
+ if (
+ (prot & 2) !== 0 &&
+ (flags & 2) === 0 &&
+ (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);
+ }
+ 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,
+ );
+ },
+ munmap: (stream) => 0,
+ 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") {
+ throw new Error(`Invalid encoding type "${opts.encoding}"`);
+ }
+ var ret;
+ 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") {
+ ret = UTF8ArrayToString(buf, 0);
+ } else if (opts.encoding === "binary") {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },
+ writeFile(path, data, opts = {}) {
+ opts.flags = opts.flags || 577;
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (typeof data == "string") {
+ var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
+ var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
+ FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
+ } else if (ArrayBuffer.isView(data)) {
+ FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
+ } else {
+ throw new Error("Unsupported data type");
+ }
+ 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,
+ });
+ 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 === 0) {
+ randomLeft = randomFill(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", 16384 | 511, 73);
+ 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 },
+ };
+ ret.parent = ret;
+ return ret;
+ },
+ };
+ return node;
+ },
+ },
+ {},
+ "/proc/self/fd",
+ );
+ },
+ createStandardStreams() {
+ if (Module["stdin"]) {
+ FS.createDevice("/dev", "stdin", Module["stdin"]);
+ } else {
+ FS.symlink("/dev/tty", "/dev/stdin");
+ }
+ if (Module["stdout"]) {
+ FS.createDevice("/dev", "stdout", null, Module["stdout"]);
+ } else {
+ FS.symlink("/dev/tty", "/dev/stdout");
+ }
+ if (Module["stderr"]) {
+ FS.createDevice("/dev", "stderr", null, Module["stderr"]);
+ } 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);
+ },
+ ensureErrnoError() {
+ if (FS.ErrnoError) return;
+ FS.ErrnoError = function ErrnoError(errno, node) {
+ this.name = "ErrnoError";
+ this.node = node;
+ this.setErrno = function (errno) {
+ this.errno = errno;
+ };
+ this.setErrno(errno);
+ this.message = "FS error";
+ };
+ FS.ErrnoError.prototype = new Error();
+ FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+ [44].forEach((code) => {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = "";
+ });
+ },
+ staticInit() {
+ FS.ensureErrnoError();
+ FS.nameTable = new Array(4096);
+ FS.mount(MEMFS, {}, "/");
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ FS.createSpecialDirectories();
+ FS.filesystems = { MEMFS: MEMFS };
+ },
+ init(input, output, error) {
+ FS.init.initialized = true;
+ FS.ensureErrnoError();
+ Module["stdin"] = input || Module["stdin"];
+ Module["stdout"] = output || Module["stdout"];
+ Module["stderr"] = error || Module["stderr"];
+ FS.createStandardStreams();
+ },
+ quit() {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ 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) {}
+ 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) {
+ if (typeof data == "string") {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i)
+ arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ 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);
+ }
+ return node;
+ },
+ createDevice(parent, name, input, output) {
+ var path = PATH.join2(
+ typeof parent == "string" ? parent : FS.getPath(parent),
+ name,
+ );
+ var mode = FS_getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ FS.registerDevice(dev, {
+ open(stream) {
+ stream.seekable = false;
+ },
+ close(stream) {
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read(stream, buffer, offset, length, pos) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(6);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset + i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset + i]);
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ },
+ });
+ return FS.mkdev(path, mode, dev);
+ },
+ forceLoadFile(obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents)
+ return true;
+ if (typeof XMLHttpRequest != "undefined") {
+ throw new Error(
+ "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.",
+ );
+ } else if (read_) {
+ try {
+ obj.contents = intArrayFromString(read_(obj.url), true);
+ obj.usedBytes = obj.contents.length;
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ } else {
+ throw new Error("Cannot load without read() or XMLHttpRequest.");
+ }
+ },
+ createLazyFile(parent, name, url, canRead, canWrite) {
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = [];
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length - 1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = (idx / this.chunkSize) | 0;
+ return this.getter(chunkNum)[chunkOffset];
+ };
+ LazyUint8Array.prototype.setDataGetter =
+ function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ };
+ LazyUint8Array.prototype.cacheLength =
+ function LazyUint8Array_cacheLength() {
+ var xhr = new XMLHttpRequest();
+ xhr.open("HEAD", url, false);
+ xhr.send(null);
+ if (
+ !((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304)
+ )
+ throw new Error(
+ "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)
+ throw new Error(
+ "invalid range (" +
+ from +
+ ", " +
+ to +
+ ") or no bytes requested!",
+ );
+ if (to > datalength - 1)
+ throw new Error(
+ "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)
+ )
+ throw new Error(
+ "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")
+ throw new Error("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;
+ };
+ if (typeof XMLHttpRequest != "undefined") {
+ if (!ENVIRONMENT_IS_WORKER)
+ throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperties(lazyArray, {
+ length: {
+ get: function () {
+ if (!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ },
+ },
+ chunkSize: {
+ get: function () {
+ if (!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ },
+ },
+ });
+ var properties = { isDevice: false, contents: lazyArray };
+ } else {
+ var properties = { isDevice: false, url: 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 = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach((key) => {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ FS.forceLoadFile(node);
+ return fn.apply(null, arguments);
+ };
+ });
+ 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 < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ }
+ stream_ops.read = (stream, buffer, offset, length, position) => {
+ 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, GROWABLE_HEAP_I8(), ptr, length, position);
+ return { ptr: ptr, allocated: true };
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },
+ };
+ var UTF8ToString = (ptr, maxBytesToRead) => {
+ ptr >>>= 0;
+ return ptr
+ ? UTF8ArrayToString(GROWABLE_HEAP_U8(), ptr, maxBytesToRead)
+ : "";
+ };
+ var SYSCALLS = {
+ DEFAULT_POLLMASK: 5,
+ 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 PATH.join2(dir, path);
+ },
+ doStat(func, path, buf) {
+ try {
+ var stat = func(path);
+ } catch (e) {
+ if (
+ e &&
+ e.node &&
+ PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))
+ ) {
+ return -54;
+ }
+ throw e;
+ }
+ GROWABLE_HEAP_I32()[(buf >>> 2) >>> 0] = stat.dev;
+ GROWABLE_HEAP_I32()[((buf + 4) >>> 2) >>> 0] = stat.mode;
+ GROWABLE_HEAP_U32()[((buf + 8) >>> 2) >>> 0] = stat.nlink;
+ GROWABLE_HEAP_I32()[((buf + 12) >>> 2) >>> 0] = stat.uid;
+ GROWABLE_HEAP_I32()[((buf + 16) >>> 2) >>> 0] = stat.gid;
+ GROWABLE_HEAP_I32()[((buf + 20) >>> 2) >>> 0] = stat.rdev;
+ (tempI64 = [
+ stat.size >>> 0,
+ ((tempDouble = stat.size),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((buf + 24) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((buf + 28) >>> 2) >>> 0] = tempI64[1]);
+ GROWABLE_HEAP_I32()[((buf + 32) >>> 2) >>> 0] = 4096;
+ GROWABLE_HEAP_I32()[((buf + 36) >>> 2) >>> 0] = stat.blocks;
+ var atime = stat.atime.getTime();
+ var mtime = stat.mtime.getTime();
+ var ctime = stat.ctime.getTime();
+ (tempI64 = [
+ Math.floor(atime / 1e3) >>> 0,
+ ((tempDouble = Math.floor(atime / 1e3)),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((buf + 40) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((buf + 44) >>> 2) >>> 0] = tempI64[1]);
+ GROWABLE_HEAP_U32()[((buf + 48) >>> 2) >>> 0] = (atime % 1e3) * 1e3;
+ (tempI64 = [
+ Math.floor(mtime / 1e3) >>> 0,
+ ((tempDouble = Math.floor(mtime / 1e3)),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((buf + 56) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((buf + 60) >>> 2) >>> 0] = tempI64[1]);
+ GROWABLE_HEAP_U32()[((buf + 64) >>> 2) >>> 0] = (mtime % 1e3) * 1e3;
+ (tempI64 = [
+ Math.floor(ctime / 1e3) >>> 0,
+ ((tempDouble = Math.floor(ctime / 1e3)),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((buf + 72) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((buf + 76) >>> 2) >>> 0] = tempI64[1]);
+ GROWABLE_HEAP_U32()[((buf + 80) >>> 2) >>> 0] = (ctime % 1e3) * 1e3;
+ (tempI64 = [
+ stat.ino >>> 0,
+ ((tempDouble = stat.ino),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((buf + 88) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((buf + 92) >>> 2) >>> 0] = tempI64[1]);
+ return 0;
+ },
+ doMsync(addr, stream, len, flags, offset) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(43);
+ }
+ if (flags & 2) {
+ return 0;
+ }
+ var buffer = GROWABLE_HEAP_U8().slice(addr, addr + len);
+ FS.msync(stream, buffer, offset, len, flags);
+ },
+ varargs: undefined,
+ get() {
+ var ret = GROWABLE_HEAP_I32()[(+SYSCALLS.varargs >>> 2) >>> 0];
+ SYSCALLS.varargs += 4;
+ return ret;
+ },
+ getp() {
+ return SYSCALLS.get();
+ },
+ getStr(ptr) {
+ var ret = UTF8ToString(ptr);
+ return ret;
+ },
+ getStreamFromFD(fd) {
+ var stream = FS.getStreamChecked(fd);
+ return stream;
+ },
+ };
+ function _proc_exit(code) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(0, 1, code);
+ EXITSTATUS = code;
+ if (!keepRuntimeAlive()) {
+ PThread.terminateAllThreads();
+ if (Module["onExit"]) Module["onExit"](code);
+ ABORT = true;
+ }
+ quit_(code, new ExitStatus(code));
+ }
+ var exitJS = (status, implicit) => {
+ EXITSTATUS = status;
+ if (ENVIRONMENT_IS_PTHREAD) {
+ exitOnMainThread(status);
+ throw "unwind";
+ }
+ _proc_exit(status);
+ };
+ var _exit = exitJS;
+ var handleException = (e) => {
+ if (e instanceof ExitStatus || e == "unwind") {
+ return EXITSTATUS;
+ }
+ quit_(1, e);
+ };
+ var PThread = {
+ unusedWorkers: [],
+ runningWorkers: [],
+ tlsInitFunctions: [],
+ pthreads: {},
+ init() {
+ if (ENVIRONMENT_IS_PTHREAD) {
+ PThread.initWorker();
+ } else {
+ PThread.initMainThread();
+ }
+ },
+ initMainThread() {
+ var pthreadPoolSize = 10;
+ while (pthreadPoolSize--) {
+ PThread.allocateUnusedWorker();
+ }
+ addOnPreRun(() => {
+ addRunDependency("loading-workers");
+ PThread.loadWasmModuleToAllWorkers(() =>
+ removeRunDependency("loading-workers"),
+ );
+ });
+ },
+ initWorker() {
+ noExitRuntime = false;
+ },
+ setExitStatus: (status) => {
+ EXITSTATUS = status;
+ },
+ terminateAllThreads__deps: ["$terminateWorker"],
+ terminateAllThreads: () => {
+ for (var worker of PThread.runningWorkers) {
+ terminateWorker(worker);
+ }
+ for (var worker of PThread.unusedWorkers) {
+ terminateWorker(worker);
+ }
+ PThread.unusedWorkers = [];
+ PThread.runningWorkers = [];
+ PThread.pthreads = [];
+ },
+ returnWorkerToPool: (worker) => {
+ var pthread_ptr = worker.pthread_ptr;
+ delete PThread.pthreads[pthread_ptr];
+ PThread.unusedWorkers.push(worker);
+ PThread.runningWorkers.splice(
+ PThread.runningWorkers.indexOf(worker),
+ 1,
+ );
+ worker.pthread_ptr = 0;
+ __emscripten_thread_free_data(pthread_ptr);
+ },
+ receiveObjectTransfer(data) {},
+ 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"]];
+ if (targetWorker) {
+ targetWorker.postMessage(d, d["transferList"]);
+ } else {
+ err(
+ `Internal error! Worker sent a message "${cmd}" to target pthread ${d["targetThread"]}, but that thread no longer exists!`,
+ );
+ }
+ return;
+ }
+ if (cmd === "checkMailbox") {
+ checkMailbox();
+ } else if (cmd === "spawnThread") {
+ spawnThread(d);
+ } else if (cmd === "cleanupThread") {
+ cleanupThread(d["thread"]);
+ } else if (cmd === "killThread") {
+ killThread(d["thread"]);
+ } else if (cmd === "cancelThread") {
+ cancelThread(d["thread"]);
+ } else if (cmd === "loaded") {
+ worker.loaded = true;
+ if (ENVIRONMENT_IS_NODE && !worker.pthread_ptr) {
+ worker.unref();
+ }
+ onFinishedLoading(worker);
+ } else if (cmd === "alert") {
+ alert(`Thread ${d["threadId"]}: ${d["text"]}`);
+ } else if (d.target === "setimmediate") {
+ worker.postMessage(d);
+ } else if (cmd === "callHandler") {
+ Module[d["handler"]](...d["args"]);
+ } else 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;
+ };
+ if (ENVIRONMENT_IS_NODE) {
+ worker.on("message", (data) => worker.onmessage({ data: data }));
+ worker.on("error", (e) => worker.onerror(e));
+ }
+ var handlers = [];
+ var knownHandlers = ["onExit", "onAbort", "print", "printErr"];
+ for (var handler of knownHandlers) {
+ if (Module.hasOwnProperty(handler)) {
+ handlers.push(handler);
+ }
+ }
+ worker.postMessage({
+ cmd: "load",
+ handlers: handlers,
+ urlOrBlob: Module["mainScriptUrlOrBlob"] || _scriptDir,
+ wasmMemory: wasmMemory,
+ wasmModule: wasmModule,
+ });
+ }),
+ loadWasmModuleToAllWorkers(onMaybeReady) {
+ if (ENVIRONMENT_IS_PTHREAD) {
+ return onMaybeReady();
+ }
+ let pthreadPoolReady = Promise.all(
+ PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker),
+ );
+ pthreadPoolReady.then(onMaybeReady);
+ },
+ allocateUnusedWorker() {
+ var worker;
+ var pthreadMainJs = locateFile("emHdBindings.worker.js");
+ worker = new Worker(pthreadMainJs);
+ PThread.unusedWorkers.push(worker);
+ },
+ getNewWorker() {
+ if (PThread.unusedWorkers.length == 0) {
+ PThread.allocateUnusedWorker();
+ PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
+ }
+ return PThread.unusedWorkers.pop();
+ },
+ };
+ Module["PThread"] = PThread;
+ var callRuntimeCallbacks = (callbacks) => {
+ while (callbacks.length > 0) {
+ callbacks.shift()(Module);
+ }
+ };
+ var establishStackSpace = () => {
+ var pthread_ptr = _pthread_self();
+ var stackHigh = GROWABLE_HEAP_U32()[((pthread_ptr + 52) >>> 2) >>> 0];
+ var stackSize = GROWABLE_HEAP_U32()[((pthread_ptr + 56) >>> 2) >>> 0];
+ var stackLow = stackHigh - stackSize;
+ _emscripten_stack_set_limits(stackHigh, stackLow);
+ stackRestore(stackHigh);
+ };
+ Module["establishStackSpace"] = establishStackSpace;
+ function exitOnMainThread(returnCode) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(1, 0, returnCode);
+ _exit(returnCode);
+ }
+ var invokeEntryPoint = (ptr, arg) => {
+ var result = ((a1) => dynCall_ii.apply(null, [ptr, a1]))(arg);
+ function finish(result) {
+ if (keepRuntimeAlive()) {
+ PThread.setExitStatus(result);
+ } else {
+ __emscripten_thread_exit(result);
+ }
+ }
+ finish(result);
+ };
+ Module["invokeEntryPoint"] = invokeEntryPoint;
+ var noExitRuntime = Module["noExitRuntime"] || true;
+ var registerTLSInit = (tlsInitFunc) => {
+ PThread.tlsInitFunctions.push(tlsInitFunc);
+ };
+ var convertI32PairToI53Checked = (lo, hi) =>
+ (hi + 2097152) >>> 0 < 4194305 - !!lo
+ ? (lo >>> 0) + hi * 4294967296
+ : NaN;
+ var ___call_sighandler = function (fp, sig) {
+ fp >>>= 0;
+ return ((a1) => dynCall_vi.apply(null, [fp, a1]))(sig);
+ };
+ var exceptionCaught = [];
+ var uncaughtExceptionCount = 0;
+ function ___cxa_begin_catch(ptr) {
+ ptr >>>= 0;
+ var info = new ExceptionInfo(ptr);
+ if (!info.get_caught()) {
+ info.set_caught(true);
+ uncaughtExceptionCount--;
+ }
+ info.set_rethrown(false);
+ exceptionCaught.push(info);
+ ___cxa_increment_exception_refcount(info.excPtr);
+ return info.get_exception_ptr();
+ }
+ var exceptionLast = 0;
+ var ___cxa_end_catch = () => {
+ _setThrew(0, 0);
+ var info = exceptionCaught.pop();
+ ___cxa_decrement_exception_refcount(info.excPtr);
+ exceptionLast = 0;
+ };
+ function ExceptionInfo(excPtr) {
+ this.excPtr = excPtr;
+ this.ptr = excPtr - 24;
+ this.set_type = function (type) {
+ GROWABLE_HEAP_U32()[((this.ptr + 4) >>> 2) >>> 0] = type;
+ };
+ this.get_type = function () {
+ return GROWABLE_HEAP_U32()[((this.ptr + 4) >>> 2) >>> 0];
+ };
+ this.set_destructor = function (destructor) {
+ GROWABLE_HEAP_U32()[((this.ptr + 8) >>> 2) >>> 0] = destructor;
+ };
+ this.get_destructor = function () {
+ return GROWABLE_HEAP_U32()[((this.ptr + 8) >>> 2) >>> 0];
+ };
+ this.set_caught = function (caught) {
+ caught = caught ? 1 : 0;
+ GROWABLE_HEAP_I8()[((this.ptr + 12) >>> 0) >>> 0] = caught;
+ };
+ this.get_caught = function () {
+ return GROWABLE_HEAP_I8()[((this.ptr + 12) >>> 0) >>> 0] != 0;
+ };
+ this.set_rethrown = function (rethrown) {
+ rethrown = rethrown ? 1 : 0;
+ GROWABLE_HEAP_I8()[((this.ptr + 13) >>> 0) >>> 0] = rethrown;
+ };
+ this.get_rethrown = function () {
+ return GROWABLE_HEAP_I8()[((this.ptr + 13) >>> 0) >>> 0] != 0;
+ };
+ this.init = function (type, destructor) {
+ this.set_adjusted_ptr(0);
+ this.set_type(type);
+ this.set_destructor(destructor);
+ };
+ this.set_adjusted_ptr = function (adjustedPtr) {
+ GROWABLE_HEAP_U32()[((this.ptr + 16) >>> 2) >>> 0] = adjustedPtr;
+ };
+ this.get_adjusted_ptr = function () {
+ return GROWABLE_HEAP_U32()[((this.ptr + 16) >>> 2) >>> 0];
+ };
+ this.get_exception_ptr = function () {
+ var isPointer = ___cxa_is_pointer_type(this.get_type());
+ if (isPointer) {
+ return GROWABLE_HEAP_U32()[(this.excPtr >>> 2) >>> 0];
+ }
+ var adjusted = this.get_adjusted_ptr();
+ if (adjusted !== 0) return adjusted;
+ return this.excPtr;
+ };
+ }
+ function ___resumeException(ptr) {
+ ptr >>>= 0;
+ if (!exceptionLast) {
+ exceptionLast = ptr;
+ }
+ throw exceptionLast;
+ }
+ var findMatchingCatch = (args) => {
+ var thrown = exceptionLast;
+ if (!thrown) {
+ setTempRet0(0);
+ return 0;
+ }
+ var info = new ExceptionInfo(thrown);
+ info.set_adjusted_ptr(thrown);
+ var thrownType = info.get_type();
+ if (!thrownType) {
+ setTempRet0(0);
+ return thrown;
+ }
+ for (var arg in args) {
+ var caughtType = args[arg];
+ if (caughtType === 0 || caughtType === thrownType) {
+ break;
+ }
+ var adjusted_ptr_addr = info.ptr + 16;
+ if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
+ setTempRet0(caughtType);
+ return thrown;
+ }
+ }
+ setTempRet0(thrownType);
+ return thrown;
+ };
+ function ___cxa_find_matching_catch_2() {
+ return findMatchingCatch([]);
+ }
+ function ___cxa_find_matching_catch_3(arg0) {
+ arg0 >>>= 0;
+ return findMatchingCatch([arg0]);
+ }
+ function ___cxa_find_matching_catch_4(arg0, arg1) {
+ arg0 >>>= 0;
+ arg1 >>>= 0;
+ return findMatchingCatch([arg0, arg1]);
+ }
+ function ___cxa_get_exception_ptr(ptr) {
+ ptr >>>= 0;
+ var rtn = new ExceptionInfo(ptr).get_exception_ptr();
+ return rtn;
+ }
+ var ___cxa_rethrow = () => {
+ var info = exceptionCaught.pop();
+ if (!info) {
+ abort("no exception to throw");
+ }
+ var ptr = info.excPtr;
+ if (!info.get_rethrown()) {
+ exceptionCaught.push(info);
+ info.set_rethrown(true);
+ info.set_caught(false);
+ uncaughtExceptionCount++;
+ }
+ exceptionLast = ptr;
+ throw exceptionLast;
+ };
+ function ___cxa_rethrow_primary_exception(ptr) {
+ ptr >>>= 0;
+ if (!ptr) return;
+ var info = new ExceptionInfo(ptr);
+ exceptionCaught.push(info);
+ info.set_rethrown(true);
+ ___cxa_rethrow();
+ }
+ function ___cxa_throw(ptr, type, destructor) {
+ ptr >>>= 0;
+ type >>>= 0;
+ destructor >>>= 0;
+ var info = new ExceptionInfo(ptr);
+ info.init(type, destructor);
+ exceptionLast = ptr;
+ uncaughtExceptionCount++;
+ throw exceptionLast;
+ }
+ var ___cxa_uncaught_exceptions = () => uncaughtExceptionCount;
+ function ___emscripten_init_main_thread_js(tb) {
+ tb >>>= 0;
+ __emscripten_thread_init(
+ tb,
+ !ENVIRONMENT_IS_WORKER,
+ 1,
+ !ENVIRONMENT_IS_WEB,
+ 2097152,
+ false,
+ );
+ PThread.threadInitTLS();
+ }
+ function ___emscripten_thread_cleanup(thread) {
+ thread >>>= 0;
+ if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread);
+ else postMessage({ cmd: "cleanupThread", thread: thread });
+ }
+ function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(2, 1, pthread_ptr, attr, startRoutine, arg);
+ return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg);
+ }
+ function ___pthread_create_js(pthread_ptr, attr, startRoutine, arg) {
+ pthread_ptr >>>= 0;
+ attr >>>= 0;
+ startRoutine >>>= 0;
+ arg >>>= 0;
+ if (typeof SharedArrayBuffer == "undefined") {
+ err(
+ "Current environment does not support SharedArrayBuffer, pthreads are not available!",
+ );
+ return 6;
+ }
+ var transferList = [];
+ var error = 0;
+ if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
+ return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg);
+ }
+ if (error) return error;
+ var threadParams = {
+ startRoutine: startRoutine,
+ pthread_ptr: pthread_ptr,
+ arg: arg,
+ transferList: transferList,
+ };
+ if (ENVIRONMENT_IS_PTHREAD) {
+ threadParams.cmd = "spawnThread";
+ postMessage(threadParams, transferList);
+ return 0;
+ }
+ return spawnThread(threadParams);
+ }
+ function ___syscall_chmod(path, mode) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(3, 1, path, mode);
+ path >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ FS.chmod(path, mode);
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_faccessat(dirfd, path, amode, flags) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(4, 1, dirfd, path, amode, flags);
+ path >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ if (amode & ~7) {
+ return -28;
+ }
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node) {
+ return -44;
+ }
+ var perms = "";
+ if (amode & 4) perms += "r";
+ if (amode & 2) perms += "w";
+ if (amode & 1) perms += "x";
+ if (perms && FS.nodePermissions(node, perms)) {
+ return -2;
+ }
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_fadvise64(fd, offset, len, advice) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(5, 0, fd, offset, len, advice);
+ return 0;
+ }
+ function ___syscall_fchmod(fd, mode) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(6, 1, fd, mode);
+ try {
+ FS.fchmod(fd, mode);
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ var setErrNo = (value) => {
+ GROWABLE_HEAP_I32()[(___errno_location() >>> 2) >>> 0] = value;
+ return value;
+ };
+ function ___syscall_fcntl64(fd, cmd, varargs) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(7, 1, fd, cmd, varargs);
+ varargs >>>= 0;
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (cmd) {
+ case 0: {
+ var arg = SYSCALLS.get();
+ if (arg < 0) {
+ return -28;
+ }
+ while (FS.streams[arg]) {
+ arg++;
+ }
+ var newStream;
+ newStream = FS.createStream(stream, arg);
+ return newStream.fd;
+ }
+ case 1:
+ case 2:
+ return 0;
+ case 3:
+ return stream.flags;
+ case 4: {
+ var arg = SYSCALLS.get();
+ stream.flags |= arg;
+ return 0;
+ }
+ case 5: {
+ var arg = SYSCALLS.getp();
+ var offset = 0;
+ GROWABLE_HEAP_I16()[((arg + offset) >>> 1) >>> 0] = 2;
+ return 0;
+ }
+ case 6:
+ case 7:
+ return 0;
+ case 16:
+ case 8:
+ return -28;
+ case 9:
+ setErrNo(28);
+ return -1;
+ default: {
+ 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(8, 1, fd, buf);
+ buf >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ return SYSCALLS.doStat(FS.stat, stream.path, buf);
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ var stringToUTF8 = (str, outPtr, maxBytesToWrite) =>
+ stringToUTF8Array(str, GROWABLE_HEAP_U8(), outPtr, maxBytesToWrite);
+ function ___syscall_getcwd(buf, size) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(9, 1, buf, size);
+ buf >>>= 0;
+ size >>>= 0;
+ try {
+ if (size === 0) return -28;
+ var cwd = FS.cwd();
+ var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
+ if (size < cwdLengthInBytes) return -68;
+ stringToUTF8(cwd, buf, size);
+ return cwdLengthInBytes;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_getdents64(fd, dirp, count) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(10, 1, fd, dirp, count);
+ dirp >>>= 0;
+ count >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ if (!stream.getdents) {
+ stream.getdents = FS.readdir(stream.path);
+ }
+ var struct_size = 280;
+ var pos = 0;
+ var off = FS.llseek(stream, 0, 1);
+ var idx = Math.floor(off / struct_size);
+ while (idx < stream.getdents.length && pos + struct_size <= count) {
+ var id;
+ var type;
+ var name = stream.getdents[idx];
+ if (name === ".") {
+ id = stream.node.id;
+ type = 4;
+ } else if (name === "..") {
+ var lookup = FS.lookupPath(stream.path, { parent: true });
+ id = lookup.node.id;
+ type = 4;
+ } else {
+ var child = FS.lookupNode(stream.node, name);
+ id = child.id;
+ type = FS.isChrdev(child.mode)
+ ? 2
+ : FS.isDir(child.mode)
+ ? 4
+ : FS.isLink(child.mode)
+ ? 10
+ : 8;
+ }
+ (tempI64 = [
+ id >>> 0,
+ ((tempDouble = id),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((dirp + pos) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((dirp + pos + 4) >>> 2) >>> 0] = tempI64[1]);
+ (tempI64 = [
+ ((idx + 1) * struct_size) >>> 0,
+ ((tempDouble = (idx + 1) * struct_size),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((dirp + pos + 8) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((dirp + pos + 12) >>> 2) >>> 0] = tempI64[1]);
+ GROWABLE_HEAP_I16()[((dirp + pos + 16) >>> 1) >>> 0] = 280;
+ GROWABLE_HEAP_I8()[((dirp + pos + 18) >>> 0) >>> 0] = type;
+ stringToUTF8(name, dirp + pos + 19, 256);
+ pos += struct_size;
+ idx += 1;
+ }
+ FS.llseek(stream, idx * struct_size, 0);
+ return pos;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_ioctl(fd, op, varargs) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(11, 1, fd, op, varargs);
+ varargs >>>= 0;
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (op) {
+ case 21509: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ case 21505: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcgets) {
+ var termios = stream.tty.ops.ioctl_tcgets(stream);
+ var argp = SYSCALLS.getp();
+ GROWABLE_HEAP_I32()[(argp >>> 2) >>> 0] = termios.c_iflag || 0;
+ GROWABLE_HEAP_I32()[((argp + 4) >>> 2) >>> 0] =
+ termios.c_oflag || 0;
+ GROWABLE_HEAP_I32()[((argp + 8) >>> 2) >>> 0] =
+ termios.c_cflag || 0;
+ GROWABLE_HEAP_I32()[((argp + 12) >>> 2) >>> 0] =
+ termios.c_lflag || 0;
+ for (var i = 0; i < 32; i++) {
+ GROWABLE_HEAP_I8()[((argp + i + 17) >>> 0) >>> 0] =
+ termios.c_cc[i] || 0;
+ }
+ return 0;
+ }
+ return 0;
+ }
+ case 21510:
+ case 21511:
+ case 21512: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ case 21506:
+ case 21507:
+ case 21508: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcsets) {
+ var argp = SYSCALLS.getp();
+ var c_iflag = GROWABLE_HEAP_I32()[(argp >>> 2) >>> 0];
+ var c_oflag = GROWABLE_HEAP_I32()[((argp + 4) >>> 2) >>> 0];
+ var c_cflag = GROWABLE_HEAP_I32()[((argp + 8) >>> 2) >>> 0];
+ var c_lflag = GROWABLE_HEAP_I32()[((argp + 12) >>> 2) >>> 0];
+ var c_cc = [];
+ for (var i = 0; i < 32; i++) {
+ c_cc.push(GROWABLE_HEAP_I8()[((argp + i + 17) >>> 0) >>> 0]);
+ }
+ return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
+ c_iflag: c_iflag,
+ c_oflag: c_oflag,
+ c_cflag: c_cflag,
+ c_lflag: c_lflag,
+ c_cc: c_cc,
+ });
+ }
+ return 0;
+ }
+ case 21519: {
+ if (!stream.tty) return -59;
+ var argp = SYSCALLS.getp();
+ GROWABLE_HEAP_I32()[(argp >>> 2) >>> 0] = 0;
+ return 0;
+ }
+ case 21520: {
+ if (!stream.tty) return -59;
+ return -28;
+ }
+ case 21531: {
+ var argp = SYSCALLS.getp();
+ return FS.ioctl(stream, op, argp);
+ }
+ case 21523: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tiocgwinsz) {
+ var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+ var argp = SYSCALLS.getp();
+ GROWABLE_HEAP_I16()[(argp >>> 1) >>> 0] = winsize[0];
+ GROWABLE_HEAP_I16()[((argp + 2) >>> 1) >>> 0] = winsize[1];
+ }
+ return 0;
+ }
+ case 21524: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ case 21515: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ default:
+ return -28;
+ }
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_lstat64(path, buf) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(12, 1, path, buf);
+ path >>>= 0;
+ buf >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ return SYSCALLS.doStat(FS.lstat, path, buf);
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_mkdirat(dirfd, path, mode) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(13, 1, dirfd, path, mode);
+ path >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ path = PATH.normalize(path);
+ if (path[path.length - 1] === "/")
+ path = path.substr(0, path.length - 1);
+ FS.mkdir(path, mode, 0);
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_newfstatat(dirfd, path, buf, flags) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(14, 1, dirfd, path, buf, flags);
+ path >>>= 0;
+ buf >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ var nofollow = flags & 256;
+ var allowEmpty = flags & 4096;
+ flags = flags & ~6400;
+ path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
+ return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf);
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_openat(dirfd, path, flags, varargs) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(15, 1, dirfd, path, flags, varargs);
+ path >>>= 0;
+ varargs >>>= 0;
+ SYSCALLS.varargs = varargs;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ var mode = varargs ? SYSCALLS.get() : 0;
+ return FS.open(path, flags, mode).fd;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function ___syscall_readlinkat(dirfd, path, buf, bufsize) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(16, 1, dirfd, path, buf, bufsize);
+ path >>>= 0;
+ buf >>>= 0;
+ bufsize >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ if (bufsize <= 0) return -28;
+ var ret = FS.readlink(path);
+ var len = Math.min(bufsize, lengthBytesUTF8(ret));
+ var endChar = GROWABLE_HEAP_I8()[(buf + len) >>> 0];
+ stringToUTF8(ret, buf, bufsize + 1);
+ GROWABLE_HEAP_I8()[(buf + len) >>> 0] = endChar;
+ return len;
+ } 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(17, 1, olddirfd, oldpath, newdirfd, newpath);
+ oldpath >>>= 0;
+ newpath >>>= 0;
+ 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_stat64(path, buf) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(18, 1, path, buf);
+ path >>>= 0;
+ buf >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ return SYSCALLS.doStat(FS.stat, path, buf);
+ } 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(19, 1, dirfd, path, flags);
+ path >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ if (flags === 0) {
+ FS.unlink(path);
+ } else if (flags === 512) {
+ FS.rmdir(path);
+ } else {
+ abort("Invalid flags passed to unlinkat");
+ }
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function __embind_register_bigint(
+ primitiveType,
+ name,
+ size,
+ minRange,
+ maxRange,
+ ) {
+ primitiveType >>>= 0;
+ name >>>= 0;
+ size >>>= 0;
+ }
+ var embind_init_charCodes = () => {
+ var codes = new Array(256);
+ for (var i = 0; i < 256; ++i) {
+ codes[i] = String.fromCharCode(i);
+ }
+ embind_charCodes = codes;
+ };
+ var embind_charCodes;
+ var readLatin1String = (ptr) => {
+ var ret = "";
+ var c = ptr;
+ while (GROWABLE_HEAP_U8()[c >>> 0]) {
+ ret += embind_charCodes[GROWABLE_HEAP_U8()[c++ >>> 0]];
+ }
+ return ret;
+ };
+ var awaitingDependencies = {};
+ var registeredTypes = {};
+ var typeDependencies = {};
+ var BindingError;
+ var throwBindingError = (message) => {
+ throw new BindingError(message);
+ };
+ var InternalError;
+ var throwInternalError = (message) => {
+ throw new InternalError(message);
+ };
+ var whenDependentTypesAreResolved = (
+ myTypes,
+ dependentTypes,
+ getTypeConverters,
+ ) => {
+ myTypes.forEach(function (type) {
+ typeDependencies[type] = dependentTypes;
+ });
+ function onComplete(typeConverters) {
+ var myTypeConverters = getTypeConverters(typeConverters);
+ if (myTypeConverters.length !== myTypes.length) {
+ throwInternalError("Mismatched type converter count");
+ }
+ for (var i = 0; i < myTypes.length; ++i) {
+ registerType(myTypes[i], myTypeConverters[i]);
+ }
+ }
+ var typeConverters = new Array(dependentTypes.length);
+ var unregisteredTypes = [];
+ var registered = 0;
+ dependentTypes.forEach((dt, i) => {
+ if (registeredTypes.hasOwnProperty(dt)) {
+ typeConverters[i] = registeredTypes[dt];
+ } else {
+ unregisteredTypes.push(dt);
+ if (!awaitingDependencies.hasOwnProperty(dt)) {
+ awaitingDependencies[dt] = [];
+ }
+ awaitingDependencies[dt].push(() => {
+ typeConverters[i] = registeredTypes[dt];
+ ++registered;
+ if (registered === unregisteredTypes.length) {
+ onComplete(typeConverters);
+ }
+ });
+ }
+ });
+ if (0 === unregisteredTypes.length) {
+ onComplete(typeConverters);
+ }
+ };
+ function sharedRegisterType(rawType, registeredInstance, options = {}) {
+ var name = registeredInstance.name;
+ if (!rawType) {
+ throwBindingError(
+ `type "${name}" must have a positive integer typeid pointer`,
+ );
+ }
+ if (registeredTypes.hasOwnProperty(rawType)) {
+ if (options.ignoreDuplicateRegistrations) {
+ return;
+ } else {
+ throwBindingError(`Cannot register type '${name}' twice`);
+ }
+ }
+ registeredTypes[rawType] = registeredInstance;
+ delete typeDependencies[rawType];
+ if (awaitingDependencies.hasOwnProperty(rawType)) {
+ var callbacks = awaitingDependencies[rawType];
+ delete awaitingDependencies[rawType];
+ callbacks.forEach((cb) => cb());
+ }
+ }
+ function registerType(rawType, registeredInstance, options = {}) {
+ if (!("argPackAdvance" in registeredInstance)) {
+ throw new TypeError(
+ "registerType registeredInstance requires argPackAdvance",
+ );
+ }
+ return sharedRegisterType(rawType, registeredInstance, options);
+ }
+ var GenericWireTypeSize = 8;
+ function __embind_register_bool(rawType, name, trueValue, falseValue) {
+ rawType >>>= 0;
+ name >>>= 0;
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ fromWireType: function (wt) {
+ return !!wt;
+ },
+ toWireType: function (destructors, o) {
+ return o ? trueValue : falseValue;
+ },
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: function (pointer) {
+ return this["fromWireType"](GROWABLE_HEAP_U8()[pointer >>> 0]);
+ },
+ destructorFunction: null,
+ });
+ }
+ var shallowCopyInternalPointer = (o) => ({
+ count: o.count,
+ deleteScheduled: o.deleteScheduled,
+ preservePointerOnDelete: o.preservePointerOnDelete,
+ ptr: o.ptr,
+ ptrType: o.ptrType,
+ smartPtr: o.smartPtr,
+ smartPtrType: o.smartPtrType,
+ });
+ var throwInstanceAlreadyDeleted = (obj) => {
+ function getInstanceTypeName(handle) {
+ return handle.$$.ptrType.registeredClass.name;
+ }
+ throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
+ };
+ var finalizationRegistry = false;
+ var detachFinalizer = (handle) => {};
+ var runDestructor = ($$) => {
+ if ($$.smartPtr) {
+ $$.smartPtrType.rawDestructor($$.smartPtr);
+ } else {
+ $$.ptrType.registeredClass.rawDestructor($$.ptr);
+ }
+ };
+ var releaseClassHandle = ($$) => {
+ $$.count.value -= 1;
+ var toDelete = 0 === $$.count.value;
+ if (toDelete) {
+ runDestructor($$);
+ }
+ };
+ var downcastPointer = (ptr, ptrClass, desiredClass) => {
+ if (ptrClass === desiredClass) {
+ return ptr;
+ }
+ if (undefined === desiredClass.baseClass) {
+ return null;
+ }
+ var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+ if (rv === null) {
+ return null;
+ }
+ return desiredClass.downcast(rv);
+ };
+ var registeredPointers = {};
+ var getInheritedInstanceCount = () =>
+ Object.keys(registeredInstances).length;
+ var getLiveInheritedInstances = () => {
+ var rv = [];
+ for (var k in registeredInstances) {
+ if (registeredInstances.hasOwnProperty(k)) {
+ rv.push(registeredInstances[k]);
+ }
+ }
+ return rv;
+ };
+ var deletionQueue = [];
+ var flushPendingDeletes = () => {
+ while (deletionQueue.length) {
+ var obj = deletionQueue.pop();
+ obj.$$.deleteScheduled = false;
+ obj["delete"]();
+ }
+ };
+ var delayFunction;
+ var setDelayFunction = (fn) => {
+ delayFunction = fn;
+ if (deletionQueue.length && delayFunction) {
+ delayFunction(flushPendingDeletes);
+ }
+ };
+ var init_embind = () => {
+ Module["getInheritedInstanceCount"] = getInheritedInstanceCount;
+ Module["getLiveInheritedInstances"] = getLiveInheritedInstances;
+ Module["flushPendingDeletes"] = flushPendingDeletes;
+ Module["setDelayFunction"] = setDelayFunction;
+ };
+ var registeredInstances = {};
+ var getBasestPointer = (class_, ptr) => {
+ if (ptr === undefined) {
+ throwBindingError("ptr should not be undefined");
+ }
+ while (class_.baseClass) {
+ ptr = class_.upcast(ptr);
+ class_ = class_.baseClass;
+ }
+ return ptr;
+ };
+ var getInheritedInstance = (class_, ptr) => {
+ ptr = getBasestPointer(class_, ptr);
+ return registeredInstances[ptr];
+ };
+ var makeClassHandle = (prototype, record) => {
+ if (!record.ptrType || !record.ptr) {
+ throwInternalError("makeClassHandle requires ptr and ptrType");
+ }
+ var hasSmartPtrType = !!record.smartPtrType;
+ var hasSmartPtr = !!record.smartPtr;
+ if (hasSmartPtrType !== hasSmartPtr) {
+ throwInternalError("Both smartPtrType and smartPtr must be specified");
+ }
+ record.count = { value: 1 };
+ return attachFinalizer(
+ Object.create(prototype, { $$: { value: record } }),
+ );
+ };
+ function RegisteredPointer_fromWireType(ptr) {
+ var rawPointer = this.getPointee(ptr);
+ if (!rawPointer) {
+ this.destructor(ptr);
+ return null;
+ }
+ var registeredInstance = getInheritedInstance(
+ this.registeredClass,
+ rawPointer,
+ );
+ if (undefined !== registeredInstance) {
+ if (0 === registeredInstance.$$.count.value) {
+ registeredInstance.$$.ptr = rawPointer;
+ registeredInstance.$$.smartPtr = ptr;
+ return registeredInstance["clone"]();
+ } else {
+ var rv = registeredInstance["clone"]();
+ this.destructor(ptr);
+ return rv;
+ }
+ }
+ function makeDefaultHandle() {
+ if (this.isSmartPointer) {
+ return makeClassHandle(this.registeredClass.instancePrototype, {
+ ptrType: this.pointeeType,
+ ptr: rawPointer,
+ smartPtrType: this,
+ smartPtr: ptr,
+ });
+ } else {
+ return makeClassHandle(this.registeredClass.instancePrototype, {
+ ptrType: this,
+ ptr: ptr,
+ });
+ }
+ }
+ var actualType = this.registeredClass.getActualType(rawPointer);
+ var registeredPointerRecord = registeredPointers[actualType];
+ if (!registeredPointerRecord) {
+ return makeDefaultHandle.call(this);
+ }
+ var toType;
+ if (this.isConst) {
+ toType = registeredPointerRecord.constPointerType;
+ } else {
+ toType = registeredPointerRecord.pointerType;
+ }
+ var dp = downcastPointer(
+ rawPointer,
+ this.registeredClass,
+ toType.registeredClass,
+ );
+ if (dp === null) {
+ return makeDefaultHandle.call(this);
+ }
+ if (this.isSmartPointer) {
+ return makeClassHandle(toType.registeredClass.instancePrototype, {
+ ptrType: toType,
+ ptr: dp,
+ smartPtrType: this,
+ smartPtr: ptr,
+ });
+ } else {
+ return makeClassHandle(toType.registeredClass.instancePrototype, {
+ ptrType: toType,
+ ptr: dp,
+ });
+ }
+ }
+ var attachFinalizer = (handle) => {
+ if ("undefined" === typeof FinalizationRegistry) {
+ attachFinalizer = (handle) => handle;
+ return handle;
+ }
+ finalizationRegistry = new FinalizationRegistry((info) => {
+ releaseClassHandle(info.$$);
+ });
+ attachFinalizer = (handle) => {
+ var $$ = handle.$$;
+ var hasSmartPtr = !!$$.smartPtr;
+ if (hasSmartPtr) {
+ var info = { $$: $$ };
+ finalizationRegistry.register(handle, info, handle);
+ }
+ return handle;
+ };
+ detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
+ return attachFinalizer(handle);
+ };
+ var init_ClassHandle = () => {
+ Object.assign(ClassHandle.prototype, {
+ isAliasOf(other) {
+ if (!(this instanceof ClassHandle)) {
+ return false;
+ }
+ if (!(other instanceof ClassHandle)) {
+ return false;
+ }
+ var leftClass = this.$$.ptrType.registeredClass;
+ var left = this.$$.ptr;
+ other.$$ = other.$$;
+ var rightClass = other.$$.ptrType.registeredClass;
+ var right = other.$$.ptr;
+ while (leftClass.baseClass) {
+ left = leftClass.upcast(left);
+ leftClass = leftClass.baseClass;
+ }
+ while (rightClass.baseClass) {
+ right = rightClass.upcast(right);
+ rightClass = rightClass.baseClass;
+ }
+ return leftClass === rightClass && left === right;
+ },
+ clone() {
+ if (!this.$$.ptr) {
+ throwInstanceAlreadyDeleted(this);
+ }
+ if (this.$$.preservePointerOnDelete) {
+ this.$$.count.value += 1;
+ return this;
+ } else {
+ var clone = attachFinalizer(
+ Object.create(Object.getPrototypeOf(this), {
+ $$: { value: shallowCopyInternalPointer(this.$$) },
+ }),
+ );
+ clone.$$.count.value += 1;
+ clone.$$.deleteScheduled = false;
+ return clone;
+ }
+ },
+ delete() {
+ if (!this.$$.ptr) {
+ throwInstanceAlreadyDeleted(this);
+ }
+ if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+ throwBindingError("Object already scheduled for deletion");
+ }
+ detachFinalizer(this);
+ releaseClassHandle(this.$$);
+ if (!this.$$.preservePointerOnDelete) {
+ this.$$.smartPtr = undefined;
+ this.$$.ptr = undefined;
+ }
+ },
+ isDeleted() {
+ return !this.$$.ptr;
+ },
+ deleteLater() {
+ if (!this.$$.ptr) {
+ throwInstanceAlreadyDeleted(this);
+ }
+ if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+ throwBindingError("Object already scheduled for deletion");
+ }
+ deletionQueue.push(this);
+ if (deletionQueue.length === 1 && delayFunction) {
+ delayFunction(flushPendingDeletes);
+ }
+ this.$$.deleteScheduled = true;
+ return this;
+ },
+ });
+ };
+ function ClassHandle() {}
+ var char_0 = 48;
+ var char_9 = 57;
+ var makeLegalFunctionName = (name) => {
+ if (undefined === name) {
+ return "_unknown";
+ }
+ name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+ var f = name.charCodeAt(0);
+ if (f >= char_0 && f <= char_9) {
+ return `_${name}`;
+ }
+ return name;
+ };
+ function createNamedFunction(name, body) {
+ name = makeLegalFunctionName(name);
+ return {
+ [name]: function () {
+ return body.apply(this, arguments);
+ },
+ }[name];
+ }
+ var ensureOverloadTable = (proto, methodName, humanName) => {
+ if (undefined === proto[methodName].overloadTable) {
+ var prevFunc = proto[methodName];
+ proto[methodName] = function () {
+ if (
+ !proto[methodName].overloadTable.hasOwnProperty(arguments.length)
+ ) {
+ throwBindingError(
+ `Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`,
+ );
+ }
+ return proto[methodName].overloadTable[arguments.length].apply(
+ this,
+ arguments,
+ );
+ };
+ proto[methodName].overloadTable = [];
+ proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+ }
+ };
+ var exposePublicSymbol = (name, value, numArguments) => {
+ if (Module.hasOwnProperty(name)) {
+ if (
+ undefined === numArguments ||
+ (undefined !== Module[name].overloadTable &&
+ undefined !== Module[name].overloadTable[numArguments])
+ ) {
+ throwBindingError(`Cannot register public name '${name}' twice`);
+ }
+ ensureOverloadTable(Module, name, name);
+ if (Module.hasOwnProperty(numArguments)) {
+ throwBindingError(
+ `Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`,
+ );
+ }
+ Module[name].overloadTable[numArguments] = value;
+ } else {
+ Module[name] = value;
+ if (undefined !== numArguments) {
+ Module[name].numArguments = numArguments;
+ }
+ }
+ };
+ function RegisteredClass(
+ name,
+ constructor,
+ instancePrototype,
+ rawDestructor,
+ baseClass,
+ getActualType,
+ upcast,
+ downcast,
+ ) {
+ this.name = name;
+ this.constructor = constructor;
+ this.instancePrototype = instancePrototype;
+ this.rawDestructor = rawDestructor;
+ this.baseClass = baseClass;
+ this.getActualType = getActualType;
+ this.upcast = upcast;
+ this.downcast = downcast;
+ this.pureVirtualFunctions = [];
+ }
+ var upcastPointer = (ptr, ptrClass, desiredClass) => {
+ while (ptrClass !== desiredClass) {
+ if (!ptrClass.upcast) {
+ throwBindingError(
+ `Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`,
+ );
+ }
+ ptr = ptrClass.upcast(ptr);
+ ptrClass = ptrClass.baseClass;
+ }
+ return ptr;
+ };
+ function constNoSmartPtrRawPointerToWireType(destructors, handle) {
+ if (handle === null) {
+ if (this.isReference) {
+ throwBindingError(`null is not a valid ${this.name}`);
+ }
+ return 0;
+ }
+ if (!handle.$$) {
+ throwBindingError(
+ `Cannot pass "${embindRepr(handle)}" as a ${this.name}`,
+ );
+ }
+ if (!handle.$$.ptr) {
+ throwBindingError(
+ `Cannot pass deleted object as a pointer of type ${this.name}`,
+ );
+ }
+ var handleClass = handle.$$.ptrType.registeredClass;
+ var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+ return ptr;
+ }
+ function genericPointerToWireType(destructors, handle) {
+ var ptr;
+ if (handle === null) {
+ if (this.isReference) {
+ throwBindingError(`null is not a valid ${this.name}`);
+ }
+ if (this.isSmartPointer) {
+ ptr = this.rawConstructor();
+ if (destructors !== null) {
+ destructors.push(this.rawDestructor, ptr);
+ }
+ return ptr;
+ } else {
+ return 0;
+ }
+ }
+ if (!handle.$$) {
+ throwBindingError(
+ `Cannot pass "${embindRepr(handle)}" as a ${this.name}`,
+ );
+ }
+ if (!handle.$$.ptr) {
+ throwBindingError(
+ `Cannot pass deleted object as a pointer of type ${this.name}`,
+ );
+ }
+ if (!this.isConst && handle.$$.ptrType.isConst) {
+ throwBindingError(
+ `Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`,
+ );
+ }
+ var handleClass = handle.$$.ptrType.registeredClass;
+ ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+ if (this.isSmartPointer) {
+ if (undefined === handle.$$.smartPtr) {
+ throwBindingError("Passing raw pointer to smart pointer is illegal");
+ }
+ switch (this.sharingPolicy) {
+ case 0:
+ if (handle.$$.smartPtrType === this) {
+ ptr = handle.$$.smartPtr;
+ } else {
+ throwBindingError(
+ `Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`,
+ );
+ }
+ break;
+ case 1:
+ ptr = handle.$$.smartPtr;
+ break;
+ case 2:
+ if (handle.$$.smartPtrType === this) {
+ ptr = handle.$$.smartPtr;
+ } else {
+ var clonedHandle = handle["clone"]();
+ ptr = this.rawShare(
+ ptr,
+ Emval.toHandle(() => clonedHandle["delete"]()),
+ );
+ if (destructors !== null) {
+ destructors.push(this.rawDestructor, ptr);
+ }
+ }
+ break;
+ default:
+ throwBindingError("Unsupporting sharing policy");
+ }
+ }
+ return ptr;
+ }
+ function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
+ if (handle === null) {
+ if (this.isReference) {
+ throwBindingError(`null is not a valid ${this.name}`);
+ }
+ return 0;
+ }
+ if (!handle.$$) {
+ throwBindingError(
+ `Cannot pass "${embindRepr(handle)}" as a ${this.name}`,
+ );
+ }
+ if (!handle.$$.ptr) {
+ throwBindingError(
+ `Cannot pass deleted object as a pointer of type ${this.name}`,
+ );
+ }
+ if (handle.$$.ptrType.isConst) {
+ throwBindingError(
+ `Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`,
+ );
+ }
+ var handleClass = handle.$$.ptrType.registeredClass;
+ var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+ return ptr;
+ }
+ function readPointer(pointer) {
+ return this["fromWireType"](GROWABLE_HEAP_U32()[(pointer >>> 2) >>> 0]);
+ }
+ var init_RegisteredPointer = () => {
+ Object.assign(RegisteredPointer.prototype, {
+ getPointee(ptr) {
+ if (this.rawGetPointee) {
+ ptr = this.rawGetPointee(ptr);
+ }
+ return ptr;
+ },
+ destructor(ptr) {
+ if (this.rawDestructor) {
+ this.rawDestructor(ptr);
+ }
+ },
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: readPointer,
+ deleteObject(handle) {
+ if (handle !== null) {
+ handle["delete"]();
+ }
+ },
+ fromWireType: RegisteredPointer_fromWireType,
+ });
+ };
+ function RegisteredPointer(
+ name,
+ registeredClass,
+ isReference,
+ isConst,
+ isSmartPointer,
+ pointeeType,
+ sharingPolicy,
+ rawGetPointee,
+ rawConstructor,
+ rawShare,
+ rawDestructor,
+ ) {
+ this.name = name;
+ this.registeredClass = registeredClass;
+ this.isReference = isReference;
+ this.isConst = isConst;
+ this.isSmartPointer = isSmartPointer;
+ this.pointeeType = pointeeType;
+ this.sharingPolicy = sharingPolicy;
+ this.rawGetPointee = rawGetPointee;
+ this.rawConstructor = rawConstructor;
+ this.rawShare = rawShare;
+ this.rawDestructor = rawDestructor;
+ if (!isSmartPointer && registeredClass.baseClass === undefined) {
+ if (isConst) {
+ this["toWireType"] = constNoSmartPtrRawPointerToWireType;
+ this.destructorFunction = null;
+ } else {
+ this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType;
+ this.destructorFunction = null;
+ }
+ } else {
+ this["toWireType"] = genericPointerToWireType;
+ }
+ }
+ var replacePublicSymbol = (name, value, numArguments) => {
+ if (!Module.hasOwnProperty(name)) {
+ throwInternalError("Replacing nonexistant public symbol");
+ }
+ if (
+ undefined !== Module[name].overloadTable &&
+ undefined !== numArguments
+ ) {
+ Module[name].overloadTable[numArguments] = value;
+ } else {
+ Module[name] = value;
+ Module[name].argCount = numArguments;
+ }
+ };
+ var dynCallLegacy = (sig, ptr, args) => {
+ var f = Module["dynCall_" + sig];
+ return args && args.length
+ ? f.apply(null, [ptr].concat(args))
+ : f.call(null, ptr);
+ };
+ var wasmTable;
+ var dynCall = (sig, ptr, args) => {
+ var rtn = dynCallLegacy(sig, ptr, args);
+ return rtn;
+ };
+ var getDynCaller = (sig, ptr) => {
+ var argCache = [];
+ return function () {
+ argCache.length = 0;
+ Object.assign(argCache, arguments);
+ return dynCall(sig, ptr, argCache);
+ };
+ };
+ var embind__requireFunction = (signature, rawFunction) => {
+ signature = readLatin1String(signature);
+ function makeDynCaller() {
+ return getDynCaller(signature, rawFunction);
+ }
+ var fp = makeDynCaller();
+ if (typeof fp != "function") {
+ throwBindingError(
+ `unknown function pointer with signature ${signature}: ${rawFunction}`,
+ );
+ }
+ return fp;
+ };
+ var extendError = (baseErrorType, errorName) => {
+ var errorClass = createNamedFunction(errorName, function (message) {
+ this.name = errorName;
+ this.message = message;
+ var stack = new Error(message).stack;
+ if (stack !== undefined) {
+ this.stack =
+ this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
+ }
+ });
+ errorClass.prototype = Object.create(baseErrorType.prototype);
+ errorClass.prototype.constructor = errorClass;
+ errorClass.prototype.toString = function () {
+ if (this.message === undefined) {
+ return this.name;
+ } else {
+ return `${this.name}: ${this.message}`;
+ }
+ };
+ return errorClass;
+ };
+ var UnboundTypeError;
+ var getTypeName = (type) => {
+ var ptr = ___getTypeName(type);
+ var rv = readLatin1String(ptr);
+ _free(ptr);
+ return rv;
+ };
+ var throwUnboundTypeError = (message, types) => {
+ var unboundTypes = [];
+ var seen = {};
+ function visit(type) {
+ if (seen[type]) {
+ return;
+ }
+ if (registeredTypes[type]) {
+ return;
+ }
+ if (typeDependencies[type]) {
+ typeDependencies[type].forEach(visit);
+ return;
+ }
+ unboundTypes.push(type);
+ seen[type] = true;
+ }
+ types.forEach(visit);
+ throw new UnboundTypeError(
+ `${message}: ` + unboundTypes.map(getTypeName).join([", "]),
+ );
+ };
+ function __embind_register_class(
+ rawType,
+ rawPointerType,
+ rawConstPointerType,
+ baseClassRawType,
+ getActualTypeSignature,
+ getActualType,
+ upcastSignature,
+ upcast,
+ downcastSignature,
+ downcast,
+ name,
+ destructorSignature,
+ rawDestructor,
+ ) {
+ rawType >>>= 0;
+ rawPointerType >>>= 0;
+ rawConstPointerType >>>= 0;
+ baseClassRawType >>>= 0;
+ getActualTypeSignature >>>= 0;
+ getActualType >>>= 0;
+ upcastSignature >>>= 0;
+ upcast >>>= 0;
+ downcastSignature >>>= 0;
+ downcast >>>= 0;
+ name >>>= 0;
+ destructorSignature >>>= 0;
+ rawDestructor >>>= 0;
+ name = readLatin1String(name);
+ getActualType = embind__requireFunction(
+ getActualTypeSignature,
+ getActualType,
+ );
+ if (upcast) {
+ upcast = embind__requireFunction(upcastSignature, upcast);
+ }
+ if (downcast) {
+ downcast = embind__requireFunction(downcastSignature, downcast);
+ }
+ rawDestructor = embind__requireFunction(
+ destructorSignature,
+ rawDestructor,
+ );
+ var legalFunctionName = makeLegalFunctionName(name);
+ exposePublicSymbol(legalFunctionName, function () {
+ throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [
+ baseClassRawType,
+ ]);
+ });
+ whenDependentTypesAreResolved(
+ [rawType, rawPointerType, rawConstPointerType],
+ baseClassRawType ? [baseClassRawType] : [],
+ function (base) {
+ base = base[0];
+ var baseClass;
+ var basePrototype;
+ if (baseClassRawType) {
+ baseClass = base.registeredClass;
+ basePrototype = baseClass.instancePrototype;
+ } else {
+ basePrototype = ClassHandle.prototype;
+ }
+ var constructor = createNamedFunction(legalFunctionName, function () {
+ if (Object.getPrototypeOf(this) !== instancePrototype) {
+ throw new BindingError("Use 'new' to construct " + name);
+ }
+ if (undefined === registeredClass.constructor_body) {
+ throw new BindingError(name + " has no accessible constructor");
+ }
+ var body = registeredClass.constructor_body[arguments.length];
+ if (undefined === body) {
+ throw new BindingError(
+ `Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`,
+ );
+ }
+ return body.apply(this, arguments);
+ });
+ var instancePrototype = Object.create(basePrototype, {
+ constructor: { value: constructor },
+ });
+ constructor.prototype = instancePrototype;
+ var registeredClass = new RegisteredClass(
+ name,
+ constructor,
+ instancePrototype,
+ rawDestructor,
+ baseClass,
+ getActualType,
+ upcast,
+ downcast,
+ );
+ if (registeredClass.baseClass) {
+ if (registeredClass.baseClass.__derivedClasses === undefined) {
+ registeredClass.baseClass.__derivedClasses = [];
+ }
+ registeredClass.baseClass.__derivedClasses.push(registeredClass);
+ }
+ var referenceConverter = new RegisteredPointer(
+ name,
+ registeredClass,
+ true,
+ false,
+ false,
+ );
+ var pointerConverter = new RegisteredPointer(
+ name + "*",
+ registeredClass,
+ false,
+ false,
+ false,
+ );
+ var constPointerConverter = new RegisteredPointer(
+ name + " const*",
+ registeredClass,
+ false,
+ true,
+ false,
+ );
+ registeredPointers[rawType] = {
+ pointerType: pointerConverter,
+ constPointerType: constPointerConverter,
+ };
+ replacePublicSymbol(legalFunctionName, constructor);
+ return [referenceConverter, pointerConverter, constPointerConverter];
+ },
+ );
+ }
+ var runDestructors = (destructors) => {
+ while (destructors.length) {
+ var ptr = destructors.pop();
+ var del = destructors.pop();
+ del(ptr);
+ }
+ };
+ function newFunc(constructor, argumentList) {
+ if (!(constructor instanceof Function)) {
+ throw new TypeError(
+ `new_ called with constructor type ${typeof constructor} which is not a function`,
+ );
+ }
+ var dummy = createNamedFunction(
+ constructor.name || "unknownFunctionName",
+ function () {},
+ );
+ dummy.prototype = constructor.prototype;
+ var obj = new dummy();
+ var r = constructor.apply(obj, argumentList);
+ return r instanceof Object ? r : obj;
+ }
+ var runAndAbortIfError = (func) => {
+ try {
+ return func();
+ } catch (e) {
+ abort(e);
+ }
+ };
+ var maybeExit = () => {
+ if (!keepRuntimeAlive()) {
+ try {
+ if (ENVIRONMENT_IS_PTHREAD) __emscripten_thread_exit(EXITSTATUS);
+ else _exit(EXITSTATUS);
+ } catch (e) {
+ handleException(e);
+ }
+ }
+ };
+ var callUserCallback = (func) => {
+ if (ABORT) {
+ return;
+ }
+ try {
+ func();
+ maybeExit();
+ } catch (e) {
+ handleException(e);
+ }
+ };
+ var runtimeKeepalivePush = () => {
+ runtimeKeepaliveCounter += 1;
+ };
+ var runtimeKeepalivePop = () => {
+ runtimeKeepaliveCounter -= 1;
+ };
+ var Asyncify = {
+ instrumentWasmImports(imports) {
+ var importPattern = /^(invoke_.*|__asyncjs__.*)$/;
+ for (var x in imports) {
+ (function (x) {
+ var original = imports[x];
+ var sig = original.sig;
+ if (typeof original == "function") {
+ var isAsyncifyImport = original.isAsync || importPattern.test(x);
+ }
+ })(x);
+ }
+ },
+ instrumentWasmExports(exports) {
+ var ret = {};
+ for (var x in exports) {
+ (function (x) {
+ var original = exports[x];
+ if (typeof original == "function") {
+ ret[x] = function () {
+ Asyncify.exportCallStack.push(x);
+ try {
+ return original.apply(null, arguments);
+ } finally {
+ if (!ABORT) {
+ var y = Asyncify.exportCallStack.pop();
+ assert(y === x);
+ Asyncify.maybeStopUnwind();
+ }
+ }
+ };
+ } else {
+ ret[x] = original;
+ }
+ })(x);
+ }
+ return ret;
+ },
+ State: { Normal: 0, Unwinding: 1, Rewinding: 2, Disabled: 3 },
+ state: 0,
+ StackSize: 4096,
+ currData: null,
+ handleSleepReturnValue: 0,
+ exportCallStack: [],
+ callStackNameToId: {},
+ callStackIdToName: {},
+ callStackId: 0,
+ asyncPromiseHandlers: null,
+ sleepCallbacks: [],
+ getCallStackId(funcName) {
+ var id = Asyncify.callStackNameToId[funcName];
+ if (id === undefined) {
+ id = Asyncify.callStackId++;
+ Asyncify.callStackNameToId[funcName] = id;
+ Asyncify.callStackIdToName[id] = funcName;
+ }
+ return id;
+ },
+ maybeStopUnwind() {
+ if (
+ Asyncify.currData &&
+ Asyncify.state === Asyncify.State.Unwinding &&
+ Asyncify.exportCallStack.length === 0
+ ) {
+ Asyncify.state = Asyncify.State.Normal;
+ runtimeKeepalivePush();
+ runAndAbortIfError(_asyncify_stop_unwind);
+ if (typeof Fibers != "undefined") {
+ Fibers.trampoline();
+ }
+ }
+ },
+ whenDone() {
+ return new Promise((resolve, reject) => {
+ Asyncify.asyncPromiseHandlers = { resolve: resolve, reject: reject };
+ });
+ },
+ allocateData() {
+ var ptr = _malloc(12 + Asyncify.StackSize);
+ Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize);
+ Asyncify.setDataRewindFunc(ptr);
+ return ptr;
+ },
+ setDataHeader(ptr, stack, stackSize) {
+ GROWABLE_HEAP_U32()[(ptr >>> 2) >>> 0] = stack;
+ GROWABLE_HEAP_U32()[((ptr + 4) >>> 2) >>> 0] = stack + stackSize;
+ },
+ setDataRewindFunc(ptr) {
+ var bottomOfCallStack = Asyncify.exportCallStack[0];
+ var rewindId = Asyncify.getCallStackId(bottomOfCallStack);
+ GROWABLE_HEAP_I32()[((ptr + 8) >>> 2) >>> 0] = rewindId;
+ },
+ getDataRewindFunc(ptr) {
+ var id = GROWABLE_HEAP_I32()[((ptr + 8) >>> 2) >>> 0];
+ var name = Asyncify.callStackIdToName[id];
+ var func = wasmExports[name];
+ return func;
+ },
+ doRewind(ptr) {
+ var start = Asyncify.getDataRewindFunc(ptr);
+ runtimeKeepalivePop();
+ return start();
+ },
+ handleSleep(startAsync) {
+ if (ABORT) return;
+ if (Asyncify.state === Asyncify.State.Normal) {
+ var reachedCallback = false;
+ var reachedAfterCallback = false;
+ startAsync((handleSleepReturnValue = 0) => {
+ if (ABORT) return;
+ Asyncify.handleSleepReturnValue = handleSleepReturnValue;
+ reachedCallback = true;
+ if (!reachedAfterCallback) {
+ return;
+ }
+ Asyncify.state = Asyncify.State.Rewinding;
+ runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData));
+ if (typeof Browser != "undefined" && Browser.mainLoop.func) {
+ Browser.mainLoop.resume();
+ }
+ var asyncWasmReturnValue,
+ isError = false;
+ try {
+ asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData);
+ } catch (err) {
+ asyncWasmReturnValue = err;
+ isError = true;
+ }
+ var handled = false;
+ if (!Asyncify.currData) {
+ var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers;
+ if (asyncPromiseHandlers) {
+ Asyncify.asyncPromiseHandlers = null;
+ (isError
+ ? asyncPromiseHandlers.reject
+ : asyncPromiseHandlers.resolve)(asyncWasmReturnValue);
+ handled = true;
+ }
+ }
+ if (isError && !handled) {
+ throw asyncWasmReturnValue;
+ }
+ });
+ reachedAfterCallback = true;
+ if (!reachedCallback) {
+ Asyncify.state = Asyncify.State.Unwinding;
+ Asyncify.currData = Asyncify.allocateData();
+ if (typeof Browser != "undefined" && Browser.mainLoop.func) {
+ Browser.mainLoop.pause();
+ }
+ runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData));
+ }
+ } else if (Asyncify.state === Asyncify.State.Rewinding) {
+ Asyncify.state = Asyncify.State.Normal;
+ runAndAbortIfError(_asyncify_stop_rewind);
+ _free(Asyncify.currData);
+ Asyncify.currData = null;
+ Asyncify.sleepCallbacks.forEach((func) => callUserCallback(func));
+ } else {
+ abort(`invalid state: ${Asyncify.state}`);
+ }
+ return Asyncify.handleSleepReturnValue;
+ },
+ handleAsync(startAsync) {
+ return Asyncify.handleSleep((wakeUp) => {
+ startAsync().then(wakeUp);
+ });
+ },
+ };
+ function craftInvokerFunction(
+ humanName,
+ argTypes,
+ classType,
+ cppInvokerFunc,
+ cppTargetFunc,
+ isAsync,
+ ) {
+ var argCount = argTypes.length;
+ if (argCount < 2) {
+ throwBindingError(
+ "argTypes array size mismatch! Must at least get return value and 'this' types!",
+ );
+ }
+ var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+ var needsDestructorStack = false;
+ for (var i = 1; i < argTypes.length; ++i) {
+ if (
+ argTypes[i] !== null &&
+ argTypes[i].destructorFunction === undefined
+ ) {
+ needsDestructorStack = true;
+ break;
+ }
+ }
+ var returns = argTypes[0].name !== "void";
+ var argsList = "";
+ var argsListWired = "";
+ for (var i = 0; i < argCount - 2; ++i) {
+ argsList += (i !== 0 ? ", " : "") + "arg" + i;
+ argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
+ }
+ var invokerFnBody = `\n return function ${makeLegalFunctionName(humanName)}(${argsList}) {\n if (arguments.length !== ${argCount - 2}) {\n throwBindingError('function ${humanName} called with ' + arguments.length + ' arguments, expected ${argCount - 2}');\n }`;
+ if (needsDestructorStack) {
+ invokerFnBody += "var destructors = [];\n";
+ }
+ var dtorStack = needsDestructorStack ? "destructors" : "null";
+ var args1 = [
+ "throwBindingError",
+ "invoker",
+ "fn",
+ "runDestructors",
+ "retType",
+ "classParam",
+ ];
+ var args2 = [
+ throwBindingError,
+ cppInvokerFunc,
+ cppTargetFunc,
+ runDestructors,
+ argTypes[0],
+ argTypes[1],
+ ];
+ if (isClassMethodFunc) {
+ invokerFnBody +=
+ "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
+ }
+ for (var i = 0; i < argCount - 2; ++i) {
+ invokerFnBody +=
+ "var arg" +
+ i +
+ "Wired = argType" +
+ i +
+ ".toWireType(" +
+ dtorStack +
+ ", arg" +
+ i +
+ "); // " +
+ argTypes[i + 2].name +
+ "\n";
+ args1.push("argType" + i);
+ args2.push(argTypes[i + 2]);
+ }
+ if (isClassMethodFunc) {
+ argsListWired =
+ "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
+ }
+ invokerFnBody +=
+ (returns || isAsync ? "var rv = " : "") +
+ "invoker(fn" +
+ (argsListWired.length > 0 ? ", " : "") +
+ argsListWired +
+ ");\n";
+ args1.push("Asyncify");
+ args2.push(Asyncify);
+ invokerFnBody += "function onDone(" + (returns ? "rv" : "") + ") {\n";
+ if (needsDestructorStack) {
+ invokerFnBody += "runDestructors(destructors);\n";
+ } else {
+ for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+ var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+ if (argTypes[i].destructorFunction !== null) {
+ invokerFnBody +=
+ paramName +
+ "_dtor(" +
+ paramName +
+ "); // " +
+ argTypes[i].name +
+ "\n";
+ args1.push(paramName + "_dtor");
+ args2.push(argTypes[i].destructorFunction);
+ }
+ }
+ }
+ if (returns) {
+ invokerFnBody +=
+ "var ret = retType.fromWireType(rv);\n" + "return ret;\n";
+ } else {
+ }
+ invokerFnBody += "}\n";
+ invokerFnBody +=
+ "return Asyncify.currData ? Asyncify.whenDone().then(onDone) : onDone(" +
+ (returns ? "rv" : "") +
+ ");\n";
+ invokerFnBody += "}\n";
+ args1.push(invokerFnBody);
+ return newFunc(Function, args1).apply(null, args2);
+ }
+ var heap32VectorToArray = (count, firstElement) => {
+ var array = [];
+ for (var i = 0; i < count; i++) {
+ array.push(GROWABLE_HEAP_U32()[((firstElement + i * 4) >>> 2) >>> 0]);
+ }
+ return array;
+ };
+ var getFunctionName = (signature) => {
+ signature = signature.trim();
+ const argsIndex = signature.indexOf("(");
+ if (argsIndex !== -1) {
+ assert(
+ signature[signature.length - 1] == ")",
+ "Parentheses for argument names should match.",
+ );
+ return signature.substr(0, argsIndex);
+ } else {
+ return signature;
+ }
+ };
+ function __embind_register_class_class_function(
+ rawClassType,
+ methodName,
+ argCount,
+ rawArgTypesAddr,
+ invokerSignature,
+ rawInvoker,
+ fn,
+ isAsync,
+ ) {
+ rawClassType >>>= 0;
+ methodName >>>= 0;
+ rawArgTypesAddr >>>= 0;
+ invokerSignature >>>= 0;
+ rawInvoker >>>= 0;
+ fn >>>= 0;
+ var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ methodName = readLatin1String(methodName);
+ methodName = getFunctionName(methodName);
+ rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+ whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+ classType = classType[0];
+ var humanName = `${classType.name}.${methodName}`;
+ function unboundTypesHandler() {
+ throwUnboundTypeError(
+ `Cannot call ${humanName} due to unbound types`,
+ rawArgTypes,
+ );
+ }
+ if (methodName.startsWith("@@")) {
+ methodName = Symbol[methodName.substring(2)];
+ }
+ var proto = classType.registeredClass.constructor;
+ if (undefined === proto[methodName]) {
+ unboundTypesHandler.argCount = argCount - 1;
+ proto[methodName] = unboundTypesHandler;
+ } else {
+ ensureOverloadTable(proto, methodName, humanName);
+ proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler;
+ }
+ whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+ var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
+ var func = craftInvokerFunction(
+ humanName,
+ invokerArgsArray,
+ null,
+ rawInvoker,
+ fn,
+ isAsync,
+ );
+ if (undefined === proto[methodName].overloadTable) {
+ func.argCount = argCount - 1;
+ proto[methodName] = func;
+ } else {
+ proto[methodName].overloadTable[argCount - 1] = func;
+ }
+ if (classType.registeredClass.__derivedClasses) {
+ for (const derivedClass of classType.registeredClass
+ .__derivedClasses) {
+ if (!derivedClass.constructor.hasOwnProperty(methodName)) {
+ derivedClass.constructor[methodName] = func;
+ }
+ }
+ }
+ return [];
+ });
+ return [];
+ });
+ }
+ var validateThis = (this_, classType, humanName) => {
+ if (!(this_ instanceof Object)) {
+ throwBindingError(`${humanName} with invalid "this": ${this_}`);
+ }
+ if (!(this_ instanceof classType.registeredClass.constructor)) {
+ throwBindingError(
+ `${humanName} incompatible with "this" of type ${this_.constructor.name}`,
+ );
+ }
+ if (!this_.$$.ptr) {
+ throwBindingError(
+ `cannot call emscripten binding method ${humanName} on deleted object`,
+ );
+ }
+ return upcastPointer(
+ this_.$$.ptr,
+ this_.$$.ptrType.registeredClass,
+ classType.registeredClass,
+ );
+ };
+ function __embind_register_class_class_property(
+ rawClassType,
+ fieldName,
+ rawFieldType,
+ rawFieldPtr,
+ getterSignature,
+ getter,
+ setterSignature,
+ setter,
+ ) {
+ rawClassType >>>= 0;
+ fieldName >>>= 0;
+ rawFieldType >>>= 0;
+ rawFieldPtr >>>= 0;
+ getterSignature >>>= 0;
+ getter >>>= 0;
+ setterSignature >>>= 0;
+ setter >>>= 0;
+ fieldName = readLatin1String(fieldName);
+ getter = embind__requireFunction(getterSignature, getter);
+ whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+ classType = classType[0];
+ var humanName = `${classType.name}.${fieldName}`;
+ var desc = {
+ get() {
+ throwUnboundTypeError(
+ `Cannot access ${humanName} due to unbound types`,
+ [rawFieldType],
+ );
+ },
+ enumerable: true,
+ configurable: true,
+ };
+ if (setter) {
+ desc.set = () => {
+ throwUnboundTypeError(
+ `Cannot access ${humanName} due to unbound types`,
+ [rawFieldType],
+ );
+ };
+ } else {
+ desc.set = (v) => {
+ throwBindingError(`${humanName} is a read-only property`);
+ };
+ }
+ Object.defineProperty(
+ classType.registeredClass.constructor,
+ fieldName,
+ desc,
+ );
+ whenDependentTypesAreResolved([], [rawFieldType], function (fieldType) {
+ fieldType = fieldType[0];
+ var desc = {
+ get() {
+ return fieldType["fromWireType"](getter(rawFieldPtr));
+ },
+ enumerable: true,
+ };
+ if (setter) {
+ setter = embind__requireFunction(setterSignature, setter);
+ desc.set = (v) => {
+ var destructors = [];
+ setter(rawFieldPtr, fieldType["toWireType"](destructors, v));
+ runDestructors(destructors);
+ };
+ }
+ Object.defineProperty(
+ classType.registeredClass.constructor,
+ fieldName,
+ desc,
+ );
+ return [];
+ });
+ return [];
+ });
+ }
+ function __embind_register_class_constructor(
+ rawClassType,
+ argCount,
+ rawArgTypesAddr,
+ invokerSignature,
+ invoker,
+ rawConstructor,
+ ) {
+ rawClassType >>>= 0;
+ rawArgTypesAddr >>>= 0;
+ invokerSignature >>>= 0;
+ invoker >>>= 0;
+ rawConstructor >>>= 0;
+ var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ invoker = embind__requireFunction(invokerSignature, invoker);
+ whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+ classType = classType[0];
+ var humanName = `constructor ${classType.name}`;
+ if (undefined === classType.registeredClass.constructor_body) {
+ classType.registeredClass.constructor_body = [];
+ }
+ if (
+ undefined !== classType.registeredClass.constructor_body[argCount - 1]
+ ) {
+ throw new BindingError(
+ `Cannot register multiple constructors with identical number of parameters (${argCount - 1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`,
+ );
+ }
+ classType.registeredClass.constructor_body[argCount - 1] = () => {
+ throwUnboundTypeError(
+ `Cannot construct ${classType.name} due to unbound types`,
+ rawArgTypes,
+ );
+ };
+ whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+ argTypes.splice(1, 0, null);
+ classType.registeredClass.constructor_body[argCount - 1] =
+ craftInvokerFunction(
+ humanName,
+ argTypes,
+ null,
+ invoker,
+ rawConstructor,
+ );
+ return [];
+ });
+ return [];
+ });
+ }
+ function __embind_register_class_function(
+ rawClassType,
+ methodName,
+ argCount,
+ rawArgTypesAddr,
+ invokerSignature,
+ rawInvoker,
+ context,
+ isPureVirtual,
+ isAsync,
+ ) {
+ rawClassType >>>= 0;
+ methodName >>>= 0;
+ rawArgTypesAddr >>>= 0;
+ invokerSignature >>>= 0;
+ rawInvoker >>>= 0;
+ context >>>= 0;
+ var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ methodName = readLatin1String(methodName);
+ methodName = getFunctionName(methodName);
+ rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+ whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+ classType = classType[0];
+ var humanName = `${classType.name}.${methodName}`;
+ if (methodName.startsWith("@@")) {
+ methodName = Symbol[methodName.substring(2)];
+ }
+ if (isPureVirtual) {
+ classType.registeredClass.pureVirtualFunctions.push(methodName);
+ }
+ function unboundTypesHandler() {
+ throwUnboundTypeError(
+ `Cannot call ${humanName} due to unbound types`,
+ rawArgTypes,
+ );
+ }
+ var proto = classType.registeredClass.instancePrototype;
+ var method = proto[methodName];
+ if (
+ undefined === method ||
+ (undefined === method.overloadTable &&
+ method.className !== classType.name &&
+ method.argCount === argCount - 2)
+ ) {
+ unboundTypesHandler.argCount = argCount - 2;
+ unboundTypesHandler.className = classType.name;
+ proto[methodName] = unboundTypesHandler;
+ } else {
+ ensureOverloadTable(proto, methodName, humanName);
+ proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+ }
+ whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+ var memberFunction = craftInvokerFunction(
+ humanName,
+ argTypes,
+ classType,
+ rawInvoker,
+ context,
+ isAsync,
+ );
+ if (undefined === proto[methodName].overloadTable) {
+ memberFunction.argCount = argCount - 2;
+ proto[methodName] = memberFunction;
+ } else {
+ proto[methodName].overloadTable[argCount - 2] = memberFunction;
+ }
+ return [];
+ });
+ return [];
+ });
+ }
+ function __embind_register_class_property(
+ classType,
+ fieldName,
+ getterReturnType,
+ getterSignature,
+ getter,
+ getterContext,
+ setterArgumentType,
+ setterSignature,
+ setter,
+ setterContext,
+ ) {
+ classType >>>= 0;
+ fieldName >>>= 0;
+ getterReturnType >>>= 0;
+ getterSignature >>>= 0;
+ getter >>>= 0;
+ getterContext >>>= 0;
+ setterArgumentType >>>= 0;
+ setterSignature >>>= 0;
+ setter >>>= 0;
+ setterContext >>>= 0;
+ fieldName = readLatin1String(fieldName);
+ getter = embind__requireFunction(getterSignature, getter);
+ whenDependentTypesAreResolved([], [classType], function (classType) {
+ classType = classType[0];
+ var humanName = `${classType.name}.${fieldName}`;
+ var desc = {
+ get() {
+ throwUnboundTypeError(
+ `Cannot access ${humanName} due to unbound types`,
+ [getterReturnType, setterArgumentType],
+ );
+ },
+ enumerable: true,
+ configurable: true,
+ };
+ if (setter) {
+ desc.set = () =>
+ throwUnboundTypeError(
+ `Cannot access ${humanName} due to unbound types`,
+ [getterReturnType, setterArgumentType],
+ );
+ } else {
+ desc.set = (v) =>
+ throwBindingError(humanName + " is a read-only property");
+ }
+ Object.defineProperty(
+ classType.registeredClass.instancePrototype,
+ fieldName,
+ desc,
+ );
+ whenDependentTypesAreResolved(
+ [],
+ setter ? [getterReturnType, setterArgumentType] : [getterReturnType],
+ function (types) {
+ var getterReturnType = types[0];
+ var desc = {
+ get() {
+ var ptr = validateThis(this, classType, humanName + " getter");
+ return getterReturnType["fromWireType"](
+ getter(getterContext, ptr),
+ );
+ },
+ enumerable: true,
+ };
+ if (setter) {
+ setter = embind__requireFunction(setterSignature, setter);
+ var setterArgumentType = types[1];
+ desc.set = function (v) {
+ var ptr = validateThis(this, classType, humanName + " setter");
+ var destructors = [];
+ setter(
+ setterContext,
+ ptr,
+ setterArgumentType["toWireType"](destructors, v),
+ );
+ runDestructors(destructors);
+ };
+ }
+ Object.defineProperty(
+ classType.registeredClass.instancePrototype,
+ fieldName,
+ desc,
+ );
+ return [];
+ },
+ );
+ return [];
+ });
+ }
+ function handleAllocatorInit() {
+ Object.assign(HandleAllocator.prototype, {
+ get(id) {
+ return this.allocated[id];
+ },
+ has(id) {
+ return this.allocated[id] !== undefined;
+ },
+ allocate(handle) {
+ var id = this.freelist.pop() || this.allocated.length;
+ this.allocated[id] = handle;
+ return id;
+ },
+ free(id) {
+ this.allocated[id] = undefined;
+ this.freelist.push(id);
+ },
+ });
+ }
+ function HandleAllocator() {
+ this.allocated = [undefined];
+ this.freelist = [];
+ }
+ var emval_handles = new HandleAllocator();
+ function __emval_decref(handle) {
+ handle >>>= 0;
+ if (
+ handle >= emval_handles.reserved &&
+ 0 === --emval_handles.get(handle).refcount
+ ) {
+ emval_handles.free(handle);
+ }
+ }
+ var count_emval_handles = () => {
+ var count = 0;
+ for (
+ var i = emval_handles.reserved;
+ i < emval_handles.allocated.length;
+ ++i
+ ) {
+ if (emval_handles.allocated[i] !== undefined) {
+ ++count;
+ }
+ }
+ return count;
+ };
+ var init_emval = () => {
+ emval_handles.allocated.push(
+ { value: undefined },
+ { value: null },
+ { value: true },
+ { value: false },
+ );
+ emval_handles.reserved = emval_handles.allocated.length;
+ Module["count_emval_handles"] = count_emval_handles;
+ };
+ var Emval = {
+ toValue: (handle) => {
+ if (!handle) {
+ throwBindingError("Cannot use deleted val. handle = " + handle);
+ }
+ return emval_handles.get(handle).value;
+ },
+ toHandle: (value) => {
+ switch (value) {
+ case undefined:
+ return 1;
+ case null:
+ return 2;
+ case true:
+ return 3;
+ case false:
+ return 4;
+ default: {
+ return emval_handles.allocate({ refcount: 1, value: value });
+ }
+ }
+ },
+ };
+ function simpleReadValueFromPointer(pointer) {
+ return this["fromWireType"](GROWABLE_HEAP_I32()[(pointer >>> 2) >>> 0]);
+ }
+ var __embind_register_emval = function (rawType, name) {
+ rawType >>>= 0;
+ name >>>= 0;
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ fromWireType: (handle) => {
+ var rv = Emval.toValue(handle);
+ __emval_decref(handle);
+ return rv;
+ },
+ toWireType: (destructors, value) => Emval.toHandle(value),
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: simpleReadValueFromPointer,
+ destructorFunction: null,
+ });
+ };
+ var enumReadValueFromPointer = (name, width, signed) => {
+ switch (width) {
+ case 1:
+ return signed
+ ? function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_I8()[(pointer >>> 0) >>> 0],
+ );
+ }
+ : function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_U8()[(pointer >>> 0) >>> 0],
+ );
+ };
+ case 2:
+ return signed
+ ? function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_I16()[(pointer >>> 1) >>> 0],
+ );
+ }
+ : function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_U16()[(pointer >>> 1) >>> 0],
+ );
+ };
+ case 4:
+ return signed
+ ? function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_I32()[(pointer >>> 2) >>> 0],
+ );
+ }
+ : function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_U32()[(pointer >>> 2) >>> 0],
+ );
+ };
+ default:
+ throw new TypeError(`invalid integer width (${width}): ${name}`);
+ }
+ };
+ function __embind_register_enum(rawType, name, size, isSigned) {
+ rawType >>>= 0;
+ name >>>= 0;
+ size >>>= 0;
+ name = readLatin1String(name);
+ function ctor() {}
+ ctor.values = {};
+ registerType(rawType, {
+ name: name,
+ constructor: ctor,
+ fromWireType: function (c) {
+ return this.constructor.values[c];
+ },
+ toWireType: (destructors, c) => c.value,
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: enumReadValueFromPointer(name, size, isSigned),
+ destructorFunction: null,
+ });
+ exposePublicSymbol(name, ctor);
+ }
+ var requireRegisteredType = (rawType, humanName) => {
+ var impl = registeredTypes[rawType];
+ if (undefined === impl) {
+ throwBindingError(
+ humanName + " has unknown type " + getTypeName(rawType),
+ );
+ }
+ return impl;
+ };
+ function __embind_register_enum_value(rawEnumType, name, enumValue) {
+ rawEnumType >>>= 0;
+ name >>>= 0;
+ enumValue >>>= 0;
+ var enumType = requireRegisteredType(rawEnumType, "enum");
+ name = readLatin1String(name);
+ var Enum = enumType.constructor;
+ var Value = Object.create(enumType.constructor.prototype, {
+ value: { value: enumValue },
+ constructor: {
+ value: createNamedFunction(
+ `${enumType.name}_${name}`,
+ function () {},
+ ),
+ },
+ });
+ Enum.values[enumValue] = Value;
+ Enum[name] = Value;
+ }
+ var embindRepr = (v) => {
+ if (v === null) {
+ return "null";
+ }
+ var t = typeof v;
+ if (t === "object" || t === "array" || t === "function") {
+ return v.toString();
+ } else {
+ return "" + v;
+ }
+ };
+ var floatReadValueFromPointer = (name, width) => {
+ switch (width) {
+ case 4:
+ return function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_F32()[(pointer >>> 2) >>> 0],
+ );
+ };
+ case 8:
+ return function (pointer) {
+ return this["fromWireType"](
+ GROWABLE_HEAP_F64()[(pointer >>> 3) >>> 0],
+ );
+ };
+ default:
+ throw new TypeError(`invalid float width (${width}): ${name}`);
+ }
+ };
+ var __embind_register_float = function (rawType, name, size) {
+ rawType >>>= 0;
+ name >>>= 0;
+ size >>>= 0;
+ name = readLatin1String(name);
+ registerType(rawType, {
+ name: name,
+ fromWireType: (value) => value,
+ toWireType: (destructors, value) => value,
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: floatReadValueFromPointer(name, size),
+ destructorFunction: null,
+ });
+ };
+ function __embind_register_function(
+ name,
+ argCount,
+ rawArgTypesAddr,
+ signature,
+ rawInvoker,
+ fn,
+ isAsync,
+ ) {
+ name >>>= 0;
+ rawArgTypesAddr >>>= 0;
+ signature >>>= 0;
+ rawInvoker >>>= 0;
+ fn >>>= 0;
+ var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ name = readLatin1String(name);
+ name = getFunctionName(name);
+ rawInvoker = embind__requireFunction(signature, rawInvoker);
+ exposePublicSymbol(
+ name,
+ function () {
+ throwUnboundTypeError(
+ `Cannot call ${name} due to unbound types`,
+ argTypes,
+ );
+ },
+ argCount - 1,
+ );
+ whenDependentTypesAreResolved([], argTypes, function (argTypes) {
+ var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
+ replacePublicSymbol(
+ name,
+ craftInvokerFunction(
+ name,
+ invokerArgsArray,
+ null,
+ rawInvoker,
+ fn,
+ isAsync,
+ ),
+ argCount - 1,
+ );
+ return [];
+ });
+ }
+ var integerReadValueFromPointer = (name, width, signed) => {
+ switch (width) {
+ case 1:
+ return signed
+ ? (pointer) => GROWABLE_HEAP_I8()[(pointer >>> 0) >>> 0]
+ : (pointer) => GROWABLE_HEAP_U8()[(pointer >>> 0) >>> 0];
+ case 2:
+ return signed
+ ? (pointer) => GROWABLE_HEAP_I16()[(pointer >>> 1) >>> 0]
+ : (pointer) => GROWABLE_HEAP_U16()[(pointer >>> 1) >>> 0];
+ case 4:
+ return signed
+ ? (pointer) => GROWABLE_HEAP_I32()[(pointer >>> 2) >>> 0]
+ : (pointer) => GROWABLE_HEAP_U32()[(pointer >>> 2) >>> 0];
+ default:
+ throw new TypeError(`invalid integer width (${width}): ${name}`);
+ }
+ };
+ function __embind_register_integer(
+ primitiveType,
+ name,
+ size,
+ minRange,
+ maxRange,
+ ) {
+ primitiveType >>>= 0;
+ name >>>= 0;
+ size >>>= 0;
+ name = readLatin1String(name);
+ if (maxRange === -1) {
+ maxRange = 4294967295;
+ }
+ var fromWireType = (value) => value;
+ if (minRange === 0) {
+ var bitshift = 32 - 8 * size;
+ fromWireType = (value) => (value << bitshift) >>> bitshift;
+ }
+ var isUnsignedType = name.includes("unsigned");
+ var checkAssertions = (value, toTypeName) => {};
+ var toWireType;
+ if (isUnsignedType) {
+ toWireType = function (destructors, value) {
+ checkAssertions(value, this.name);
+ return value >>> 0;
+ };
+ } else {
+ toWireType = function (destructors, value) {
+ checkAssertions(value, this.name);
+ return value;
+ };
+ }
+ registerType(primitiveType, {
+ name: name,
+ fromWireType: fromWireType,
+ toWireType: toWireType,
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: integerReadValueFromPointer(
+ name,
+ size,
+ minRange !== 0,
+ ),
+ destructorFunction: null,
+ });
+ }
+ function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+ rawType >>>= 0;
+ name >>>= 0;
+ var typeMapping = [
+ Int8Array,
+ Uint8Array,
+ Int16Array,
+ Uint16Array,
+ Int32Array,
+ Uint32Array,
+ Float32Array,
+ Float64Array,
+ ];
+ var TA = typeMapping[dataTypeIndex];
+ function decodeMemoryView(handle) {
+ var size = GROWABLE_HEAP_U32()[(handle >>> 2) >>> 0];
+ var data = GROWABLE_HEAP_U32()[((handle + 4) >>> 2) >>> 0];
+ return new TA(GROWABLE_HEAP_I8().buffer, data, size);
+ }
+ name = readLatin1String(name);
+ registerType(
+ rawType,
+ {
+ name: name,
+ fromWireType: decodeMemoryView,
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: decodeMemoryView,
+ },
+ { ignoreDuplicateRegistrations: true },
+ );
+ }
+ function __embind_register_smart_ptr(
+ rawType,
+ rawPointeeType,
+ name,
+ sharingPolicy,
+ getPointeeSignature,
+ rawGetPointee,
+ constructorSignature,
+ rawConstructor,
+ shareSignature,
+ rawShare,
+ destructorSignature,
+ rawDestructor,
+ ) {
+ rawType >>>= 0;
+ rawPointeeType >>>= 0;
+ name >>>= 0;
+ getPointeeSignature >>>= 0;
+ rawGetPointee >>>= 0;
+ constructorSignature >>>= 0;
+ rawConstructor >>>= 0;
+ shareSignature >>>= 0;
+ rawShare >>>= 0;
+ destructorSignature >>>= 0;
+ rawDestructor >>>= 0;
+ name = readLatin1String(name);
+ rawGetPointee = embind__requireFunction(
+ getPointeeSignature,
+ rawGetPointee,
+ );
+ rawConstructor = embind__requireFunction(
+ constructorSignature,
+ rawConstructor,
+ );
+ rawShare = embind__requireFunction(shareSignature, rawShare);
+ rawDestructor = embind__requireFunction(
+ destructorSignature,
+ rawDestructor,
+ );
+ whenDependentTypesAreResolved(
+ [rawType],
+ [rawPointeeType],
+ function (pointeeType) {
+ pointeeType = pointeeType[0];
+ var registeredPointer = new RegisteredPointer(
+ name,
+ pointeeType.registeredClass,
+ false,
+ false,
+ true,
+ pointeeType,
+ sharingPolicy,
+ rawGetPointee,
+ rawConstructor,
+ rawShare,
+ rawDestructor,
+ );
+ return [registeredPointer];
+ },
+ );
+ }
+ function __embind_register_std_string(rawType, name) {
+ rawType >>>= 0;
+ name >>>= 0;
+ name = readLatin1String(name);
+ var stdStringIsUTF8 = name === "std::string";
+ registerType(rawType, {
+ name: name,
+ fromWireType(value) {
+ var length = GROWABLE_HEAP_U32()[(value >>> 2) >>> 0];
+ var payload = value + 4;
+ var str;
+ if (stdStringIsUTF8) {
+ var decodeStartPtr = payload;
+ for (var i = 0; i <= length; ++i) {
+ var currentBytePtr = payload + i;
+ if (
+ i == length ||
+ GROWABLE_HEAP_U8()[currentBytePtr >>> 0] == 0
+ ) {
+ var maxRead = currentBytePtr - decodeStartPtr;
+ var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+ if (str === undefined) {
+ str = stringSegment;
+ } else {
+ str += String.fromCharCode(0);
+ str += stringSegment;
+ }
+ decodeStartPtr = currentBytePtr + 1;
+ }
+ }
+ } else {
+ var a = new Array(length);
+ for (var i = 0; i < length; ++i) {
+ a[i] = String.fromCharCode(
+ GROWABLE_HEAP_U8()[(payload + i) >>> 0],
+ );
+ }
+ str = a.join("");
+ }
+ _free(value);
+ return str;
+ },
+ toWireType(destructors, value) {
+ if (value instanceof ArrayBuffer) {
+ value = new Uint8Array(value);
+ }
+ var length;
+ var valueIsOfTypeString = typeof value == "string";
+ if (
+ !(
+ valueIsOfTypeString ||
+ value instanceof Uint8Array ||
+ value instanceof Uint8ClampedArray ||
+ value instanceof Int8Array
+ )
+ ) {
+ throwBindingError("Cannot pass non-string to std::string");
+ }
+ if (stdStringIsUTF8 && valueIsOfTypeString) {
+ length = lengthBytesUTF8(value);
+ } else {
+ length = value.length;
+ }
+ var base = _malloc(4 + length + 1);
+ var ptr = base + 4;
+ GROWABLE_HEAP_U32()[(base >>> 2) >>> 0] = length;
+ if (stdStringIsUTF8 && valueIsOfTypeString) {
+ stringToUTF8(value, ptr, length + 1);
+ } else {
+ if (valueIsOfTypeString) {
+ for (var i = 0; i < length; ++i) {
+ var charCode = value.charCodeAt(i);
+ if (charCode > 255) {
+ _free(ptr);
+ throwBindingError(
+ "String has UTF-16 code units that do not fit in 8 bits",
+ );
+ }
+ GROWABLE_HEAP_U8()[(ptr + i) >>> 0] = charCode;
+ }
+ } else {
+ for (var i = 0; i < length; ++i) {
+ GROWABLE_HEAP_U8()[(ptr + i) >>> 0] = value[i];
+ }
+ }
+ }
+ if (destructors !== null) {
+ destructors.push(_free, base);
+ }
+ return base;
+ },
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: readPointer,
+ destructorFunction(ptr) {
+ _free(ptr);
+ },
+ });
+ }
+ var UTF16Decoder =
+ typeof TextDecoder != "undefined"
+ ? new TextDecoder("utf-16le")
+ : undefined;
+ var UTF16ToString = (ptr, maxBytesToRead) => {
+ var endPtr = ptr;
+ var idx = endPtr >> 1;
+ var maxIdx = idx + maxBytesToRead / 2;
+ while (!(idx >= maxIdx) && GROWABLE_HEAP_U16()[idx >>> 0]) ++idx;
+ endPtr = idx << 1;
+ if (endPtr - ptr > 32 && UTF16Decoder)
+ return UTF16Decoder.decode(GROWABLE_HEAP_U8().slice(ptr, endPtr));
+ var str = "";
+ for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
+ var codeUnit = GROWABLE_HEAP_I16()[((ptr + i * 2) >>> 1) >>> 0];
+ if (codeUnit == 0) break;
+ str += String.fromCharCode(codeUnit);
+ }
+ return str;
+ };
+ var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+ if (maxBytesToWrite === undefined) {
+ maxBytesToWrite = 2147483647;
+ }
+ if (maxBytesToWrite < 2) return 0;
+ maxBytesToWrite -= 2;
+ var startPtr = outPtr;
+ var numCharsToWrite =
+ maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+ for (var i = 0; i < numCharsToWrite; ++i) {
+ var codeUnit = str.charCodeAt(i);
+ GROWABLE_HEAP_I16()[(outPtr >>> 1) >>> 0] = codeUnit;
+ outPtr += 2;
+ }
+ GROWABLE_HEAP_I16()[(outPtr >>> 1) >>> 0] = 0;
+ return outPtr - startPtr;
+ };
+ var lengthBytesUTF16 = (str) => str.length * 2;
+ var UTF32ToString = (ptr, maxBytesToRead) => {
+ var i = 0;
+ var str = "";
+ while (!(i >= maxBytesToRead / 4)) {
+ var utf32 = GROWABLE_HEAP_I32()[((ptr + i * 4) >>> 2) >>> 0];
+ if (utf32 == 0) break;
+ ++i;
+ if (utf32 >= 65536) {
+ var ch = utf32 - 65536;
+ str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+ } else {
+ str += String.fromCharCode(utf32);
+ }
+ }
+ return str;
+ };
+ var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
+ outPtr >>>= 0;
+ if (maxBytesToWrite === undefined) {
+ maxBytesToWrite = 2147483647;
+ }
+ if (maxBytesToWrite < 4) return 0;
+ var startPtr = outPtr;
+ var endPtr = startPtr + maxBytesToWrite - 4;
+ for (var i = 0; i < str.length; ++i) {
+ var codeUnit = str.charCodeAt(i);
+ if (codeUnit >= 55296 && codeUnit <= 57343) {
+ var trailSurrogate = str.charCodeAt(++i);
+ codeUnit =
+ (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023);
+ }
+ GROWABLE_HEAP_I32()[(outPtr >>> 2) >>> 0] = codeUnit;
+ outPtr += 4;
+ if (outPtr + 4 > endPtr) break;
+ }
+ GROWABLE_HEAP_I32()[(outPtr >>> 2) >>> 0] = 0;
+ return outPtr - startPtr;
+ };
+ var lengthBytesUTF32 = (str) => {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+ var codeUnit = str.charCodeAt(i);
+ if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
+ len += 4;
+ }
+ return len;
+ };
+ var __embind_register_std_wstring = function (rawType, charSize, name) {
+ rawType >>>= 0;
+ charSize >>>= 0;
+ name >>>= 0;
+ name = readLatin1String(name);
+ var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+ if (charSize === 2) {
+ decodeString = UTF16ToString;
+ encodeString = stringToUTF16;
+ lengthBytesUTF = lengthBytesUTF16;
+ getHeap = () => GROWABLE_HEAP_U16();
+ shift = 1;
+ } else if (charSize === 4) {
+ decodeString = UTF32ToString;
+ encodeString = stringToUTF32;
+ lengthBytesUTF = lengthBytesUTF32;
+ getHeap = () => GROWABLE_HEAP_U32();
+ shift = 2;
+ }
+ registerType(rawType, {
+ name: name,
+ fromWireType: (value) => {
+ var length = GROWABLE_HEAP_U32()[(value >>> 2) >>> 0];
+ var HEAP = getHeap();
+ var str;
+ var decodeStartPtr = value + 4;
+ for (var i = 0; i <= length; ++i) {
+ var currentBytePtr = value + 4 + i * charSize;
+ if (i == length || HEAP[currentBytePtr >>> shift] == 0) {
+ var maxReadBytes = currentBytePtr - decodeStartPtr;
+ var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+ if (str === undefined) {
+ str = stringSegment;
+ } else {
+ str += String.fromCharCode(0);
+ str += stringSegment;
+ }
+ decodeStartPtr = currentBytePtr + charSize;
+ }
+ }
+ _free(value);
+ return str;
+ },
+ toWireType: (destructors, value) => {
+ if (!(typeof value == "string")) {
+ throwBindingError(
+ `Cannot pass non-string to C++ string type ${name}`,
+ );
+ }
+ var length = lengthBytesUTF(value);
+ var ptr = _malloc(4 + length + charSize);
+ GROWABLE_HEAP_U32()[ptr >>> 2] = length >> shift;
+ encodeString(value, ptr + 4, length + charSize);
+ if (destructors !== null) {
+ destructors.push(_free, ptr);
+ }
+ return ptr;
+ },
+ argPackAdvance: GenericWireTypeSize,
+ readValueFromPointer: simpleReadValueFromPointer,
+ destructorFunction(ptr) {
+ _free(ptr);
+ },
+ });
+ };
+ var __embind_register_void = function (rawType, name) {
+ rawType >>>= 0;
+ name >>>= 0;
+ name = readLatin1String(name);
+ registerType(rawType, {
+ isVoid: true,
+ name: name,
+ argPackAdvance: 0,
+ fromWireType: () => undefined,
+ toWireType: (destructors, o) => undefined,
+ });
+ };
+ var nowIsMonotonic = true;
+ var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
+ function __emscripten_thread_mailbox_await(pthread_ptr) {
+ pthread_ptr >>>= 0;
+ if (typeof Atomics.waitAsync === "function") {
+ var wait = Atomics.waitAsync(
+ GROWABLE_HEAP_I32(),
+ pthread_ptr >>> 2,
+ pthread_ptr,
+ );
+ wait.value.then(checkMailbox);
+ var waitingAsync = pthread_ptr + 128;
+ Atomics.store(GROWABLE_HEAP_I32(), waitingAsync >>> 2, 1);
+ }
+ }
+ Module["__emscripten_thread_mailbox_await"] =
+ __emscripten_thread_mailbox_await;
+ var checkMailbox = () => {
+ var pthread_ptr = _pthread_self();
+ if (pthread_ptr) {
+ __emscripten_thread_mailbox_await(pthread_ptr);
+ callUserCallback(() => __emscripten_check_mailbox());
+ }
+ };
+ Module["checkMailbox"] = checkMailbox;
+ var __emscripten_notify_mailbox_postmessage = function (
+ targetThreadId,
+ currThreadId,
+ mainThreadId,
+ ) {
+ targetThreadId >>>= 0;
+ currThreadId >>>= 0;
+ mainThreadId >>>= 0;
+ if (targetThreadId == currThreadId) {
+ setTimeout(() => checkMailbox());
+ } else if (ENVIRONMENT_IS_PTHREAD) {
+ postMessage({ targetThread: targetThreadId, cmd: "checkMailbox" });
+ } else {
+ var worker = PThread.pthreads[targetThreadId];
+ if (!worker) {
+ return;
+ }
+ worker.postMessage({ cmd: "checkMailbox" });
+ }
+ };
+ var withStackSave = (f) => {
+ var stack = stackSave();
+ var ret = f();
+ stackRestore(stack);
+ return ret;
+ };
+ var proxyToMainThread = function (index, sync) {
+ var numCallArgs = arguments.length - 2;
+ var outerArgs = arguments;
+ return withStackSave(() => {
+ var serializedNumCallArgs = numCallArgs;
+ var args = stackAlloc(serializedNumCallArgs * 8);
+ var b = args >>> 3;
+ for (var i = 0; i < numCallArgs; i++) {
+ var arg = outerArgs[2 + i];
+ GROWABLE_HEAP_F64()[(b + i) >>> 0] = arg;
+ }
+ return __emscripten_run_on_main_thread_js(
+ index,
+ serializedNumCallArgs,
+ args,
+ sync,
+ );
+ });
+ };
+ var proxiedJSCallArgs = [];
+ function __emscripten_receive_on_main_thread_js(
+ index,
+ callingThread,
+ numCallArgs,
+ args,
+ ) {
+ callingThread >>>= 0;
+ args >>>= 0;
+ proxiedJSCallArgs.length = numCallArgs;
+ var b = args >>> 3;
+ for (var i = 0; i < numCallArgs; i++) {
+ proxiedJSCallArgs[i] = GROWABLE_HEAP_F64()[(b + i) >>> 0];
+ }
+ var func = proxiedFunctionTable[index];
+ PThread.currentProxiedOperationCallerThread = callingThread;
+ var rtn = func.apply(null, proxiedJSCallArgs);
+ PThread.currentProxiedOperationCallerThread = 0;
+ return rtn;
+ }
+ function __emscripten_runtime_keepalive_clear() {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(20, 1);
+ noExitRuntime = false;
+ runtimeKeepaliveCounter = 0;
+ }
+ function __emscripten_thread_set_strongref(thread) {
+ thread >>>= 0;
+ if (ENVIRONMENT_IS_NODE) {
+ PThread.pthreads[thread].ref();
+ }
+ }
+ function __emval_as(handle, returnType, destructorsRef) {
+ handle >>>= 0;
+ returnType >>>= 0;
+ destructorsRef >>>= 0;
+ handle = Emval.toValue(handle);
+ returnType = requireRegisteredType(returnType, "emval::as");
+ var destructors = [];
+ var rd = Emval.toHandle(destructors);
+ GROWABLE_HEAP_U32()[(destructorsRef >>> 2) >>> 0] = rd;
+ return returnType["toWireType"](destructors, handle);
+ }
+ function __emval_as_int64(handle, returnType) {
+ handle >>>= 0;
+ returnType >>>= 0;
+ handle = Emval.toValue(handle);
+ returnType = requireRegisteredType(returnType, "emval::as");
+ return returnType["toWireType"](null, handle);
+ }
+ function __emval_as_uint64(handle, returnType) {
+ handle >>>= 0;
+ returnType >>>= 0;
+ handle = Emval.toValue(handle);
+ returnType = requireRegisteredType(returnType, "emval::as");
+ return returnType["toWireType"](null, handle);
+ }
+ var emval_lookupTypes = (argCount, argTypes) => {
+ var a = new Array(argCount);
+ for (var i = 0; i < argCount; ++i) {
+ a[i] = requireRegisteredType(
+ GROWABLE_HEAP_U32()[((argTypes + i * 4) >>> 2) >>> 0],
+ "parameter " + i,
+ );
+ }
+ return a;
+ };
+ function __emval_call(handle, argCount, argTypes, argv) {
+ handle >>>= 0;
+ argTypes >>>= 0;
+ argv >>>= 0;
+ handle = Emval.toValue(handle);
+ var types = emval_lookupTypes(argCount, argTypes);
+ var args = new Array(argCount);
+ for (var i = 0; i < argCount; ++i) {
+ var type = types[i];
+ args[i] = type["readValueFromPointer"](argv);
+ argv += type["argPackAdvance"];
+ }
+ var rv = handle.apply(undefined, args);
+ return Emval.toHandle(rv);
+ }
+ var emval_symbols = {};
+ var getStringOrSymbol = (address) => {
+ var symbol = emval_symbols[address];
+ if (symbol === undefined) {
+ return readLatin1String(address);
+ }
+ return symbol;
+ };
+ var emval_methodCallers = [];
+ function __emval_call_method(
+ caller,
+ handle,
+ methodName,
+ destructorsRef,
+ args,
+ ) {
+ caller >>>= 0;
+ handle >>>= 0;
+ methodName >>>= 0;
+ destructorsRef >>>= 0;
+ args >>>= 0;
+ caller = emval_methodCallers[caller];
+ handle = Emval.toValue(handle);
+ methodName = getStringOrSymbol(methodName);
+ var destructors = [];
+ var result = caller(handle, methodName, destructors, args);
+ if (destructors.length) {
+ GROWABLE_HEAP_U32()[(destructorsRef >>> 2) >>> 0] =
+ Emval.toHandle(destructors);
+ }
+ return result;
+ }
+ function __emval_equals(first, second) {
+ first >>>= 0;
+ second >>>= 0;
+ first = Emval.toValue(first);
+ second = Emval.toValue(second);
+ return first == second;
+ }
+ var emval_get_global = () => {
+ if (typeof globalThis == "object") {
+ return globalThis;
+ }
+ return (function () {
+ return Function;
+ })()("return this")();
+ };
+ function __emval_get_global(name) {
+ name >>>= 0;
+ if (name === 0) {
+ return Emval.toHandle(emval_get_global());
+ } else {
+ name = getStringOrSymbol(name);
+ return Emval.toHandle(emval_get_global()[name]);
+ }
+ }
+ var emval_addMethodCaller = (caller) => {
+ var id = emval_methodCallers.length;
+ emval_methodCallers.push(caller);
+ return id;
+ };
+ function __emval_get_method_caller(argCount, argTypes) {
+ argTypes >>>= 0;
+ var types = emval_lookupTypes(argCount, argTypes);
+ var retType = types.shift();
+ argCount--;
+ var params = ["retType"];
+ var args = [retType];
+ var argsList = "";
+ for (var i = 0; i < argCount; ++i) {
+ argsList += (i !== 0 ? ", " : "") + "arg" + i;
+ params.push("argType" + i);
+ args.push(types[i]);
+ }
+ var signatureName =
+ retType.name + "_$" + types.map((t) => t.name).join("_") + "$";
+ var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
+ var functionBody =
+ "return function " +
+ functionName +
+ "(handle, name, destructors, args) {\n";
+ var offset = 0;
+ for (var i = 0; i < argCount; ++i) {
+ functionBody +=
+ " var arg" +
+ i +
+ " = argType" +
+ i +
+ ".readValueFromPointer(args" +
+ (offset ? "+" + offset : "") +
+ ");\n";
+ offset += types[i]["argPackAdvance"];
+ }
+ functionBody += " var rv = handle[name](" + argsList + ");\n";
+ for (var i = 0; i < argCount; ++i) {
+ if (types[i]["deleteObject"]) {
+ functionBody += " argType" + i + ".deleteObject(arg" + i + ");\n";
+ }
+ }
+ if (!retType.isVoid) {
+ functionBody += " return retType.toWireType(destructors, rv);\n";
+ }
+ functionBody += "};\n";
+ params.push(functionBody);
+ var invokerFunction = newFunc(Function, params).apply(null, args);
+ return emval_addMethodCaller(invokerFunction);
+ }
+ function __emval_get_property(handle, key) {
+ handle >>>= 0;
+ key >>>= 0;
+ handle = Emval.toValue(handle);
+ key = Emval.toValue(key);
+ return Emval.toHandle(handle[key]);
+ }
+ function __emval_incref(handle) {
+ handle >>>= 0;
+ if (handle > 4) {
+ emval_handles.get(handle).refcount += 1;
+ }
+ }
+ function __emval_instanceof(object, constructor) {
+ object >>>= 0;
+ constructor >>>= 0;
+ object = Emval.toValue(object);
+ constructor = Emval.toValue(constructor);
+ return object instanceof constructor;
+ }
+ function __emval_new_array() {
+ return Emval.toHandle([]);
+ }
+ function __emval_new_cstring(v) {
+ v >>>= 0;
+ return Emval.toHandle(getStringOrSymbol(v));
+ }
+ function __emval_new_object() {
+ return Emval.toHandle({});
+ }
+ function __emval_run_destructors(handle) {
+ handle >>>= 0;
+ var destructors = Emval.toValue(handle);
+ runDestructors(destructors);
+ __emval_decref(handle);
+ }
+ function __emval_set_property(handle, key, value) {
+ handle >>>= 0;
+ key >>>= 0;
+ value >>>= 0;
+ handle = Emval.toValue(handle);
+ key = Emval.toValue(key);
+ value = Emval.toValue(value);
+ handle[key] = value;
+ }
+ function __emval_take_value(type, arg) {
+ type >>>= 0;
+ arg >>>= 0;
+ type = requireRegisteredType(type, "_emval_take_value");
+ var v = type["readValueFromPointer"](arg);
+ return Emval.toHandle(v);
+ }
+ function __emval_typeof(handle) {
+ handle >>>= 0;
+ handle = Emval.toValue(handle);
+ return Emval.toHandle(typeof handle);
+ }
+ function __mmap_js(
+ len,
+ prot,
+ flags,
+ fd,
+ offset_low,
+ offset_high,
+ allocated,
+ addr,
+ ) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(
+ 21,
+ 1,
+ len,
+ prot,
+ flags,
+ fd,
+ offset_low,
+ offset_high,
+ allocated,
+ addr,
+ );
+ len >>>= 0;
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+ allocated >>>= 0;
+ addr >>>= 0;
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var res = FS.mmap(stream, len, offset, prot, flags);
+ var ptr = res.ptr;
+ GROWABLE_HEAP_I32()[(allocated >>> 2) >>> 0] = res.allocated;
+ GROWABLE_HEAP_U32()[(addr >>> 2) >>> 0] = ptr;
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ function __munmap_js(addr, len, prot, flags, fd, offset_low, offset_high) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(
+ 22,
+ 1,
+ addr,
+ len,
+ prot,
+ flags,
+ fd,
+ offset_low,
+ offset_high,
+ );
+ addr >>>= 0;
+ len >>>= 0;
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ if (prot & 2) {
+ SYSCALLS.doMsync(addr, stream, len, flags, offset);
+ }
+ FS.munmap(stream);
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno;
+ }
+ }
+ var timers = {};
+ var _emscripten_get_now;
+ _emscripten_get_now = () => performance.timeOrigin + performance.now();
+ function __setitimer_js(which, timeout_ms) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(23, 1, which, timeout_ms);
+ if (timers[which]) {
+ clearTimeout(timers[which].id);
+ delete timers[which];
+ }
+ if (!timeout_ms) return 0;
+ var id = setTimeout(() => {
+ delete timers[which];
+ callUserCallback(() =>
+ __emscripten_timeout(which, _emscripten_get_now()),
+ );
+ }, timeout_ms);
+ timers[which] = { id: id, timeout_ms: timeout_ms };
+ return 0;
+ }
+ var _abort = () => {
+ abort("");
+ };
+ var warnOnce = (text) => {
+ if (!warnOnce.shown) warnOnce.shown = {};
+ if (!warnOnce.shown[text]) {
+ warnOnce.shown[text] = 1;
+ if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
+ err(text);
+ }
+ };
+ var _emscripten_check_blocking_allowed = () => {};
+ var _emscripten_date_now = () => Date.now();
+ var _emscripten_exit_with_live_runtime = () => {
+ runtimeKeepalivePush();
+ throw "unwind";
+ };
+ function _emscripten_force_exit(status) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(24, 1, status);
+ __emscripten_runtime_keepalive_clear();
+ _exit(status);
+ }
+ var getHeapMax = () => 4294901760;
+ function _emscripten_get_heap_max() {
+ return getHeapMax();
+ }
+ var _emscripten_num_logical_cores = () => {
+ if (ENVIRONMENT_IS_NODE) return require("os").cpus().length;
+ return navigator["hardwareConcurrency"];
+ };
+ var growMemory = (size) => {
+ var b = wasmMemory.buffer;
+ var pages = (size - b.byteLength + 65535) / 65536;
+ try {
+ wasmMemory.grow(pages);
+ updateMemoryViews();
+ return 1;
+ } catch (e) {}
+ };
+ function _emscripten_resize_heap(requestedSize) {
+ requestedSize >>>= 0;
+ var oldSize = GROWABLE_HEAP_U8().length;
+ if (requestedSize <= oldSize) {
+ return false;
+ }
+ var maxHeapSize = getHeapMax();
+ if (requestedSize > maxHeapSize) {
+ return false;
+ }
+ var alignUp = (x, multiple) =>
+ x + ((multiple - (x % multiple)) % multiple);
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+ var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+ overGrownHeapSize = Math.min(
+ overGrownHeapSize,
+ requestedSize + 100663296,
+ );
+ var newSize = Math.min(
+ maxHeapSize,
+ alignUp(Math.max(requestedSize, overGrownHeapSize), 65536),
+ );
+ var replacement = growMemory(newSize);
+ if (replacement) {
+ return true;
+ }
+ }
+ return false;
+ }
+ var ENV = {};
+ var getExecutableName = () => thisProgram || "./this.program";
+ var getEnvStrings = () => {
+ if (!getEnvStrings.strings) {
+ var lang =
+ (
+ (typeof navigator == "object" &&
+ navigator.languages &&
+ navigator.languages[0]) ||
+ "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;
+ };
+ var stringToAscii = (str, buffer) => {
+ for (var i = 0; i < str.length; ++i) {
+ GROWABLE_HEAP_I8()[(buffer++ >>> 0) >>> 0] = str.charCodeAt(i);
+ }
+ GROWABLE_HEAP_I8()[(buffer >>> 0) >>> 0] = 0;
+ };
+ var _environ_get = function (__environ, environ_buf) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(25, 1, __environ, environ_buf);
+ __environ >>>= 0;
+ environ_buf >>>= 0;
+ var bufSize = 0;
+ getEnvStrings().forEach((string, i) => {
+ var ptr = environ_buf + bufSize;
+ GROWABLE_HEAP_U32()[((__environ + i * 4) >>> 2) >>> 0] = ptr;
+ stringToAscii(string, ptr);
+ bufSize += string.length + 1;
+ });
+ return 0;
+ };
+ var _environ_sizes_get = function (penviron_count, penviron_buf_size) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(26, 1, penviron_count, penviron_buf_size);
+ penviron_count >>>= 0;
+ penviron_buf_size >>>= 0;
+ var strings = getEnvStrings();
+ GROWABLE_HEAP_U32()[(penviron_count >>> 2) >>> 0] = strings.length;
+ var bufSize = 0;
+ strings.forEach((string) => (bufSize += string.length + 1));
+ GROWABLE_HEAP_U32()[(penviron_buf_size >>> 2) >>> 0] = bufSize;
+ return 0;
+ };
+ function _fd_close(fd) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(27, 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;
+ }
+ }
+ function _fd_fdstat_get(fd, pbuf) {
+ if (ENVIRONMENT_IS_PTHREAD) return proxyToMainThread(28, 1, fd, pbuf);
+ pbuf >>>= 0;
+ try {
+ var rightsBase = 0;
+ var rightsInheriting = 0;
+ var flags = 0;
+ {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var type = stream.tty
+ ? 2
+ : FS.isDir(stream.mode)
+ ? 3
+ : FS.isLink(stream.mode)
+ ? 7
+ : 4;
+ }
+ GROWABLE_HEAP_I8()[(pbuf >>> 0) >>> 0] = type;
+ GROWABLE_HEAP_I16()[((pbuf + 2) >>> 1) >>> 0] = flags;
+ (tempI64 = [
+ rightsBase >>> 0,
+ ((tempDouble = rightsBase),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((pbuf + 8) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((pbuf + 12) >>> 2) >>> 0] = tempI64[1]);
+ (tempI64 = [
+ rightsInheriting >>> 0,
+ ((tempDouble = rightsInheriting),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[((pbuf + 16) >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((pbuf + 20) >>> 2) >>> 0] = tempI64[1]);
+ 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; i < iovcnt; i++) {
+ var ptr = GROWABLE_HEAP_U32()[(iov >>> 2) >>> 0];
+ var len = GROWABLE_HEAP_U32()[((iov + 4) >>> 2) >>> 0];
+ iov += 8;
+ var curr = FS.read(stream, GROWABLE_HEAP_I8(), ptr, len, offset);
+ if (curr < 0) return -1;
+ ret += curr;
+ if (curr < len) break;
+ if (typeof offset !== "undefined") {
+ offset += curr;
+ }
+ }
+ return ret;
+ };
+ function _fd_pread(fd, iov, iovcnt, offset_low, offset_high, pnum) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(
+ 29,
+ 1,
+ fd,
+ iov,
+ iovcnt,
+ offset_low,
+ offset_high,
+ pnum,
+ );
+ iov >>>= 0;
+ iovcnt >>>= 0;
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+ pnum >>>= 0;
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doReadv(stream, iov, iovcnt, offset);
+ GROWABLE_HEAP_U32()[(pnum >>> 2) >>> 0] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno;
+ }
+ }
+ var doWritev = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = GROWABLE_HEAP_U32()[(iov >>> 2) >>> 0];
+ var len = GROWABLE_HEAP_U32()[((iov + 4) >>> 2) >>> 0];
+ iov += 8;
+ var curr = FS.write(stream, GROWABLE_HEAP_I8(), ptr, len, offset);
+ if (curr < 0) return -1;
+ ret += curr;
+ if (typeof offset !== "undefined") {
+ offset += curr;
+ }
+ }
+ return ret;
+ };
+ function _fd_pwrite(fd, iov, iovcnt, offset_low, offset_high, pnum) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(
+ 30,
+ 1,
+ fd,
+ iov,
+ iovcnt,
+ offset_low,
+ offset_high,
+ pnum,
+ );
+ iov >>>= 0;
+ iovcnt >>>= 0;
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+ pnum >>>= 0;
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doWritev(stream, iov, iovcnt, offset);
+ GROWABLE_HEAP_U32()[(pnum >>> 2) >>> 0] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno;
+ }
+ }
+ function _fd_read(fd, iov, iovcnt, pnum) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(31, 1, fd, iov, iovcnt, pnum);
+ iov >>>= 0;
+ iovcnt >>>= 0;
+ pnum >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doReadv(stream, iov, iovcnt);
+ GROWABLE_HEAP_U32()[(pnum >>> 2) >>> 0] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno;
+ }
+ }
+ function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(
+ 32,
+ 1,
+ fd,
+ offset_low,
+ offset_high,
+ whence,
+ newOffset,
+ );
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+ newOffset >>>= 0;
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ FS.llseek(stream, offset, whence);
+ (tempI64 = [
+ stream.position >>> 0,
+ ((tempDouble = stream.position),
+ +Math.abs(tempDouble) >= 1
+ ? tempDouble > 0
+ ? +Math.floor(tempDouble / 4294967296) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296,
+ ) >>> 0
+ : 0),
+ ]),
+ (GROWABLE_HEAP_I32()[(newOffset >>> 2) >>> 0] = tempI64[0]),
+ (GROWABLE_HEAP_I32()[((newOffset + 4) >>> 2) >>> 0] = tempI64[1]);
+ if (stream.getdents && offset === 0 && whence === 0)
+ stream.getdents = null;
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno;
+ }
+ }
+ function _fd_write(fd, iov, iovcnt, pnum) {
+ if (ENVIRONMENT_IS_PTHREAD)
+ return proxyToMainThread(33, 1, fd, iov, iovcnt, pnum);
+ iov >>>= 0;
+ iovcnt >>>= 0;
+ pnum >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doWritev(stream, iov, iovcnt);
+ GROWABLE_HEAP_U32()[(pnum >>> 2) >>> 0] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno;
+ }
+ }
+ function _llvm_eh_typeid_for(type) {
+ type >>>= 0;
+ return type;
+ }
+ var isLeapYear = (year) =>
+ year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+ var arraySum = (array, index) => {
+ var sum = 0;
+ for (var i = 0; i <= index; sum += array[i++]) {}
+ return sum;
+ };
+ var MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+ var MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+ var addDays = (date, days) => {
+ var newDate = new Date(date.getTime());
+ while (days > 0) {
+ var leap = isLeapYear(newDate.getFullYear());
+ var currentMonth = newDate.getMonth();
+ var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[
+ currentMonth
+ ];
+ if (days > daysInCurrentMonth - newDate.getDate()) {
+ days -= daysInCurrentMonth - newDate.getDate() + 1;
+ newDate.setDate(1);
+ if (currentMonth < 11) {
+ newDate.setMonth(currentMonth + 1);
+ } else {
+ newDate.setMonth(0);
+ newDate.setFullYear(newDate.getFullYear() + 1);
+ }
+ } else {
+ newDate.setDate(newDate.getDate() + days);
+ return newDate;
+ }
+ }
+ return newDate;
+ };
+ var writeArrayToMemory = (array, buffer) => {
+ GROWABLE_HEAP_I8().set(array, buffer >>> 0);
+ };
+ function _strftime(s, maxsize, format, tm) {
+ s >>>= 0;
+ maxsize >>>= 0;
+ format >>>= 0;
+ tm >>>= 0;
+ var tm_zone = GROWABLE_HEAP_U32()[((tm + 40) >>> 2) >>> 0];
+ var date = {
+ tm_sec: GROWABLE_HEAP_I32()[(tm >>> 2) >>> 0],
+ tm_min: GROWABLE_HEAP_I32()[((tm + 4) >>> 2) >>> 0],
+ tm_hour: GROWABLE_HEAP_I32()[((tm + 8) >>> 2) >>> 0],
+ tm_mday: GROWABLE_HEAP_I32()[((tm + 12) >>> 2) >>> 0],
+ tm_mon: GROWABLE_HEAP_I32()[((tm + 16) >>> 2) >>> 0],
+ tm_year: GROWABLE_HEAP_I32()[((tm + 20) >>> 2) >>> 0],
+ tm_wday: GROWABLE_HEAP_I32()[((tm + 24) >>> 2) >>> 0],
+ tm_yday: GROWABLE_HEAP_I32()[((tm + 28) >>> 2) >>> 0],
+ tm_isdst: GROWABLE_HEAP_I32()[((tm + 32) >>> 2) >>> 0],
+ tm_gmtoff: GROWABLE_HEAP_I32()[((tm + 36) >>> 2) >>> 0],
+ tm_zone: tm_zone ? UTF8ToString(tm_zone) : "",
+ };
+ var pattern = UTF8ToString(format);
+ var EXPANSION_RULES_1 = {
+ "%c": "%a %b %d %H:%M:%S %Y",
+ "%D": "%m/%d/%y",
+ "%F": "%Y-%m-%d",
+ "%h": "%b",
+ "%r": "%I:%M:%S %p",
+ "%R": "%H:%M",
+ "%T": "%H:%M:%S",
+ "%x": "%m/%d/%y",
+ "%X": "%H:%M:%S",
+ "%Ec": "%c",
+ "%EC": "%C",
+ "%Ex": "%m/%d/%y",
+ "%EX": "%H:%M:%S",
+ "%Ey": "%y",
+ "%EY": "%Y",
+ "%Od": "%d",
+ "%Oe": "%e",
+ "%OH": "%H",
+ "%OI": "%I",
+ "%Om": "%m",
+ "%OM": "%M",
+ "%OS": "%S",
+ "%Ou": "%u",
+ "%OU": "%U",
+ "%OV": "%V",
+ "%Ow": "%w",
+ "%OW": "%W",
+ "%Oy": "%y",
+ };
+ for (var rule in EXPANSION_RULES_1) {
+ pattern = pattern.replace(
+ new RegExp(rule, "g"),
+ EXPANSION_RULES_1[rule],
+ );
+ }
+ var WEEKDAYS = [
+ "Sunday",
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday",
+ ];
+ var MONTHS = [
+ "January",
+ "February",
+ "March",
+ "April",
+ "May",
+ "June",
+ "July",
+ "August",
+ "September",
+ "October",
+ "November",
+ "December",
+ ];
+ function leadingSomething(value, digits, character) {
+ var str = typeof value == "number" ? value.toString() : value || "";
+ while (str.length < digits) {
+ str = character[0] + str;
+ }
+ return str;
+ }
+ function leadingNulls(value, digits) {
+ return leadingSomething(value, digits, "0");
+ }
+ function compareByDay(date1, date2) {
+ function sgn(value) {
+ return value < 0 ? -1 : value > 0 ? 1 : 0;
+ }
+ var compare;
+ if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
+ if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
+ compare = sgn(date1.getDate() - date2.getDate());
+ }
+ }
+ return compare;
+ }
+ function getFirstWeekStartDate(janFourth) {
+ switch (janFourth.getDay()) {
+ case 0:
+ return new Date(janFourth.getFullYear() - 1, 11, 29);
+ case 1:
+ return janFourth;
+ case 2:
+ return new Date(janFourth.getFullYear(), 0, 3);
+ case 3:
+ return new Date(janFourth.getFullYear(), 0, 2);
+ case 4:
+ return new Date(janFourth.getFullYear(), 0, 1);
+ case 5:
+ return new Date(janFourth.getFullYear() - 1, 11, 31);
+ case 6:
+ return new Date(janFourth.getFullYear() - 1, 11, 30);
+ }
+ }
+ function getWeekBasedYear(date) {
+ var thisDate = addDays(
+ new Date(date.tm_year + 1900, 0, 1),
+ date.tm_yday,
+ );
+ var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+ var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
+ var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+ var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+ if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+ if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+ return thisDate.getFullYear() + 1;
+ }
+ return thisDate.getFullYear();
+ }
+ return thisDate.getFullYear() - 1;
+ }
+ var EXPANSION_RULES_2 = {
+ "%a": (date) => WEEKDAYS[date.tm_wday].substring(0, 3),
+ "%A": (date) => WEEKDAYS[date.tm_wday],
+ "%b": (date) => MONTHS[date.tm_mon].substring(0, 3),
+ "%B": (date) => MONTHS[date.tm_mon],
+ "%C": (date) => {
+ var year = date.tm_year + 1900;
+ return leadingNulls((year / 100) | 0, 2);
+ },
+ "%d": (date) => leadingNulls(date.tm_mday, 2),
+ "%e": (date) => leadingSomething(date.tm_mday, 2, " "),
+ "%g": (date) => getWeekBasedYear(date).toString().substring(2),
+ "%G": (date) => getWeekBasedYear(date),
+ "%H": (date) => leadingNulls(date.tm_hour, 2),
+ "%I": (date) => {
+ var twelveHour = date.tm_hour;
+ if (twelveHour == 0) twelveHour = 12;
+ else if (twelveHour > 12) twelveHour -= 12;
+ return leadingNulls(twelveHour, 2);
+ },
+ "%j": (date) =>
+ leadingNulls(
+ date.tm_mday +
+ arraySum(
+ isLeapYear(date.tm_year + 1900)
+ ? MONTH_DAYS_LEAP
+ : MONTH_DAYS_REGULAR,
+ date.tm_mon - 1,
+ ),
+ 3,
+ ),
+ "%m": (date) => leadingNulls(date.tm_mon + 1, 2),
+ "%M": (date) => leadingNulls(date.tm_min, 2),
+ "%n": () => "\n",
+ "%p": (date) => {
+ if (date.tm_hour >= 0 && date.tm_hour < 12) {
+ return "AM";
+ }
+ return "PM";
+ },
+ "%S": (date) => leadingNulls(date.tm_sec, 2),
+ "%t": () => "\t",
+ "%u": (date) => date.tm_wday || 7,
+ "%U": (date) => {
+ var days = date.tm_yday + 7 - date.tm_wday;
+ return leadingNulls(Math.floor(days / 7), 2);
+ },
+ "%V": (date) => {
+ var val = Math.floor(
+ (date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7,
+ );
+ if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
+ val++;
+ }
+ if (!val) {
+ val = 52;
+ var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
+ if (
+ dec31 == 4 ||
+ (dec31 == 5 && isLeapYear((date.tm_year % 400) - 1))
+ ) {
+ val++;
+ }
+ } else if (val == 53) {
+ var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
+ if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date.tm_year))) val = 1;
+ }
+ return leadingNulls(val, 2);
+ },
+ "%w": (date) => date.tm_wday,
+ "%W": (date) => {
+ var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
+ return leadingNulls(Math.floor(days / 7), 2);
+ },
+ "%y": (date) => (date.tm_year + 1900).toString().substring(2),
+ "%Y": (date) => date.tm_year + 1900,
+ "%z": (date) => {
+ var off = date.tm_gmtoff;
+ var ahead = off >= 0;
+ off = Math.abs(off) / 60;
+ off = (off / 60) * 100 + (off % 60);
+ return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
+ },
+ "%Z": (date) => date.tm_zone,
+ "%%": () => "%",
+ };
+ pattern = pattern.replace(/%%/g, "\0\0");
+ for (var rule in EXPANSION_RULES_2) {
+ if (pattern.includes(rule)) {
+ pattern = pattern.replace(
+ new RegExp(rule, "g"),
+ EXPANSION_RULES_2[rule](date),
+ );
+ }
+ }
+ pattern = pattern.replace(/\0\0/g, "%");
+ var bytes = intArrayFromString(pattern, false);
+ if (bytes.length > maxsize) {
+ return 0;
+ }
+ writeArrayToMemory(bytes, s);
+ return bytes.length - 1;
+ }
+ function _strftime_l(s, maxsize, format, tm, loc) {
+ s >>>= 0;
+ maxsize >>>= 0;
+ format >>>= 0;
+ tm >>>= 0;
+ loc >>>= 0;
+ return _strftime(s, maxsize, format, tm);
+ }
+ PThread.init();
+ var FSNode = function (parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this;
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ };
+ var readMode = 292 | 73;
+ var writeMode = 146;
+ Object.defineProperties(FSNode.prototype, {
+ read: {
+ get: function () {
+ return (this.mode & readMode) === readMode;
+ },
+ set: function (val) {
+ val ? (this.mode |= readMode) : (this.mode &= ~readMode);
+ },
+ },
+ write: {
+ get: function () {
+ return (this.mode & writeMode) === writeMode;
+ },
+ set: function (val) {
+ val ? (this.mode |= writeMode) : (this.mode &= ~writeMode);
+ },
+ },
+ isFolder: {
+ get: function () {
+ return FS.isDir(this.mode);
+ },
+ },
+ isDevice: {
+ get: function () {
+ return FS.isChrdev(this.mode);
+ },
+ },
+ });
+ FS.FSNode = FSNode;
+ FS.createPreloadedFile = FS_createPreloadedFile;
+ FS.staticInit();
+ Module["FS_createPath"] = FS.createPath;
+ Module["FS_createDataFile"] = FS.createDataFile;
+ Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
+ Module["FS_unlink"] = FS.unlink;
+ Module["FS_createLazyFile"] = FS.createLazyFile;
+ Module["FS_createDevice"] = FS.createDevice;
+ embind_init_charCodes();
+ BindingError = Module["BindingError"] = class BindingError extends Error {
+ constructor(message) {
+ super(message);
+ this.name = "BindingError";
+ }
+ };
+ InternalError = Module["InternalError"] = class InternalError extends (
+ Error
+ ) {
+ constructor(message) {
+ super(message);
+ this.name = "InternalError";
+ }
+ };
+ init_ClassHandle();
+ init_embind();
+ init_RegisteredPointer();
+ UnboundTypeError = Module["UnboundTypeError"] = extendError(
+ Error,
+ "UnboundTypeError",
+ );
+ handleAllocatorInit();
+ init_emval();
+ var proxiedFunctionTable = [
+ _proc_exit,
+ exitOnMainThread,
+ pthreadCreateProxied,
+ ___syscall_chmod,
+ ___syscall_faccessat,
+ ___syscall_fadvise64,
+ ___syscall_fchmod,
+ ___syscall_fcntl64,
+ ___syscall_fstat64,
+ ___syscall_getcwd,
+ ___syscall_getdents64,
+ ___syscall_ioctl,
+ ___syscall_lstat64,
+ ___syscall_mkdirat,
+ ___syscall_newfstatat,
+ ___syscall_openat,
+ ___syscall_readlinkat,
+ ___syscall_renameat,
+ ___syscall_stat64,
+ ___syscall_unlinkat,
+ __emscripten_runtime_keepalive_clear,
+ __mmap_js,
+ __munmap_js,
+ __setitimer_js,
+ _emscripten_force_exit,
+ _environ_get,
+ _environ_sizes_get,
+ _fd_close,
+ _fd_fdstat_get,
+ _fd_pread,
+ _fd_pwrite,
+ _fd_read,
+ _fd_seek,
+ _fd_write,
+ ];
+ var wasmImports = {
+ Qb: __asyncjs__fetch_asset,
+ Lc: ___call_sighandler,
+ r: ___cxa_begin_catch,
+ D: ___cxa_end_catch,
+ b: ___cxa_find_matching_catch_2,
+ l: ___cxa_find_matching_catch_3,
+ Na: ___cxa_find_matching_catch_4,
+ nb: ___cxa_get_exception_ptr,
+ Ua: ___cxa_rethrow,
+ Bc: ___cxa_rethrow_primary_exception,
+ y: ___cxa_throw,
+ Cc: ___cxa_uncaught_exceptions,
+ Rc: ___emscripten_init_main_thread_js,
+ bb: ___emscripten_thread_cleanup,
+ Nc: ___pthread_create_js,
+ f: ___resumeException,
+ gb: ___syscall_chmod,
+ $c: ___syscall_faccessat,
+ _b: ___syscall_fadvise64,
+ Xc: ___syscall_fchmod,
+ hb: ___syscall_fcntl64,
+ Wc: ___syscall_fstat64,
+ Sc: ___syscall_getcwd,
+ Kc: ___syscall_getdents64,
+ cd: ___syscall_ioctl,
+ Tc: ___syscall_lstat64,
+ Pc: ___syscall_mkdirat,
+ Uc: ___syscall_newfstatat,
+ eb: ___syscall_openat,
+ Jc: ___syscall_readlinkat,
+ Ic: ___syscall_renameat,
+ Vc: ___syscall_stat64,
+ Ec: ___syscall_unlinkat,
+ cc: __embind_register_bigint,
+ gd: __embind_register_bool,
+ H: __embind_register_class,
+ da: __embind_register_class_class_function,
+ wa: __embind_register_class_class_property,
+ N: __embind_register_class_constructor,
+ z: __embind_register_class_function,
+ x: __embind_register_class_property,
+ fd: __embind_register_emval,
+ sb: __embind_register_enum,
+ Ea: __embind_register_enum_value,
+ jb: __embind_register_float,
+ ld: __embind_register_function,
+ oa: __embind_register_integer,
+ T: __embind_register_memory_view,
+ qa: __embind_register_smart_ptr,
+ ib: __embind_register_std_string,
+ Wa: __embind_register_std_wstring,
+ hd: __embind_register_void,
+ _c: __emscripten_get_now_is_monotonic,
+ Fc: __emscripten_notify_mailbox_postmessage,
+ Oc: __emscripten_receive_on_main_thread_js,
+ Mc: __emscripten_runtime_keepalive_clear,
+ Qc: __emscripten_thread_mailbox_await,
+ Zc: __emscripten_thread_set_strongref,
+ ra: __emval_as,
+ lc: __emval_as_int64,
+ kc: __emval_as_uint64,
+ Ha: __emval_call,
+ la: __emval_call_method,
+ yd: __emval_decref,
+ kd: __emval_equals,
+ od: __emval_get_global,
+ ka: __emval_get_method_caller,
+ Ad: __emval_get_property,
+ $a: __emval_incref,
+ pd: __emval_instanceof,
+ Ub: __emval_new_array,
+ Rb: __emval_new_cstring,
+ Tb: __emval_new_object,
+ Vb: __emval_run_destructors,
+ Sb: __emval_set_property,
+ F: __emval_take_value,
+ qd: __emval_typeof,
+ $b: __mmap_js,
+ ac: __munmap_js,
+ ab: __setitimer_js,
+ fa: _abort,
+ Pb: addToLoadedFiles,
+ rd: downloadJS,
+ cb: _emscripten_check_blocking_allowed,
+ fb: _emscripten_date_now,
+ Yc: _emscripten_exit_with_live_runtime,
+ tb: _emscripten_force_exit,
+ Gc: _emscripten_get_heap_max,
+ ba: _emscripten_get_now,
+ Hc: _emscripten_num_logical_cores,
+ Dc: _emscripten_resize_heap,
+ dd: _environ_get,
+ ed: _environ_sizes_get,
+ xa: _exit,
+ Ia: _fd_close,
+ db: _fd_fdstat_get,
+ Zb: _fd_pread,
+ Yb: _fd_pwrite,
+ bd: _fd_read,
+ bc: _fd_seek,
+ Va: _fd_write,
+ ub: invoke_dddd,
+ jd: invoke_ddiiiii,
+ s: invoke_di,
+ P: invoke_did,
+ nd: invoke_didii,
+ pa: invoke_dif,
+ Ta: invoke_dii,
+ sa: invoke_diii,
+ mc: invoke_dj,
+ Aa: invoke_fi,
+ Kb: invoke_fid,
+ Gb: invoke_fif,
+ mb: invoke_fii,
+ Sa: invoke_fiii,
+ xd: invoke_fiiid,
+ k: invoke_i,
+ Ab: invoke_idddii,
+ Bb: invoke_idddiii,
+ La: invoke_iddii,
+ Ma: invoke_iddiii,
+ zb: invoke_idi,
+ Fa: invoke_idii,
+ ob: invoke_idiiiiii,
+ Ja: invoke_idiiiiiii,
+ Eb: invoke_ifii,
+ c: invoke_ii,
+ Q: invoke_iid,
+ J: invoke_iidd,
+ _a: invoke_iiddddddiiii,
+ xb: invoke_iidi,
+ na: invoke_iidii,
+ aa: invoke_iidiii,
+ vd: invoke_iidiiii,
+ Za: invoke_iidiiiii,
+ M: invoke_iif,
+ ta: invoke_iiffi,
+ id: invoke_iifi,
+ e: invoke_iii,
+ q: invoke_iiid,
+ sd: invoke_iiidd,
+ ma: invoke_iiidddii,
+ td: invoke_iiiddi,
+ zd: invoke_iiiddii,
+ ca: invoke_iiidi,
+ w: invoke_iiidii,
+ vb: invoke_iiidiiidiiiidiif,
+ wb: invoke_iiidiiiii,
+ ya: invoke_iiiff,
+ Ra: invoke_iiifi,
+ h: invoke_iiii,
+ R: invoke_iiiid,
+ I: invoke_iiiiddd,
+ wd: invoke_iiiidii,
+ ua: invoke_iiiidiii,
+ md: invoke_iiiidiiii,
+ yb: invoke_iiiidiiiiii,
+ Hb: invoke_iiiifffffiiff,
+ m: invoke_iiiii,
+ L: invoke_iiiiid,
+ Ca: invoke_iiiiidiiii,
+ o: invoke_iiiiii,
+ Pa: invoke_iiiiiid,
+ B: invoke_iiiiiii,
+ rb: invoke_iiiiiiidddi,
+ C: invoke_iiiiiiii,
+ ud: invoke_iiiiiiiidi,
+ A: invoke_iiiiiiiii,
+ va: invoke_iiiiiiiiii,
+ kb: invoke_iiiiiiiiiii,
+ Da: invoke_iiiiiiiiiiii,
+ za: invoke_iiiiiiiiiiiii,
+ Oa: invoke_iiiiiiiiiiiiii,
+ Cb: invoke_iiiiiiiiiiiiiiiiiiii,
+ Xb: invoke_iiiiij,
+ dc: invoke_iiiij,
+ ec: invoke_iiiijii,
+ gc: invoke_iiiijjii,
+ sc: invoke_iiijj,
+ rc: invoke_iiijji,
+ jc: invoke_iij,
+ zc: invoke_j,
+ wc: invoke_ji,
+ pc: invoke_jii,
+ yc: invoke_jiii,
+ Wb: invoke_jiiii,
+ xc: invoke_jiij,
+ p: invoke_v,
+ Z: invoke_vd,
+ pb: invoke_vdiii,
+ Fb: invoke_vfiiii,
+ j: invoke_vi,
+ _: invoke_vid,
+ Mb: invoke_vidddi,
+ Jb: invoke_viddi,
+ Qa: invoke_vidi,
+ ea: invoke_vidii,
+ Ka: invoke_vidiii,
+ qb: invoke_vidiiii,
+ U: invoke_vif,
+ V: invoke_vifii,
+ d: invoke_vii,
+ W: invoke_viid,
+ Lb: invoke_viiddddi,
+ Nb: invoke_viiddi,
+ ja: invoke_viidi,
+ Xa: invoke_viidii,
+ t: invoke_viif,
+ g: invoke_viii,
+ Y: invoke_viiid,
+ Ob: invoke_viiiddddi,
+ O: invoke_viiidi,
+ ha: invoke_viiidii,
+ Ba: invoke_viiidiiiii,
+ Db: invoke_viiif,
+ i: invoke_viiii,
+ E: invoke_viiiid,
+ ia: invoke_viiiidi,
+ Ya: invoke_viiiidiiiiii,
+ n: invoke_viiiii,
+ S: invoke_viiiiid,
+ X: invoke_viiiiidi,
+ v: invoke_viiiiii,
+ G: invoke_viiiiiii,
+ Ib: invoke_viiiiiiid,
+ K: invoke_viiiiiiii,
+ $: invoke_viiiiiiiii,
+ ga: invoke_viiiiiiiiii,
+ lb: invoke_viiiiiiiiiiiii,
+ Ga: invoke_viiiiiiiiiiiiiii,
+ ic: invoke_viiiijii,
+ fc: invoke_viiijii,
+ hc: invoke_viiijjii,
+ vc: invoke_viij,
+ nc: invoke_viiji,
+ qc: invoke_vij,
+ uc: invoke_viji,
+ tc: invoke_vijii,
+ oc: invoke_vijji,
+ u: _llvm_eh_typeid_for,
+ a: wasmMemory || Module["wasmMemory"],
+ ad: _proc_exit,
+ Ac: _strftime_l,
+ };
+ var wasmExports = createWasm();
+ var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["Bd"])();
+ var _pthread_self = (Module["_pthread_self"] = () =>
+ (_pthread_self = Module["_pthread_self"] = wasmExports["Cd"])());
+ var ___cxa_free_exception = (a0) =>
+ (___cxa_free_exception = wasmExports["__cxa_free_exception"])(a0);
+ var _free = (a0) => (_free = wasmExports["Ed"])(a0);
+ var _malloc = (a0) => (_malloc = wasmExports["Fd"])(a0);
+ var ___errno_location = () => (___errno_location = wasmExports["Gd"])();
+ var __emscripten_tls_init = (Module["__emscripten_tls_init"] = () =>
+ (__emscripten_tls_init = Module["__emscripten_tls_init"] =
+ wasmExports["Hd"])());
+ var _emscripten_builtin_memalign = (a0, a1) =>
+ (_emscripten_builtin_memalign = wasmExports["Id"])(a0, a1);
+ var ___getTypeName = (a0) => (___getTypeName = wasmExports["Jd"])(a0);
+ var __embind_initialize_bindings = (Module["__embind_initialize_bindings"] =
+ () =>
+ (__embind_initialize_bindings = Module["__embind_initialize_bindings"] =
+ wasmExports["Kd"])());
+ var __emscripten_thread_init = (Module["__emscripten_thread_init"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ) =>
+ (__emscripten_thread_init = Module["__emscripten_thread_init"] =
+ wasmExports["Ld"])(a0, a1, a2, a3, a4, a5));
+ var __emscripten_thread_crashed = (Module["__emscripten_thread_crashed"] =
+ () =>
+ (__emscripten_thread_crashed = Module["__emscripten_thread_crashed"] =
+ wasmExports["Md"])());
+ var _emscripten_main_thread_process_queued_calls = () =>
+ (_emscripten_main_thread_process_queued_calls =
+ wasmExports["emscripten_main_thread_process_queued_calls"])();
+ var _emscripten_main_runtime_thread_id = () =>
+ (_emscripten_main_runtime_thread_id =
+ wasmExports["emscripten_main_runtime_thread_id"])();
+ var __emscripten_run_on_main_thread_js = (a0, a1, a2, a3) =>
+ (__emscripten_run_on_main_thread_js = wasmExports["Nd"])(a0, a1, a2, a3);
+ var __emscripten_thread_free_data = (a0) =>
+ (__emscripten_thread_free_data = wasmExports["Od"])(a0);
+ var __emscripten_thread_exit = (Module["__emscripten_thread_exit"] = (a0) =>
+ (__emscripten_thread_exit = Module["__emscripten_thread_exit"] =
+ wasmExports["Pd"])(a0));
+ var __emscripten_timeout = (a0, a1) =>
+ (__emscripten_timeout = wasmExports["Qd"])(a0, a1);
+ var __emscripten_check_mailbox = (Module["__emscripten_check_mailbox"] =
+ () =>
+ (__emscripten_check_mailbox = Module["__emscripten_check_mailbox"] =
+ wasmExports["Rd"])());
+ var _setThrew = (a0, a1) => (_setThrew = wasmExports["Sd"])(a0, a1);
+ var setTempRet0 = (a0) => (setTempRet0 = wasmExports["Td"])(a0);
+ var _emscripten_stack_set_limits = (a0, a1) =>
+ (_emscripten_stack_set_limits = wasmExports["Ud"])(a0, a1);
+ var stackSave = () => (stackSave = wasmExports["Vd"])();
+ var stackRestore = (a0) => (stackRestore = wasmExports["Wd"])(a0);
+ var stackAlloc = (a0) => (stackAlloc = wasmExports["Xd"])(a0);
+ var ___cxa_decrement_exception_refcount = (a0) =>
+ (___cxa_decrement_exception_refcount = wasmExports["Yd"])(a0);
+ var ___cxa_increment_exception_refcount = (a0) =>
+ (___cxa_increment_exception_refcount = wasmExports["Zd"])(a0);
+ var ___cxa_can_catch = (a0, a1, a2) =>
+ (___cxa_can_catch = wasmExports["_d"])(a0, a1, a2);
+ var ___cxa_is_pointer_type = (a0) =>
+ (___cxa_is_pointer_type = wasmExports["$d"])(a0);
+ var dynCall_iii = (Module["dynCall_iii"] = (a0, a1, a2) =>
+ (dynCall_iii = Module["dynCall_iii"] = wasmExports["ae"])(a0, a1, a2));
+ var dynCall_iiii = (Module["dynCall_iiii"] = (a0, a1, a2, a3) =>
+ (dynCall_iiii = Module["dynCall_iiii"] = wasmExports["be"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_vi = (Module["dynCall_vi"] = (a0, a1) =>
+ (dynCall_vi = Module["dynCall_vi"] = wasmExports["ce"])(a0, a1));
+ var dynCall_ii = (Module["dynCall_ii"] = (a0, a1) =>
+ (dynCall_ii = Module["dynCall_ii"] = wasmExports["de"])(a0, a1));
+ var dynCall_iiiiii = (Module["dynCall_iiiiii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iiiiii = Module["dynCall_iiiiii"] = wasmExports["ee"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_vii = (Module["dynCall_vii"] = (a0, a1, a2) =>
+ (dynCall_vii = Module["dynCall_vii"] = wasmExports["fe"])(a0, a1, a2));
+ var dynCall_i = (Module["dynCall_i"] = (a0) =>
+ (dynCall_i = Module["dynCall_i"] = wasmExports["ge"])(a0));
+ var dynCall_viiiii = (Module["dynCall_viiiii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_viiiii = Module["dynCall_viiiii"] = wasmExports["he"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_v = (Module["dynCall_v"] = (a0) =>
+ (dynCall_v = Module["dynCall_v"] = wasmExports["ie"])(a0));
+ var dynCall_viii = (Module["dynCall_viii"] = (a0, a1, a2, a3) =>
+ (dynCall_viii = Module["dynCall_viii"] = wasmExports["je"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_vid = (Module["dynCall_vid"] = (a0, a1, a2) =>
+ (dynCall_vid = Module["dynCall_vid"] = wasmExports["ke"])(a0, a1, a2));
+ var dynCall_di = (Module["dynCall_di"] = (a0, a1) =>
+ (dynCall_di = Module["dynCall_di"] = wasmExports["le"])(a0, a1));
+ var dynCall_iiiii = (Module["dynCall_iiiii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiiii = Module["dynCall_iiiii"] = wasmExports["me"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viiii = (Module["dynCall_viiii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viiii = Module["dynCall_viiii"] = wasmExports["ne"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viid = (Module["dynCall_viid"] = (a0, a1, a2, a3) =>
+ (dynCall_viid = Module["dynCall_viid"] = wasmExports["oe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_dii = (Module["dynCall_dii"] = (a0, a1, a2) =>
+ (dynCall_dii = Module["dynCall_dii"] = wasmExports["pe"])(a0, a1, a2));
+ var dynCall_viiid = (Module["dynCall_viiid"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viiid = Module["dynCall_viiid"] = wasmExports["qe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiid = (Module["dynCall_iiiid"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiiid = Module["dynCall_iiiid"] = wasmExports["re"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiiiiii = (Module["dynCall_iiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = wasmExports["se"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_viiiiii = (Module["dynCall_viiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_viiiiii = Module["dynCall_viiiiii"] = wasmExports["te"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_iiiiiii = (Module["dynCall_iiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = wasmExports["ue"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_diii = (Module["dynCall_diii"] = (a0, a1, a2, a3) =>
+ (dynCall_diii = Module["dynCall_diii"] = wasmExports["ve"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_j = (Module["dynCall_j"] = (a0) =>
+ (dynCall_j = Module["dynCall_j"] = wasmExports["we"])(a0));
+ var dynCall_iiid = (Module["dynCall_iiid"] = (a0, a1, a2, a3) =>
+ (dynCall_iiid = Module["dynCall_iiid"] = wasmExports["xe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iiiiid = (Module["dynCall_iiiiid"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iiiiid = Module["dynCall_iiiiid"] = wasmExports["ye"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_vd = (Module["dynCall_vd"] = (a0, a1) =>
+ (dynCall_vd = Module["dynCall_vd"] = wasmExports["ze"])(a0, a1));
+ var dynCall_iiiiiiiiiiii = (Module["dynCall_iiiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) =>
+ (dynCall_iiiiiiiiiiii = Module["dynCall_iiiiiiiiiiii"] =
+ wasmExports["Ae"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
+ var dynCall_iid = (Module["dynCall_iid"] = (a0, a1, a2) =>
+ (dynCall_iid = Module["dynCall_iid"] = wasmExports["Be"])(a0, a1, a2));
+ var dynCall_viidi = (Module["dynCall_viidi"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viidi = Module["dynCall_viidi"] = wasmExports["Ce"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iidiii = (Module["dynCall_iidiii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iidiii = Module["dynCall_iidiii"] = wasmExports["De"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iiiiiiiii = (Module["dynCall_iiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = wasmExports["Ee"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_iiiiiiiiii = (Module["dynCall_iiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = wasmExports["Fe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_iiidi = (Module["dynCall_iiidi"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiidi = Module["dynCall_iiidi"] = wasmExports["Ge"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_fiii = (Module["dynCall_fiii"] = (a0, a1, a2, a3) =>
+ (dynCall_fiii = Module["dynCall_fiii"] = wasmExports["He"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iiifi = (Module["dynCall_iiifi"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiifi = Module["dynCall_iiifi"] = wasmExports["Ie"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viif = (Module["dynCall_viif"] = (a0, a1, a2, a3) =>
+ (dynCall_viif = Module["dynCall_viif"] = wasmExports["Je"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iiffi = (Module["dynCall_iiffi"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiffi = Module["dynCall_iiffi"] = wasmExports["Ke"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_fif = (Module["dynCall_fif"] = (a0, a1, a2) =>
+ (dynCall_fif = Module["dynCall_fif"] = wasmExports["Le"])(a0, a1, a2));
+ var dynCall_iif = (Module["dynCall_iif"] = (a0, a1, a2) =>
+ (dynCall_iif = Module["dynCall_iif"] = wasmExports["Me"])(a0, a1, a2));
+ var dynCall_dif = (Module["dynCall_dif"] = (a0, a1, a2) =>
+ (dynCall_dif = Module["dynCall_dif"] = wasmExports["Ne"])(a0, a1, a2));
+ var dynCall_viiiiiii = (Module["dynCall_viiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = wasmExports["Oe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_viiiiiiii = (Module["dynCall_viiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = wasmExports["Pe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_iidii = (Module["dynCall_iidii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iidii = Module["dynCall_iidii"] = wasmExports["Qe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viiidiiiii = (Module["dynCall_viiidiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_viiidiiiii = Module["dynCall_viiidiiiii"] = wasmExports["Re"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_viiiidi = (Module["dynCall_viiiidi"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_viiiidi = Module["dynCall_viiiidi"] = wasmExports["Se"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_viiidii = (Module["dynCall_viiidii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_viiidii = Module["dynCall_viiidii"] = wasmExports["Te"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_viiiid = (Module["dynCall_viiiid"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_viiiid = Module["dynCall_viiiid"] = wasmExports["Ue"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iiiidiii = (Module["dynCall_iiiidiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iiiidiii = Module["dynCall_iiiidiii"] = wasmExports["Ve"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_iiiiidiiii = (Module["dynCall_iiiiidiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_iiiiidiiii = Module["dynCall_iiiiidiiii"] = wasmExports["We"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_viiiiid = (Module["dynCall_viiiiid"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_viiiiid = Module["dynCall_viiiiid"] = wasmExports["Xe"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_viiiiidi = (Module["dynCall_viiiiidi"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_viiiiidi = Module["dynCall_viiiiidi"] = wasmExports["Ye"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_viiiddddi = (Module["dynCall_viiiddddi"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_viiiddddi = Module["dynCall_viiiddddi"] = wasmExports["Ze"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_viiddi = (Module["dynCall_viiddi"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_viiddi = Module["dynCall_viiddi"] = wasmExports["_e"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_vidddi = (Module["dynCall_vidddi"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_vidddi = Module["dynCall_vidddi"] = wasmExports["$e"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_viiddddi = (Module["dynCall_viiddddi"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_viiddddi = Module["dynCall_viiddddi"] = wasmExports["af"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_fid = (Module["dynCall_fid"] = (a0, a1, a2) =>
+ (dynCall_fid = Module["dynCall_fid"] = wasmExports["bf"])(a0, a1, a2));
+ var dynCall_iiiiiid = (Module["dynCall_iiiiiid"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiiiiid = Module["dynCall_iiiiiid"] = wasmExports["cf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_vif = (Module["dynCall_vif"] = (a0, a1, a2) =>
+ (dynCall_vif = Module["dynCall_vif"] = wasmExports["df"])(a0, a1, a2));
+ var dynCall_viiidi = (Module["dynCall_viiidi"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_viiidi = Module["dynCall_viiidi"] = wasmExports["ef"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_viddi = (Module["dynCall_viddi"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viddi = Module["dynCall_viddi"] = wasmExports["ff"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viiiiiiid = (Module["dynCall_viiiiiiid"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_viiiiiiid = Module["dynCall_viiiiiiid"] = wasmExports["gf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_jiij = (Module["dynCall_jiij"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_jiij = Module["dynCall_jiij"] = wasmExports["hf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_ji = (Module["dynCall_ji"] = (a0, a1) =>
+ (dynCall_ji = Module["dynCall_ji"] = wasmExports["jf"])(a0, a1));
+ var dynCall_iiiifffffiiff = (Module["dynCall_iiiifffffiiff"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ ) =>
+ (dynCall_iiiifffffiiff = Module["dynCall_iiiifffffiiff"] =
+ wasmExports["kf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ ));
+ var dynCall_jif = (Module["dynCall_jif"] = (a0, a1, a2) =>
+ (dynCall_jif = Module["dynCall_jif"] = wasmExports["lf"])(a0, a1, a2));
+ var dynCall_vifii = (Module["dynCall_vifii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_vifii = Module["dynCall_vifii"] = wasmExports["mf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_vfiiii = (Module["dynCall_vfiiii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_vfiiii = Module["dynCall_vfiiii"] = wasmExports["nf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_ifii = (Module["dynCall_ifii"] = (a0, a1, a2, a3) =>
+ (dynCall_ifii = Module["dynCall_ifii"] = wasmExports["of"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_jiiijji = (Module["dynCall_jiiijji"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_jiiijji = Module["dynCall_jiiijji"] = wasmExports["pf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_viiif = (Module["dynCall_viiif"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viiif = Module["dynCall_viiif"] = wasmExports["qf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiiiiiiiiiiiiiiiiii = (Module["dynCall_iiiiiiiiiiiiiiiiiiii"] =
+ (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ a16,
+ a17,
+ a18,
+ a19,
+ ) =>
+ (dynCall_iiiiiiiiiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiiiiiiiiii"] =
+ wasmExports["rf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ a16,
+ a17,
+ a18,
+ a19,
+ ));
+ var dynCall_viiiiiiiiii = (Module["dynCall_viiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) =>
+ (dynCall_viiiiiiiiii = Module["dynCall_viiiiiiiiii"] = wasmExports["sf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ));
+ var dynCall_viiiiiiiii = (Module["dynCall_viiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = wasmExports["tf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_iiiiiiiiiiiii = (Module["dynCall_iiiiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ ) =>
+ (dynCall_iiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiii"] =
+ wasmExports["uf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ ));
+ var dynCall_ff = (Module["dynCall_ff"] = (a0, a1) =>
+ (dynCall_ff = Module["dynCall_ff"] = wasmExports["vf"])(a0, a1));
+ var dynCall_fff = (Module["dynCall_fff"] = (a0, a1, a2) =>
+ (dynCall_fff = Module["dynCall_fff"] = wasmExports["wf"])(a0, a1, a2));
+ var dynCall_iiijiii = (Module["dynCall_iiijiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iiijiii = Module["dynCall_iiijiii"] = wasmExports["xf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_jii = (Module["dynCall_jii"] = (a0, a1, a2) =>
+ (dynCall_jii = Module["dynCall_jii"] = wasmExports["yf"])(a0, a1, a2));
+ var dynCall_iiij = (Module["dynCall_iiij"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiij = Module["dynCall_iiij"] = wasmExports["zf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiji = (Module["dynCall_iiiji"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iiiji = Module["dynCall_iiiji"] = wasmExports["Af"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iiiiiiiiiiiiii = (Module["dynCall_iiiiiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ ) =>
+ (dynCall_iiiiiiiiiiiiii = Module["dynCall_iiiiiiiiiiiiii"] =
+ wasmExports["Bf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ ));
+ var dynCall_iiddddddiiii = (Module["dynCall_iiddddddiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) =>
+ (dynCall_iiddddddiiii = Module["dynCall_iiddddddiiii"] =
+ wasmExports["Cf"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
+ var dynCall_iidiiiii = (Module["dynCall_iidiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iidiiiii = Module["dynCall_iidiiiii"] = wasmExports["Df"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_iddiii = (Module["dynCall_iddiii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iddiii = Module["dynCall_iddiii"] = wasmExports["Ef"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iddii = (Module["dynCall_iddii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iddii = Module["dynCall_iddii"] = wasmExports["Ff"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_idddiii = (Module["dynCall_idddiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_idddiii = Module["dynCall_idddiii"] = wasmExports["Gf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_idddii = (Module["dynCall_idddii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_idddii = Module["dynCall_idddii"] = wasmExports["Hf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_idii = (Module["dynCall_idii"] = (a0, a1, a2, a3) =>
+ (dynCall_idii = Module["dynCall_idii"] = wasmExports["If"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_idi = (Module["dynCall_idi"] = (a0, a1, a2) =>
+ (dynCall_idi = Module["dynCall_idi"] = wasmExports["Jf"])(a0, a1, a2));
+ var dynCall_fiiid = (Module["dynCall_fiiid"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_fiiid = Module["dynCall_fiiid"] = wasmExports["Kf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iidi = (Module["dynCall_iidi"] = (a0, a1, a2, a3) =>
+ (dynCall_iidi = Module["dynCall_iidi"] = wasmExports["Lf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iiiidii = (Module["dynCall_iiiidii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiiidii = Module["dynCall_iiiidii"] = wasmExports["Mf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_iiiidiiiiii = (Module["dynCall_iiiidiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) =>
+ (dynCall_iiiidiiiiii = Module["dynCall_iiiidiiiiii"] = wasmExports["Nf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ));
+ var dynCall_iiidiiiii = (Module["dynCall_iiidiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_iiidiiiii = Module["dynCall_iiidiiiii"] = wasmExports["Of"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_iiidiiidiiiidiif = (Module["dynCall_iiidiiidiiiidiif"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ ) =>
+ (dynCall_iiidiiidiiiidiif = Module["dynCall_iiidiiidiiiidiif"] =
+ wasmExports["Pf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ ));
+ var dynCall_dddd = (Module["dynCall_dddd"] = (a0, a1, a2, a3) =>
+ (dynCall_dddd = Module["dynCall_dddd"] = wasmExports["Qf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iidiiii = (Module["dynCall_iidiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iidiiii = Module["dynCall_iidiiii"] = wasmExports["Rf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_iiiddii = (Module["dynCall_iiiddii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiiddii = Module["dynCall_iiiddii"] = wasmExports["Sf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_iiiiiiiidi = (Module["dynCall_iiiiiiiidi"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_iiiiiiiidi = Module["dynCall_iiiiiiiidi"] = wasmExports["Tf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_iiiddi = (Module["dynCall_iiiddi"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iiiddi = Module["dynCall_iiiddi"] = wasmExports["Uf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iiidd = (Module["dynCall_iiidd"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiidd = Module["dynCall_iiidd"] = wasmExports["Vf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiif = (Module["dynCall_iiiif"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiiif = Module["dynCall_iiiif"] = wasmExports["Wf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_fi = (Module["dynCall_fi"] = (a0, a1) =>
+ (dynCall_fi = Module["dynCall_fi"] = wasmExports["Xf"])(a0, a1));
+ var dynCall_did = (Module["dynCall_did"] = (a0, a1, a2) =>
+ (dynCall_did = Module["dynCall_did"] = wasmExports["Yf"])(a0, a1, a2));
+ var dynCall_iiidii = (Module["dynCall_iiidii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iiidii = Module["dynCall_iiidii"] = wasmExports["Zf"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iiidddii = (Module["dynCall_iiidddii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iiidddii = Module["dynCall_iiidddii"] = wasmExports["_f"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_didii = (Module["dynCall_didii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_didii = Module["dynCall_didii"] = wasmExports["$f"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiiiiidddi = (Module["dynCall_iiiiiiidddi"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) =>
+ (dynCall_iiiiiiidddi = Module["dynCall_iiiiiiidddi"] = wasmExports["ag"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ));
+ var dynCall_iidd = (Module["dynCall_iidd"] = (a0, a1, a2, a3) =>
+ (dynCall_iidd = Module["dynCall_iidd"] = wasmExports["bg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_viij = (Module["dynCall_viij"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viij = Module["dynCall_viij"] = wasmExports["cg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viji = (Module["dynCall_viji"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_viji = Module["dynCall_viji"] = wasmExports["dg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_vijii = (Module["dynCall_vijii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_vijii = Module["dynCall_vijii"] = wasmExports["eg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_iiijj = (Module["dynCall_iiijj"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiijj = Module["dynCall_iiijj"] = wasmExports["fg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_iiijji = (Module["dynCall_iiijji"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iiijji = Module["dynCall_iiijji"] = wasmExports["gg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_vij = (Module["dynCall_vij"] = (a0, a1, a2, a3) =>
+ (dynCall_vij = Module["dynCall_vij"] = wasmExports["hg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_vijji = (Module["dynCall_vijji"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_vijji = Module["dynCall_vijji"] = wasmExports["ig"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_viiji = (Module["dynCall_viiji"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_viiji = Module["dynCall_viiji"] = wasmExports["jg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_jiii = (Module["dynCall_jiii"] = (a0, a1, a2, a3) =>
+ (dynCall_jiii = Module["dynCall_jiii"] = wasmExports["kg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iiiiddd = (Module["dynCall_iiiiddd"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiiiddd = Module["dynCall_iiiiddd"] = wasmExports["lg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_vidii = (Module["dynCall_vidii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_vidii = Module["dynCall_vidii"] = wasmExports["mg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_vidiiii = (Module["dynCall_vidiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_vidiiii = Module["dynCall_vidiiii"] = wasmExports["ng"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_vidiii = (Module["dynCall_vidiii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_vidiii = Module["dynCall_vidiii"] = wasmExports["og"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_dj = (Module["dynCall_dj"] = (a0, a1, a2) =>
+ (dynCall_dj = Module["dynCall_dj"] = wasmExports["pg"])(a0, a1, a2));
+ var dynCall_vdiii = (Module["dynCall_vdiii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_vdiii = Module["dynCall_vdiii"] = wasmExports["qg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_idiiiiii = (Module["dynCall_idiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_idiiiiii = Module["dynCall_idiiiiii"] = wasmExports["rg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_idiiiiiii = (Module["dynCall_idiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_idiiiiiii = Module["dynCall_idiiiiiii"] = wasmExports["sg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_iiiidiiii = (Module["dynCall_iiiidiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_iiiidiiii = Module["dynCall_iiiidiiii"] = wasmExports["tg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_viiiidiiiiii = (Module["dynCall_viiiidiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) =>
+ (dynCall_viiiidiiiiii = Module["dynCall_viiiidiiiiii"] =
+ wasmExports["ug"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
+ var dynCall_iiiff = (Module["dynCall_iiiff"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_iiiff = Module["dynCall_iiiff"] = wasmExports["vg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viiiiiiiiiii = (Module["dynCall_viiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) =>
+ (dynCall_viiiiiiiiiii = Module["dynCall_viiiiiiiiiii"] =
+ wasmExports["wg"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
+ var dynCall_iij = (Module["dynCall_iij"] = (a0, a1, a2, a3) =>
+ (dynCall_iij = Module["dynCall_iij"] = wasmExports["xg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_vidi = (Module["dynCall_vidi"] = (a0, a1, a2, a3) =>
+ (dynCall_vidi = Module["dynCall_vidi"] = wasmExports["yg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_fii = (Module["dynCall_fii"] = (a0, a1, a2) =>
+ (dynCall_fii = Module["dynCall_fii"] = wasmExports["zg"])(a0, a1, a2));
+ var dynCall_viiiiiiiiiiiii = (Module["dynCall_viiiiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ ) =>
+ (dynCall_viiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiii"] =
+ wasmExports["Ag"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ ));
+ var dynCall_iiiiiiiiiii = (Module["dynCall_iiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) =>
+ (dynCall_iiiiiiiiiii = Module["dynCall_iiiiiiiiiii"] = wasmExports["Bg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ));
+ var dynCall_viidii = (Module["dynCall_viidii"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_viidii = Module["dynCall_viidii"] = wasmExports["Cg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_viiiijii = (Module["dynCall_viiiijii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_viiiijii = Module["dynCall_viiiijii"] = wasmExports["Dg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_viiijjii = (Module["dynCall_viiijjii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_viiijjii = Module["dynCall_viiijjii"] = wasmExports["Eg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_iiiijjii = (Module["dynCall_iiiijjii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_iiiijjii = Module["dynCall_iiiijjii"] = wasmExports["Fg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var dynCall_viiijii = (Module["dynCall_viiijii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_viiijii = Module["dynCall_viiijii"] = wasmExports["Gg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_iiiijii = (Module["dynCall_iiiijii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ) =>
+ (dynCall_iiiijii = Module["dynCall_iiiijii"] = wasmExports["Hg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ ));
+ var dynCall_ddiiiii = (Module["dynCall_ddiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_ddiiiii = Module["dynCall_ddiiiii"] = wasmExports["Ig"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_iifi = (Module["dynCall_iifi"] = (a0, a1, a2, a3) =>
+ (dynCall_iifi = Module["dynCall_iifi"] = wasmExports["Jg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ ));
+ var dynCall_iiiij = (Module["dynCall_iiiij"] = (a0, a1, a2, a3, a4, a5) =>
+ (dynCall_iiiij = Module["dynCall_iiiij"] = wasmExports["Kg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ ));
+ var dynCall_jiji = (Module["dynCall_jiji"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_jiji = Module["dynCall_jiji"] = wasmExports["Lg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_iiiiij = (Module["dynCall_iiiiij"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_iiiiij = Module["dynCall_iiiiij"] = wasmExports["Mg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_viijii = (Module["dynCall_viijii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ) =>
+ (dynCall_viijii = Module["dynCall_viijii"] = wasmExports["Ng"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ ));
+ var dynCall_jiiii = (Module["dynCall_jiiii"] = (a0, a1, a2, a3, a4) =>
+ (dynCall_jiiii = Module["dynCall_jiiii"] = wasmExports["Og"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ ));
+ var dynCall_viiiiiiiiiiiiiii = (Module["dynCall_viiiiiiiiiiiiiii"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ ) =>
+ (dynCall_viiiiiiiiiiiiiii = Module["dynCall_viiiiiiiiiiiiiii"] =
+ wasmExports["Pg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ ));
+ var dynCall_iiiiijj = (Module["dynCall_iiiiijj"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ) =>
+ (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = wasmExports["Qg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ ));
+ var dynCall_iiiiiijj = (Module["dynCall_iiiiiijj"] = (
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ) =>
+ (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = wasmExports["Rg"])(
+ a0,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ ));
+ var _asyncify_start_unwind = (a0) =>
+ (_asyncify_start_unwind = wasmExports["Sg"])(a0);
+ var _asyncify_stop_unwind = () =>
+ (_asyncify_stop_unwind = wasmExports["Tg"])();
+ var _asyncify_start_rewind = (a0) =>
+ (_asyncify_start_rewind = wasmExports["Ug"])(a0);
+ var _asyncify_stop_rewind = () =>
+ (_asyncify_stop_rewind = wasmExports["Vg"])();
+ var ___start_em_js = (Module["___start_em_js"] = 3895468);
+ var ___stop_em_js = (Module["___stop_em_js"] = 3896792);
+ function invoke_iii(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_iii(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vi(index, a1) {
+ var sp = stackSave();
+ try {
+ dynCall_vi(index, a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_ii(index, a1) {
+ var sp = stackSave();
+ try {
+ return dynCall_ii(index, a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vii(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ dynCall_vii(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_i(index) {
+ var sp = stackSave();
+ try {
+ return dynCall_i(index);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ dynCall_viii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viiii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_v(index) {
+ var sp = stackSave();
+ try {
+ dynCall_v(index);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vid(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ dynCall_vid(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiidi(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiidi(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiidi(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_viiidi(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viid(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ dynCall_viid(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viidi(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viidi(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiid(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiid(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_di(index, a1) {
+ var sp = stackSave();
+ try {
+ return dynCall_di(index, a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iid(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_iid(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_dii(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_dii(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiid(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiid(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vd(index, a1) {
+ var sp = stackSave();
+ try {
+ dynCall_vd(index, a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iif(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_iif(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iidiii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iidiii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiid(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viiid(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiid(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiid(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_fiii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_fiii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiifi(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiifi(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiffi(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiffi(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viif(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ dynCall_viif(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_diii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_diii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iidii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iidii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_dif(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_dif(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiid(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiid(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiidi(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiidi(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiidiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiidiii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiidi(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiidi(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiidiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiidiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiidii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ dynCall_viiidii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiid(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiid(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiidiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ dynCall_viiidiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vidi(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ dynCall_vidi(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiddddi(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiddddi(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiddi(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_viiddi(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vidddi(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_vidddi(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiddddi(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ dynCall_viiddddi(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_fid(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_fid(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiid(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiid(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vif(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ dynCall_vif(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viddi(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viddi(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiiid(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiiid(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiifffffiiff(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiifffffiiff(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_fif(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_fif(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vifii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_vifii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vfiiii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_vfiiii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_ifii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_ifii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ ) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiif(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viiif(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_fi(index, a1) {
+ var sp = stackSave();
+ try {
+ return dynCall_fi(index, a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiiiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ a16,
+ a17,
+ a18,
+ a19,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiiiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ a16,
+ a17,
+ a18,
+ a19,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiddddddiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiddddddiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iidiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_iidiiiii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiddii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiddii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iddiii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iddiii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iddii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iddii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_idddiii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_idddiii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_idddii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_idddii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_idii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_idii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_idi(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_idi(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_fiiid(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_fiiid(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiidiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiidiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iidi(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_iidi(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiidii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiidii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiidiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiidiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiidiiidiiiidiif(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiidiiidiiiidiif(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ a14,
+ a15,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_dddd(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_dddd(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iidiiii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iidiiii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiidi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiidi(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiddi(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiddi(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiidd(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiidd(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_did(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_did(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiidii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiidii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiidddii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiidddii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_didii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_didii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiidddi(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiidddi(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iidd(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_iidd(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiddd(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiddd(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vidii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_vidii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vidiiii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ dynCall_vidiiii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vidiii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_vidiii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vdiii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_vdiii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiidiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiidiiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_idiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_idiiiiii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_idiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ return dynCall_idiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiidiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ ) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiidiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiff(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiff(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_fii(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_fii(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ ) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ a11,
+ a12,
+ a13,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ ) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiiiiiiii(
+ index,
+ a1,
+ a2,
+ a3,
+ a4,
+ a5,
+ a6,
+ a7,
+ a8,
+ a9,
+ a10,
+ );
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viidii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_viidii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_ddiiiii(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_ddiiiii(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iifi(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_iifi(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_j(index) {
+ var sp = stackSave();
+ try {
+ return dynCall_j(index);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_jiii(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_jiii(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_jiij(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_jiij(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_ji(index, a1) {
+ var sp = stackSave();
+ try {
+ return dynCall_ji(index, a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viij(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viij(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viji(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ dynCall_viji(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vijii(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_vijii(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiijj(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiijj(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiijji(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiijji(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vij(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ dynCall_vij(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_jii(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_jii(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_vijji(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ dynCall_vijji(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiji(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ dynCall_viiji(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_dj(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ return dynCall_dj(index, a1, a2);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iij(index, a1, a2, a3) {
+ var sp = stackSave();
+ try {
+ return dynCall_iij(index, a1, a2, a3);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
+ var sp = stackSave();
+ try {
+ dynCall_viiiijii(index, a1, a2, a3, a4, a5, a6, a7, a8);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ dynCall_viiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiijjii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_viiijii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ dynCall_viiijii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiijii(index, a1, a2, a3, a4, a5, a6, a7) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiijii(index, a1, a2, a3, a4, a5, a6, a7);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiij(index, a1, a2, a3, a4, a5) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiij(index, a1, a2, a3, a4, a5);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_iiiiij(index, a1, a2, a3, a4, a5, a6) {
+ var sp = stackSave();
+ try {
+ return dynCall_iiiiij(index, a1, a2, a3, a4, a5, a6);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function invoke_jiiii(index, a1, a2, a3, a4) {
+ var sp = stackSave();
+ try {
+ return dynCall_jiiii(index, a1, a2, a3, a4);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+ }
+ function applySignatureConversions(wasmExports) {
+ wasmExports = Object.assign({}, wasmExports);
+ var makeWrapper_p = (f) => () => f() >>> 0;
+ var makeWrapper_pp = (f) => (a0) => f(a0) >>> 0;
+ var makeWrapper_ppp = (f) => (a0, a1) => f(a0, a1) >>> 0;
+ wasmExports["Cd"] = makeWrapper_p(wasmExports["Cd"]);
+ wasmExports["Fd"] = makeWrapper_pp(wasmExports["Fd"]);
+ wasmExports["Gd"] = makeWrapper_p(wasmExports["Gd"]);
+ wasmExports["Id"] = makeWrapper_ppp(wasmExports["Id"]);
+ wasmExports["Jd"] = makeWrapper_pp(wasmExports["Jd"]);
+ wasmExports["Vd"] = makeWrapper_p(wasmExports["Vd"]);
+ wasmExports["Xd"] = makeWrapper_pp(wasmExports["Xd"]);
+ return wasmExports;
+ }
+ Module["addRunDependency"] = addRunDependency;
+ Module["removeRunDependency"] = removeRunDependency;
+ Module["FS_createPath"] = FS.createPath;
+ Module["FS_createLazyFile"] = FS.createLazyFile;
+ Module["FS_createDevice"] = FS.createDevice;
+ Module["wasmMemory"] = wasmMemory;
+ Module["keepRuntimeAlive"] = keepRuntimeAlive;
+ Module["ExitStatus"] = ExitStatus;
+ Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
+ Module["FS_createDataFile"] = FS.createDataFile;
+ Module["FS_unlink"] = FS.unlink;
+ Module["PThread"] = PThread;
+ Module["FS_readdir"]=FS.readdir;
+ Module["FS_analyzePath"]=FS.analyzePath;
+ var calledRun;
+ dependenciesFulfilled = function runCaller() {
+ if (!calledRun) run();
+ if (!calledRun) dependenciesFulfilled = runCaller;
+ };
+ function run() {
+ if (runDependencies > 0) {
+ return;
+ }
+ if (ENVIRONMENT_IS_PTHREAD) {
+ readyPromiseResolve(Module);
+ initRuntime();
+ startWorker(Module);
+ return;
+ }
+ preRun();
+ if (runDependencies > 0) {
+ return;
+ }
+ function doRun() {
+ if (calledRun) return;
+ calledRun = true;
+ Module["calledRun"] = true;
+ if (ABORT) return;
+ initRuntime();
+ readyPromiseResolve(Module);
+ if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
+ postRun();
+ }
+ if (Module["setStatus"]) {
+ Module["setStatus"]("Running...");
+ setTimeout(function () {
+ setTimeout(function () {
+ Module["setStatus"]("");
+ }, 1);
+ doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+ }
+ if (Module["preInit"]) {
+ if (typeof Module["preInit"] == "function")
+ Module["preInit"] = [Module["preInit"]];
+ while (Module["preInit"].length > 0) {
+ Module["preInit"].pop()();
+ }
+ }
+ run();
+
+ return moduleArg.ready;
+ };
+})();
+if (typeof exports === "object" && typeof module === "object")
+ module.exports = getUsdModule;
+else if (typeof define === "function" && define["amd"])
+ define([], () => getUsdModule);
+
+globalThis["NEEDLE:USD:GET"] = getUsdModule;
\ No newline at end of file
diff --git a/web/threeVisualizer/assets/emHdBindings-D9OMRJgz.data b/web/threeVisualizer/assets/emHdBindings-D9OMRJgz.data
new file mode 100644
index 0000000..168e611
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings-D9OMRJgz.data
@@ -0,0 +1,19331 @@
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "ArResolver": {},
+ "ArDefaultResolver": {
+ "bases": [
+ "ArResolver"
+ ],
+ "implementsContexts": true
+ },
+ "ArPackageResolver": {}
+ }
+ },
+ "LibraryPath": "",
+ "Name": "ar",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+//
+// Copyright 2023 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+////////////////////////////////////////////////////////////////////////
+
+/* ************************************************************************** */
+/* ** ** */
+/* ** This file is generated by a script. ** */
+/* ** ** */
+/* ** Do not edit it directly (unless it is within a CUSTOM CODE section)! ** */
+/* ** Edit hdSchemaDefs.py instead to make changes. ** */
+/* ** ** */
+/* ************************************************************************** */
+
+#include "{{ INCLUDE_PATH }}/{{ FILE_NAME }}.h"
+
+#include "pxr/imaging/hd/retainedDataSource.h"
+
+{%- if IMPL_SCHEMA_INCLUDES is defined -%}
+{%- for t in IMPL_SCHEMA_INCLUDES %}
+#include "{{ t | expand }}.h"
+{%- endfor -%}
+{%- endif %}
+
+#include "pxr/base/trace/trace.h"
+
+// --(BEGIN CUSTOM CODE: Includes)--
+{%- if 'Includes' in CUSTOM_CODE_IMPL %}
+{{ CUSTOM_CODE_IMPL['Includes'] }}
+{%- endif %}
+// --(END CUSTOM CODE: Includes)--
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+TF_DEFINE_PUBLIC_TOKENS({{SCHEMA_CLASS_NAME}}Tokens,
+ {{ SCHEMA_CLASS_NAME|snake }}_TOKENS);
+
+// --(BEGIN CUSTOM CODE: Schema Methods)--
+{%- if 'Schema Methods' in CUSTOM_CODE_IMPL %}
+{{ CUSTOM_CODE_IMPL['Schema Methods'] }}
+{%- endif %}
+// --(END CUSTOM CODE: Schema Methods)--
+
+{%- if GENERIC_MEMBER is defined -%}
+{%- set name, type_name, opt_dict = GENERIC_MEMBER -%}
+{%- if opt_dict.get('GETTER', True) %}
+
+TfTokenVector
+{{ SCHEMA_CLASS_NAME }}::Get{{ name | capitalizeFirst }}Names()
+{%- if VERSION_GUARD_CONST_GETTER %}
+#if HD_API_VERSION >= 66
+ const
+#else
+
+#endif
+{% else %} const
+{% endif -%} {#- if VERSION_GUARD_CONST_GETTER -#}
+{
+ if (_container) {
+ return _container->GetNames();
+ } else {
+ return {};
+ }
+}
+
+{{ type_name}}{% if not type_name.endswith('Schema') %}Handle{% endif %}
+{{ SCHEMA_CLASS_NAME }}::Get{{ name | capitalizeFirst }}(const TfToken &name)
+{%- if VERSION_GUARD_CONST_GETTER %}
+#if HD_API_VERSION >= 66
+ const
+#else
+
+#endif
+{% else %} const
+{% endif -%} {#- if VERSION_GUARD_CONST_GETTER -#}
+{
+ {%- if type_name.endswith('Schema') %}
+ return {{type_name}}(
+ _GetTypedDataSource<{{ type_name | underlyingDataSource}}>(name));
+ {%- else %}
+ return _GetTypedDataSource<{{ type_name | underlyingDataSource}}>(name);
+ {%- endif %}
+}
+{%- endif -%} {# if opt_dict.get('GETTER', True) #}
+{%- endif -%} {# if GENERIC_MEMBER is defiend #}
+
+{%- if MEMBERS is defined -%}
+{%- for name, type_name, opt_dict in MEMBERS -%}
+{%- if opt_dict.get('GETTER', True) %}
+
+{{ type_name}}{% if not type_name.endswith('Schema') %}Handle{% endif %}
+{{ SCHEMA_CLASS_NAME }}::Get{{ name|capitalizeFirst }}()
+{%- if VERSION_GUARD_CONST_GETTER %}
+#if HD_API_VERSION >= 66
+ const
+#else
+
+#endif
+{% else %} const
+{% endif -%} {#- if VERSION_GUARD_CONST_GETTER -#}
+{
+ return {% if type_name.endswith('Schema') %}{{ type_name }}({% endif %}_GetTypedDataSource<{{type_name | underlyingDataSource}}>(
+ {{SCHEMA_CLASS_NAME}}Tokens->{{ name }}){% if type_name.endswith('Schema') %}){% endif %};
+}
+{%- endif -%} {# if opt_dict.get('GETTER', True) #}
+{%- endfor -%}
+{%- endif -%} {# if MEMBERS is defined #}
+
+{%- if GENERIC_MEMBER is defined %}
+
+/*static*/
+HdContainerDataSourceHandle
+{{SCHEMA_CLASS_NAME}}::BuildRetained(
+ const size_t count,
+ const TfToken * const names,
+ const HdDataSourceBaseHandle * const values)
+{
+ return HdRetainedContainerDataSource::New(count, names, values);
+}
+{%- else -%}
+{%- if MEMBERS %}
+
+/*static*/
+HdContainerDataSourceHandle
+{{ SCHEMA_CLASS_NAME }}::BuildRetained(
+{%- for name, type_name, opt_dict in MEMBERS %}
+ const {{type_name | underlyingDataSource}}Handle &{{ name }}{%if loop.last == False %},{% endif -%}
+{%- endfor %}
+)
+{
+ TfToken _names[{{MEMBERS|length}}];
+ HdDataSourceBaseHandle _values[{{MEMBERS|length}}];
+
+ size_t _count = 0;
+{%- for name, type_name, opt_dict in MEMBERS %}
+
+ if ({{name}}) {
+ _names[_count] = {{SCHEMA_CLASS_NAME}}Tokens->{{name}};
+ _values[_count++] = {{name}};
+ }
+{%- endfor %}
+ return HdRetainedContainerDataSource::New(_count, _names, _values);
+}
+
+{%- for name, type_name, opt_dict in MEMBERS %}
+
+{{ SCHEMA_CLASS_NAME }}::Builder &
+{{ SCHEMA_CLASS_NAME }}::Builder::Set{{ name|capitalizeFirst }}(
+ const {{ type_name | underlyingDataSource}}Handle &{{name}})
+{
+ _{{name}} = {{name}};
+ return *this;
+}
+{%- endfor %}
+
+HdContainerDataSourceHandle
+{{ SCHEMA_CLASS_NAME }}::Builder::Build()
+{
+ return {{ SCHEMA_CLASS_NAME }}::BuildRetained(
+{%- for name, type_name, opt_dict in MEMBERS %}
+ _{{ name }}{%if loop.last == False %},{% endif -%}
+{%- endfor %}
+ );
+}
+{%- endif -%} {# else of if MEMBERS #}
+{%- endif -%} {# else of if GENERIC_MEMBER is defined #}
+
+{%- if SCHEMA_TOKEN is defined %}
+
+/*static*/
+{{ SCHEMA_CLASS_NAME }}
+{{ SCHEMA_CLASS_NAME }}::GetFromParent(
+ const HdContainerDataSourceHandle &fromParentContainer)
+{
+ return {{ SCHEMA_CLASS_NAME }}(
+ fromParentContainer
+ ? HdContainerDataSource::Cast(fromParentContainer->Get(
+ {{SCHEMA_CLASS_NAME}}Tokens->{{SCHEMA_TOKEN}}))
+ : nullptr);
+}
+
+/*static*/
+const TfToken &
+{{ SCHEMA_CLASS_NAME }}::GetSchemaToken()
+{
+ return {{SCHEMA_CLASS_NAME}}Tokens->{{SCHEMA_TOKEN}};
+}
+{%- endif -%}
+
+{%- if ADD_DEFAULT_LOCATOR is defined %}
+
+/*static*/
+const HdDataSourceLocator &
+{{ SCHEMA_CLASS_NAME }}::GetDefaultLocator()
+{
+{%- if LOCATOR_PREFIX is defined %}
+ static const HdDataSourceLocator locator =
+ {{ LOCATOR_PREFIX }}.Append(GetSchemaToken());
+{%- else %}
+ static const HdDataSourceLocator locator(GetSchemaToken());
+{%- endif %}
+ return locator;
+}
+{%- endif -%}
+
+{%- if MEMBERS is defined -%}
+{%- for name, type_name, opt_dict in MEMBERS -%}
+{%- if opt_dict['ADD_LOCATOR'] %}
+
+/* static */
+const HdDataSourceLocator &
+{{ SCHEMA_CLASS_NAME }}::Get{{ name |capitalizeFirst }}Locator()
+{
+ static const HdDataSourceLocator locator =
+ GetDefaultLocator().Append(
+ {{SCHEMA_CLASS_NAME}}Tokens->{{name}});
+ return locator;
+}
+{%- endif -%} {# if opt_dict['ADD_LOCATOR'] #}
+{%- endfor -%}
+{%- endif -%} {# if MEMBERS is defined #}
+
+{%- if STATIC_LOCATOR_ACCESSORS is defined -%}
+{%- for name, tokens in STATIC_LOCATOR_ACCESSORS %}
+
+/*static*/
+const HdDataSourceLocator &
+{{ SCHEMA_CLASS_NAME }}::Get{{name|capitalizeFirst}}Locator()
+{
+ static const HdDataSourceLocator locator(
+ {%- for t in tokens -%}
+ {%if t is string %}{{SCHEMA_CLASS_NAME}}Tokens->{{ t }}{% else %}{{ t[0] }}SchemaTokens->{{ t[1] }}{% endif %}{%if loop.last == False %},{% endif -%}
+ {%- endfor %}
+ );
+ return locator;
+}
+{%- endfor -%}
+{%- endif -%} {# if STATIC_LOCATOR_ACCESSORS is defined #}
+
+{%- if STATIC_TOKEN_DATASOURCE_BUILDERS is defined -%}
+{%- for typeName, tokens in STATIC_TOKEN_DATASOURCE_BUILDERS %}
+
+/*static*/
+HdTokenDataSourceHandle
+{{ SCHEMA_CLASS_NAME }}::Build{{typeName|capitalizeFirst}}DataSource(
+ const TfToken &{{typeName}})
+{
+{% for token in tokens %}
+ if ({{typeName}} == {{SCHEMA_CLASS_NAME}}Tokens->{{ token | tokenName }}) {
+ static const HdRetainedTypedSampledDataSource::Handle ds =
+ HdRetainedTypedSampledDataSource::New({{typeName}});
+ return ds;
+ }
+{%- endfor %}
+ // fallback for unknown token
+ return HdRetainedTypedSampledDataSource::New({{typeName}});
+}
+{%- endfor -%}
+{%- endif %} {# if STATIC_TOKEN_DATASOURCE_BUILDERS is defined #}
+
+PXR_NAMESPACE_CLOSE_SCOPE
+//
+// Copyright 2023 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+////////////////////////////////////////////////////////////////////////
+
+/* ************************************************************************** */
+/* ** ** */
+/* ** This file is generated by a script. ** */
+/* ** ** */
+/* ** Do not edit it directly (unless it is within a CUSTOM CODE section)! ** */
+/* ** Edit hdSchemaDefs.py instead to make changes. ** */
+/* ** ** */
+/* ************************************************************************** */
+
+#ifndef {{ HEADER_GUARD|snake }}_{{ FILE_NAME|snake }}_H
+#define {{ HEADER_GUARD|snake }}_{{ FILE_NAME|snake }}_H
+
+/// \file
+
+#include "{{ INCLUDE_PATH }}/api.h"
+
+{%- if SCHEMA_INCLUDES is defined -%}
+{%- for t in SCHEMA_INCLUDES %}
+#include "{{ t | expand }}.h"
+{%- endfor -%}
+{%- endif %}
+
+#include "pxr/imaging/hd/schema.h"
+{%- if VERSION_GUARD_CONST_GETTER %}
+#include "pxr/imaging/hd/version.h"
+{%- endif %}
+
+// --(BEGIN CUSTOM CODE: Includes)--
+{%- if 'Includes' in CUSTOM_CODE_HEADER %}
+{{ CUSTOM_CODE_HEADER['Includes'] }}
+{%- endif %}
+// --(END CUSTOM CODE: Includes)--
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+// --(BEGIN CUSTOM CODE: Declares)--
+{%- if 'Declares' in CUSTOM_CODE_HEADER %}
+{{ CUSTOM_CODE_HEADER['Declares'] }}
+{%- endif %}
+// --(END CUSTOM CODE: Declares)--
+
+#define {{ SCHEMA_CLASS_NAME|snake }}_TOKENS \
+
+{%- if SCHEMA_TOKEN is defined %}
+ ({{SCHEMA_TOKEN}}) \
+{%- endif -%}
+
+{%- if MEMBERS is defined -%}
+{%- for name, type_name, opt_dict in MEMBERS -%}
+{%- if SCHEMA_TOKEN is not defined or name != SCHEMA_TOKEN %}
+ ({{name}}) \
+{%- endif -%}
+{%- endfor -%}
+{%- endif -%}
+
+{%- if EXTRA_TOKENS is defined -%}
+{%- for t in EXTRA_TOKENS %}
+ ({{t}}) \
+{%- endfor -%}
+{%- endif -%}
+
+{%- if STATIC_TOKEN_DATASOURCE_BUILDERS is defined -%}
+{%- for typeName, tokens in STATIC_TOKEN_DATASOURCE_BUILDERS -%}
+{%- for token in tokens %}
+ ({{token}}) \
+{%- endfor -%}
+{%- endfor -%}
+{%- endif %}
+
+TF_DECLARE_PUBLIC_TOKENS({{SCHEMA_CLASS_NAME}}Tokens, {{ LIBRARY_API }},
+ {{ SCHEMA_CLASS_NAME|snake }}_TOKENS);
+
+//-----------------------------------------------------------------------------
+
+{% if DOC is defined -%}
+{{ DOC | expand | makeComment }}
+{%- endif %}
+class {{ SCHEMA_CLASS_NAME }} : public HdSchema
+{
+public:
+ /// \name Schema retrieval
+ /// @{
+
+ {{ SCHEMA_CLASS_NAME }}(HdContainerDataSourceHandle container)
+ : HdSchema(container) {}
+
+{%- if SCHEMA_TOKEN is defined %}
+
+ /// Retrieves a container data source with the schema's default name token
+ /// "{{ SCHEMA_TOKEN }}" from the parent container and constructs a
+ /// {{SCHEMA_CLASS_NAME}} instance.
+ /// Because the requested container data source may not exist, the result
+ /// should be checked with IsDefined() or a bool comparison before use.
+ {{ LIBRARY_API }}
+ static {{ SCHEMA_CLASS_NAME }} GetFromParent(
+ const HdContainerDataSourceHandle &fromParentContainer);
+{%- endif %}
+
+ /// @}
+
+// --(BEGIN CUSTOM CODE: Schema Methods)--
+{%- if 'Schema Methods' in CUSTOM_CODE_HEADER %}
+{{ CUSTOM_CODE_HEADER['Schema Methods'] }}
+{%- endif %}
+// --(END CUSTOM CODE: Schema Methods)--
+
+ /// \name Member accessor
+ /// @{
+{%- if GENERIC_MEMBER is defined -%}
+{%- set name, type_name, opt_dict = GENERIC_MEMBER -%}
+{%- if opt_dict.get('GETTER', True) %}
+
+ {{ LIBRARY_API }}
+ TfTokenVector Get{{ name | capitalizeFirst }}Names()
+{%- if VERSION_GUARD_CONST_GETTER %}
+#if HD_API_VERSION >= 66
+ const;
+#else
+ ;
+#endif
+{% else %} const;
+{% endif -%} {# if VERSION_GUARD_CONST_GETTER #}
+
+{%- if 'DOC' in opt_dict -%}
+{%- for l in (opt_dict['DOC'].split()|join(' ')|wordwrap(width=70)).split('\n') %}
+ /// {{l}}
+{%- endfor -%}
+{%- endif %}
+ {{ LIBRARY_API }}
+ {{ type_name}}{% if not type_name.endswith('Schema') %}Handle{% endif %} Get{{ name|capitalizeFirst }}(const TfToken &name)
+{%- if VERSION_GUARD_CONST_GETTER %}
+#if HD_API_VERSION >= 66
+ const;
+#else
+ ;
+#endif
+{% else %} const;
+{%- endif -%} {# if VERSION_GUARD_CONST_GETTER #}
+{%- endif -%} {# if opt_dict.get('GETTER', True) #}
+{%- endif -%} {# if GENERIC_MEMBER is defined #}
+
+{%- if MEMBERS is defined -%}
+{%- for name, type_name, opt_dict in MEMBERS -%}
+{%- if opt_dict.get('GETTER', True) %}
+{% if 'DOC' in opt_dict -%}
+{%- for l in (opt_dict['DOC'].split()|join(' ')|wordwrap(width=70)).split('\n') %}
+ /// {{l}}
+{%- endfor -%}
+{%- endif %}
+ {{ LIBRARY_API }}
+ {{ type_name}}{% if not type_name.endswith('Schema') %}Handle{% endif %} Get{{ name|capitalizeFirst }}()
+{%- if VERSION_GUARD_CONST_GETTER %}
+#if HD_API_VERSION >= 66
+ const;
+#else
+ ;
+#endif
+{% else %} const;
+{%- endif -%} {# if VERSION_GUARD_CONST_GETTER #}
+{%- endif -%} {# if opt_dict.get('GETTER', True) #}
+{%- endfor -%}
+{%- endif %} {# if MEMBERS is defined #}
+
+ /// @}
+
+{%- if SCHEMA_TOKEN is defined %}
+
+ /// \name Schema location
+ /// @{
+
+ /// Returns a token where the container representing this schema is found in
+ /// a container by default.
+ {{ LIBRARY_API }}
+ static const TfToken &GetSchemaToken();
+
+{%- if ADD_DEFAULT_LOCATOR is defined %}
+
+ /// Returns an HdDataSourceLocator (relative to the prim-level data source)
+ /// where the container representing this schema is found by default.
+ {{ LIBRARY_API }}
+ static const HdDataSourceLocator &GetDefaultLocator();
+{%- endif %}
+
+ /// @}
+{%- endif -%}
+
+
+{%- if self.member_locators() | trim %}
+
+ /// \name Data source locators for members
+ ///
+ /// The following methods return an HdDataSourceLocator (relative to the
+ /// prim-level data source) where the data source for a member can be found.
+ ///
+ /// This is often useful for checking intersection against the
+ /// HdDataSourceLocatorSet sent with HdDataSourceObserver::PrimsDirtied.
+ /// @{
+
+{%- block member_locators -%}
+{%- if MEMBERS is defined -%}
+{%- for name, type_name, opt_dict in MEMBERS -%}
+{%- if opt_dict['ADD_LOCATOR'] %}
+
+ /// Prim-level relative data source locator to locate {{ name }}.
+ {{ LIBRARY_API }}
+ static const HdDataSourceLocator &Get{{ name |capitalizeFirst }}Locator();
+{%- endif -%}
+{%- endfor -%}
+{%- endif -%} {# if MEMBERS is defined #}
+
+{%- if STATIC_LOCATOR_ACCESSORS is defined -%}
+{%- for name, tokens in STATIC_LOCATOR_ACCESSORS %}
+
+ /// Additional prim-level relative data source locator to locate
+ /// {{ name }}.
+ {{ LIBRARY_API }}
+ static const HdDataSourceLocator &Get{{name | capitalizeFirst}}Locator();
+{%- endfor -%}
+{%- endif -%}
+{%- endblock member_locators %}
+ /// @}
+{%- endif %} {# if self.member_locators() | trim #}
+
+ /// \name Schema construction
+ /// @{
+
+{%- if GENERIC_MEMBER is defined %}
+ {{ LIBRARY_API }}
+ static HdContainerDataSourceHandle
+ BuildRetained(
+ size_t count,
+ const TfToken *names,
+ const HdDataSourceBaseHandle *values);
+{%- else -%}
+{%- if MEMBERS %}
+
+ /// \deprecated Use Builder instead.
+ ///
+ /// Builds a container data source which includes the provided child data
+ /// sources. Parameters with nullptr values are excluded. This is a
+ /// low-level interface. For cases in which it's desired to define
+ /// the container with a sparse set of child fields, the Builder class
+ /// is often more convenient and readable.
+ {{ LIBRARY_API }}
+ static HdContainerDataSourceHandle
+ BuildRetained(
+{%- for name, type_name, opt_dict in MEMBERS %}
+ const {{ type_name | underlyingDataSource }}Handle &{{ name }}{%if loop.last == False %},{% endif -%}
+{%- endfor %}
+ );
+
+ /// \class {{ SCHEMA_CLASS_NAME }}::Builder
+ ///
+ /// Utility class for setting sparse sets of child data source fields to be
+ /// filled as arguments into BuildRetained. Because all setter methods
+ /// return a reference to the instance, this can be used in the "builder
+ /// pattern" form.
+ class Builder
+ {
+ public:
+{%- for name, type_name, opt_dict in MEMBERS %}
+ {{ LIBRARY_API }}
+ Builder &Set{{ name|capitalizeFirst }}(
+ const {{ type_name | underlyingDataSource}}Handle &{{name}});
+{%- endfor %}
+
+ /// Returns a container data source containing the members set thus far.
+ {{ LIBRARY_API }}
+ HdContainerDataSourceHandle Build();
+
+ private:
+{%- for name, type_name, opt_dict in MEMBERS %}
+ {{ type_name | underlyingDataSource}}Handle _{{name}};
+{%- endfor %}
+
+ };
+{%- endif -%} {# else of if MEMBERS #}
+{%- endif -%} {# else of if GENERIC_MEMBER is defined #}
+
+{%- if STATIC_TOKEN_DATASOURCE_BUILDERS is defined -%}
+{%- for typeName, tokens in STATIC_TOKEN_DATASOURCE_BUILDERS %}
+
+ /// Returns token data source for use as {{typeName}} value.
+ ///
+ /// The following values will be stored statically and reused for future
+ /// calls:
+{%- for token in tokens %}
+ /// - {{SCHEMA_CLASS_NAME}}Tokens->{{ token | tokenName }}
+{%- endfor %}
+ {{ LIBRARY_API }}
+ static HdTokenDataSourceHandle Build{{typeName|capitalizeFirst}}DataSource(
+ const TfToken &{{typeName}});
+{%- endfor -%}
+{%- endif %}
+
+ /// @}
+};
+
+PXR_NAMESPACE_CLOSE_SCOPE
+
+#endif
+{
+ "Plugins": [
+ {
+ "Info": {},
+ "LibraryPath": "",
+ "Name": "hd",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "HttpResolver": {
+ "bases": ["ArDefaultResolver"]
+ }
+ }
+ },
+ "Name": "HttpResolver",
+ "LibraryPath": "",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "NdrDiscoveryPlugin": {},
+ "_NdrFilesystemDiscoveryPlugin" : {
+ "bases": ["NdrDiscoveryPlugin"],
+ "displayName": "Filesystem Discovery"
+ },
+ "NdrParserPlugin": {}
+ }
+ },
+ "LibraryPath": "",
+ "Name": "ndr",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+{
+ "Includes": [
+ "*/resources/"
+ ]
+}
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "payloadAssetDependencies": {
+ "appliesTo": "prims",
+ "displayGroup": "Pipeline",
+ "type": "asset[]"
+ }
+ },
+ "Types": {
+ "SdfFileFormat": {
+ "displayName": "Sdf file format base class",
+ "target": "sdf"
+ },
+ "SdfTextFileFormat": {
+ "bases": [
+ "SdfFileFormat"
+ ],
+ "displayName": "Sdf Text File Format",
+ "extensions": [
+ "sdf"
+ ],
+ "formatId": "sdf"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "sdf",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+//
+// Copyright 2017 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+#ifndef {{ Upper(libraryName) }}_API_H
+#define {{ Upper(libraryName) }}_API_H
+
+#include "pxr/base/arch/export.h"
+
+#if defined(PXR_STATIC)
+# define {{ Upper(libraryName) }}_API
+# define {{ Upper(libraryName) }}_API_TEMPLATE_CLASS(...)
+# define {{ Upper(libraryName) }}_API_TEMPLATE_STRUCT(...)
+# define {{ Upper(libraryName) }}_LOCAL
+#else
+# if defined({{ Upper(libraryName) }}_EXPORTS)
+# define {{ Upper(libraryName) }}_API ARCH_EXPORT
+# define {{ Upper(libraryName) }}_API_TEMPLATE_CLASS(...) ARCH_EXPORT_TEMPLATE(class, __VA_ARGS__)
+# define {{ Upper(libraryName) }}_API_TEMPLATE_STRUCT(...) ARCH_EXPORT_TEMPLATE(struct, __VA_ARGS__)
+# else
+# define {{ Upper(libraryName) }}_API ARCH_IMPORT
+# define {{ Upper(libraryName) }}_API_TEMPLATE_CLASS(...) ARCH_IMPORT_TEMPLATE(class, __VA_ARGS__)
+# define {{ Upper(libraryName) }}_API_TEMPLATE_STRUCT(...) ARCH_IMPORT_TEMPLATE(struct, __VA_ARGS__)
+# endif
+# define {{ Upper(libraryName) }}_LOCAL ARCH_HIDDEN
+#endif
+
+#endif
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ }
+ },
+ "LibraryPath": "@PLUG_INFO_LIBRARY_PATH@",
+ "Name": "{{ libraryName }}",
+ "ResourcePath": "@PLUG_INFO_RESOURCE_PATH@",
+ "Root": "@PLUG_INFO_ROOT@",
+ "Type": "library"
+ }
+ ]
+}
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+#include "{{ libraryPath }}/{{ cls.GetHeaderFile() }}"
+#include "pxr/usd/usd/schemaRegistry.h"
+#include "pxr/usd/usd/typed.h"
+
+#include "pxr/usd/sdf/types.h"
+#include "pxr/usd/sdf/assetPath.h"
+
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+#include "pxr/base/tf/staticTokens.h"
+
+{% endif %}
+{% if useExportAPI %}
+{{ namespaceOpen }}
+
+{% endif %}
+// Register the schema with the TfType system.
+TF_REGISTRY_FUNCTION(TfType)
+{
+ TfType::Define<{{ cls.cppClassName }},
+ TfType::Bases< {{ cls.parentCppClassName }} > >();
+
+{% if cls.isConcrete %}
+ // Register the usd prim typename as an alias under UsdSchemaBase. This
+ // enables one to call
+ // TfType::Find().FindDerivedByName("{{ cls.usdPrimTypeName }}")
+ // to find TfType<{{ cls.cppClassName }}>, which is how IsA queries are
+ // answered.
+ TfType::AddAlias("{{ cls.usdPrimTypeName }}");
+{% endif %}
+}
+
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+TF_DEFINE_PRIVATE_TOKENS(
+ _schemaTokens,
+ ({{ cls.propertyNamespacePrefix }})
+);
+
+{% endif %}
+/* virtual */
+{{ cls.cppClassName }}::~{{ cls.cppClassName }}()
+{
+}
+
+{% if not cls.isAPISchemaBase %}
+/* static */
+{{ cls.cppClassName }}
+{{ cls.cppClassName }}::Get(const UsdStagePtr &stage, const SdfPath &path)
+{
+ if (!stage) {
+ TF_CODING_ERROR("Invalid stage");
+ return {{ cls.cppClassName }}();
+ }
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ TfToken name;
+ if (!Is{{ cls.usdPrimTypeName }}Path(path, &name)) {
+ TF_CODING_ERROR("Invalid {{ cls.propertyNamespacePrefix }} path <%s>.", path.GetText());
+ return {{ cls.cppClassName }}();
+ }
+ return {{ cls.cppClassName }}(stage->GetPrimAtPath(path.GetPrimPath()), name);
+{% else %}
+ return {{ cls.cppClassName }}(stage->GetPrimAtPath(path));
+{% endif %}
+}
+
+{% if cls.isMultipleApply %}
+{{ cls.cppClassName }}
+{{ cls.cppClassName }}::Get(const UsdPrim &prim, const TfToken &name)
+{
+ return {{ cls.cppClassName }}(prim, name);
+}
+
+/* static */
+std::vector<{{ cls.cppClassName }}>
+{{ cls.cppClassName }}::GetAll(const UsdPrim &prim)
+{
+ std::vector<{{ cls.cppClassName }}> schemas;
+
+ for (const auto &schemaName :
+ UsdAPISchemaBase::_GetMultipleApplyInstanceNames(prim, _GetStaticTfType())) {
+ schemas.emplace_back(prim, schemaName);
+ }
+
+ return schemas;
+}
+
+{% endif %}
+{% endif %}
+{% if cls.isConcrete %}
+/* static */
+{{ cls.cppClassName }}
+{{ cls.cppClassName }}::Define(
+ const UsdStagePtr &stage, const SdfPath &path)
+{
+ static TfToken usdPrimTypeName("{{ cls.usdPrimTypeName }}");
+ if (!stage) {
+ TF_CODING_ERROR("Invalid stage");
+ return {{ cls.cppClassName }}();
+ }
+ return {{ cls.cppClassName }}(
+ stage->DefinePrim(path, usdPrimTypeName));
+}
+{% endif %}
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+
+/* static */
+bool
+{{ cls.cppClassName }}::IsSchemaPropertyBaseName(const TfToken &baseName)
+{
+ static TfTokenVector attrsAndRels = {
+{% for attrName in cls.attrOrder %}
+{% set attr = cls.attrs[attrName] %}
+ UsdSchemaRegistry::GetMultipleApplyNameTemplateBaseName(
+ {{ tokensPrefix }}Tokens->{{ attr.name }}),
+{% endfor %}
+{% for relName in cls.relOrder %}
+{% set rel = cls.rels[relName] %}
+ UsdSchemaRegistry::GetMultipleApplyNameTemplateBaseName(
+ {{ tokensPrefix }}Tokens->{{ rel.name }}),
+{% endfor %}
+ };
+
+ return find(attrsAndRels.begin(), attrsAndRels.end(), baseName)
+ != attrsAndRels.end();
+}
+
+/* static */
+bool
+{{ cls.cppClassName }}::Is{{ cls.usdPrimTypeName }}Path(
+ const SdfPath &path, TfToken *name)
+{
+ if (!path.IsPropertyPath()) {
+ return false;
+ }
+
+ std::string propertyName = path.GetName();
+ TfTokenVector tokens = SdfPath::TokenizeIdentifierAsTokens(propertyName);
+
+ // The baseName of the {{ cls.usdPrimTypename }} path can't be one of the
+ // schema properties. We should validate this in the creation (or apply)
+ // API.
+ TfToken baseName = *tokens.rbegin();
+ if (IsSchemaPropertyBaseName(baseName)) {
+ return false;
+ }
+
+ if (tokens.size() >= 2
+ && tokens[0] == _schemaTokens->{{ cls.propertyNamespacePrefix }}) {
+ *name = TfToken(propertyName.substr(
+ _schemaTokens->{{ cls.propertyNamespacePrefix }}.GetString().size() + 1));
+ return true;
+ }
+
+ return false;
+}
+{% endif %}
+
+/* virtual */
+UsdSchemaKind {{ cls.cppClassName }}::_GetSchemaKind() const
+{
+ return {{ cls.cppClassName }}::schemaKind;
+}
+{% if cls.isAppliedAPISchema %}
+
+/* static */
+bool
+{% if not cls.isMultipleApply %}
+{{ cls.cppClassName }}::CanApply(
+ const UsdPrim &prim, std::string *whyNot)
+{% else %}
+{{ cls.cppClassName }}::CanApply(
+ const UsdPrim &prim, const TfToken &name, std::string *whyNot)
+{% endif %}
+{
+{% if cls.isMultipleApply %}
+ return prim.CanApplyAPI<{{ cls.cppClassName }}>(name, whyNot);
+{% else %}
+ return prim.CanApplyAPI<{{ cls.cppClassName }}>(whyNot);
+{% endif %}
+}
+
+/* static */
+{{ cls.cppClassName }}
+{% if not cls.isMultipleApply %}
+{{ cls.cppClassName }}::Apply(const UsdPrim &prim)
+{% else %}
+{{ cls.cppClassName }}::Apply(const UsdPrim &prim, const TfToken &name)
+{% endif %}
+{
+{% if cls.isMultipleApply %}
+ if (prim.ApplyAPI<{{ cls.cppClassName }}>(name)) {
+ return {{ cls.cppClassName }}(prim, name);
+ }
+{% else %}
+ if (prim.ApplyAPI<{{ cls.cppClassName }}>()) {
+ return {{ cls.cppClassName }}(prim);
+ }
+{% endif %}
+ return {{ cls.cppClassName }}();
+}
+{% endif %}
+
+/* static */
+const TfType &
+{{ cls.cppClassName }}::_GetStaticTfType()
+{
+ static TfType tfType = TfType::Find<{{ cls.cppClassName }}>();
+ return tfType;
+}
+
+/* static */
+bool
+{{ cls.cppClassName }}::_IsTypedSchema()
+{
+ static bool isTyped = _GetStaticTfType().IsA();
+ return isTyped;
+}
+
+/* virtual */
+const TfType &
+{{ cls.cppClassName }}::_GetTfType() const
+{
+ return _GetStaticTfType();
+}
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+
+/// Returns the property name prefixed with the correct namespace prefix, which
+/// is composed of the the API's propertyNamespacePrefix metadata and the
+/// instance name of the API.
+static inline
+TfToken
+_GetNamespacedPropertyName(const TfToken instanceName, const TfToken propName)
+{
+ return UsdSchemaRegistry::MakeMultipleApplyNameInstance(propName, instanceName);
+}
+{% endif %}
+
+{% for attrName in cls.attrOrder %}
+{% set attr = cls.attrs[attrName] %}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+{% if attr.apiGet != "custom" %}
+UsdAttribute
+{{ cls.cppClassName }}::Get{{ Proper(attr.apiName) }}Attr() const
+{
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ return GetPrim().GetAttribute(
+ _GetNamespacedPropertyName(
+ GetName(),
+ {{ tokensPrefix }}Tokens->{{ attr.name }}));
+{% else %}
+ return GetPrim().GetAttribute({{ tokensPrefix }}Tokens->{{ attr.name }});
+{% endif %}
+}
+{% endif %}
+
+UsdAttribute
+{{ cls.cppClassName }}::Create{{ Proper(attr.apiName) }}Attr(VtValue const &defaultValue, bool writeSparsely) const
+{
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ return UsdSchemaBase::_CreateAttr(
+ _GetNamespacedPropertyName(
+ GetName(),
+ {{ tokensPrefix }}Tokens->{{ attr.name }}),
+{% else %}
+ return UsdSchemaBase::_CreateAttr({{ tokensPrefix }}Tokens->{{ attr.name }},
+{% endif %}
+ {{ attr.usdType }},
+ /* custom = */ {{ "true" if attr.custom else "false" }},
+ {{ attr.variability }},
+ defaultValue,
+ writeSparsely);
+}
+
+{% endif %}
+{% endfor %}
+{% for relName in cls.relOrder %}
+{% set rel = cls.rels[relName] %}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% if rel.apiName != '' %}
+{% if rel.apiGet != "custom" %}
+UsdRelationship
+{{ cls.cppClassName }}::Get{{ Proper(rel.apiName) }}Rel() const
+{
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ return GetPrim().GetRelationship(
+ _GetNamespacedPropertyName(
+ GetName(),
+ {{ tokensPrefix }}Tokens->{{ rel.name }}));
+{% else %}
+ return GetPrim().GetRelationship({{ tokensPrefix }}Tokens->{{ rel.name }});
+{% endif %}
+}
+{% endif %}
+
+UsdRelationship
+{{ cls.cppClassName }}::Create{{ Proper(rel.apiName) }}Rel() const
+{
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ return GetPrim().CreateRelationship(
+ _GetNamespacedPropertyName(
+ GetName(),
+ {{ tokensPrefix }}Tokens->{{ rel.name }}),
+{% else %}
+ return GetPrim().CreateRelationship({{ tokensPrefix }}Tokens->{{rel.name}},
+{% endif %}
+ /* custom = */ {{ "true" if rel.custom else "false" }});
+}
+
+{% endif %}
+{% endfor %}
+{% if cls.attrOrder|length > 0 %}
+namespace {
+static inline TfTokenVector
+_ConcatenateAttributeNames(const TfTokenVector& left,const TfTokenVector& right)
+{
+ TfTokenVector result;
+ result.reserve(left.size() + right.size());
+ result.insert(result.end(), left.begin(), left.end());
+ result.insert(result.end(), right.begin(), right.end());
+ return result;
+}
+}
+
+{% endif %}
+/*static*/
+const TfTokenVector&
+{{ cls.cppClassName }}::GetSchemaAttributeNames(bool includeInherited)
+{
+{% if cls.attrOrder|length > 0 %}
+ static TfTokenVector localNames = {
+{% for attrName in cls.attrOrder %}
+{% set attr = cls.attrs[attrName] %}
+{% if attr.apiName != '' %}
+ {{ tokensPrefix }}Tokens->{{ attr.name }},
+{% endif %}
+{% endfor %}
+ };
+ static TfTokenVector allNames =
+ _ConcatenateAttributeNames(
+ {{ cls.parentCppClassName }}::GetSchemaAttributeNames(true),
+ localNames);
+{% else %}
+ static TfTokenVector localNames;
+ static TfTokenVector allNames =
+ {{ cls.parentCppClassName }}::GetSchemaAttributeNames(true);
+{% endif %}
+
+ if (includeInherited)
+ return allNames;
+ else
+ return localNames;
+}
+
+{% if cls.isMultipleApply %}
+/*static*/
+TfTokenVector
+{{ cls.cppClassName }}::GetSchemaAttributeNames(
+ bool includeInherited, const TfToken &instanceName)
+{
+ const TfTokenVector &attrNames = GetSchemaAttributeNames(includeInherited);
+ if (instanceName.IsEmpty()) {
+ return attrNames;
+ }
+ TfTokenVector result;
+ result.reserve(attrNames.size());
+ for (const TfToken &attrName : attrNames) {
+ result.push_back(
+ UsdSchemaRegistry::MakeMultipleApplyNameInstance(attrName, instanceName));
+ }
+ return result;
+}
+
+{% endif %}
+{% if useExportAPI %}
+{{ namespaceClose }}
+
+{% endif %}
+// ===================================================================== //
+// Feel free to add custom code below this line. It will be preserved by
+// the code generator.
+{% if useExportAPI %}
+//
+// Just remember to wrap code in the appropriate delimiters:
+// '{{ namespaceOpen }}', '{{ namespaceClose }}'.
+{% endif %}
+// ===================================================================== //
+// --(BEGIN CUSTOM CODE)--
+
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+#ifndef {{ Upper(libraryName) }}_GENERATED_{{ Upper(cls.className) }}_H
+#define {{ Upper(libraryName) }}_GENERATED_{{ Upper(cls.className) }}_H
+
+/// \file {{ libraryName }}/{{ cls.GetHeaderFile() }}
+
+{% if useExportAPI %}
+#include "pxr/pxr.h"
+#include "{{ libraryPath }}/api.h"
+{% endif %}
+#include "{{ cls.parentLibPath }}/{{ cls.GetParentHeaderFile() }}"
+#include "pxr/usd/usd/prim.h"
+#include "pxr/usd/usd/stage.h"
+{% if cls.tokens -%}
+#include "{{ libraryPath }}/tokens.h"
+{% endif %}
+{% if cls.extraIncludes -%}
+{{ cls.extraIncludes }}
+{% endif %}
+
+#include "pxr/base/vt/value.h"
+
+#include "pxr/base/gf/vec3d.h"
+#include "pxr/base/gf/vec3f.h"
+#include "pxr/base/gf/matrix4d.h"
+
+#include "pxr/base/tf/token.h"
+#include "pxr/base/tf/type.h"
+
+{% if useExportAPI %}
+{{ namespaceOpen }}
+
+{% endif %}
+class SdfAssetPath;
+
+// -------------------------------------------------------------------------- //
+// {{ Upper(cls.usdPrimTypeName) }}{{' ' * (74 - cls.usdPrimTypeName|count)}} //
+// -------------------------------------------------------------------------- //
+
+/// \class {{ cls.cppClassName }}
+///
+{% if cls.doc -%}
+/// {{ cls.doc }}
+{% endif %}
+{% if cls.doc and hasTokenAttrs -%}
+///
+{%endif%}
+{% if hasTokenAttrs -%}
+/// For any described attribute \em Fallback \em Value or \em Allowed \em Values below
+/// that are text/tokens, the actual token is published and defined in \ref {{ tokensPrefix }}Tokens.
+/// So to set an attribute to the value "rightHanded", use {{ tokensPrefix }}Tokens->rightHanded
+/// as the value.
+{% endif %}
+///
+class {{ cls.cppClassName }} : public {{ cls.parentCppClassName }}
+{
+public:
+ /// Compile time constant representing what kind of schema this class is.
+ ///
+ /// \sa UsdSchemaKind
+ static const UsdSchemaKind schemaKind = {{cls.schemaKindEnumValue }};
+
+{% if cls.isMultipleApply %}
+ /// Construct a {{ cls.cppClassName }} on UsdPrim \p prim with
+ /// name \p name . Equivalent to
+ /// {{ cls.cppClassName }}::Get(
+ /// prim.GetStage(),
+ /// prim.GetPath().AppendProperty(
+ /// "{{ cls.propertyNamespacePrefix }}:name"));
+ ///
+ /// for a \em valid \p prim, but will not immediately throw an error for
+ /// an invalid \p prim
+ explicit {{ cls.cppClassName }}(
+ const UsdPrim& prim=UsdPrim(), const TfToken &name=TfToken())
+ : {{ cls.parentCppClassName }}(prim, /*instanceName*/ name)
+ { }
+
+ /// Construct a {{ cls.cppClassName }} on the prim held by \p schemaObj with
+ /// name \p name. Should be preferred over
+ /// {{ cls.cppClassName }}(schemaObj.GetPrim(), name), as it preserves
+ /// SchemaBase state.
+ explicit {{ cls.cppClassName }}(
+ const UsdSchemaBase& schemaObj, const TfToken &name)
+ : {{ cls.parentCppClassName }}(schemaObj, /*instanceName*/ name)
+ { }
+{% else %}
+ /// Construct a {{ cls.cppClassName }} on UsdPrim \p prim .
+ /// Equivalent to {{ cls.cppClassName }}::Get(prim.GetStage(), prim.GetPath())
+ /// for a \em valid \p prim, but will not immediately throw an error for
+ /// an invalid \p prim
+ explicit {{ cls.cppClassName }}(const UsdPrim& prim=UsdPrim())
+ : {{ cls.parentCppClassName }}(prim)
+ {
+ }
+
+ /// Construct a {{ cls.cppClassName }} on the prim held by \p schemaObj .
+ /// Should be preferred over {{ cls.cppClassName }}(schemaObj.GetPrim()),
+ /// as it preserves SchemaBase state.
+ explicit {{ cls.cppClassName }}(const UsdSchemaBase& schemaObj)
+ : {{ cls.parentCppClassName }}(schemaObj)
+ {
+ }
+{% endif %}
+
+ /// Destructor.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ virtual ~{{ cls.cppClassName }}() {%- if cls.isAPISchemaBase %} = 0{% endif %};
+
+ /// Return a vector of names of all pre-declared attributes for this schema
+ /// class and all its ancestor classes. Does not include attributes that
+ /// may be authored by custom/extended methods of the schemas involved.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static const TfTokenVector &
+ GetSchemaAttributeNames(bool includeInherited=true);
+{% if cls.isMultipleApply %}
+
+ /// Return a vector of names of all pre-declared attributes for this schema
+ /// class and all its ancestor classes for a given instance name. Does not
+ /// include attributes that may be authored by custom/extended methods of
+ /// the schemas involved. The names returned will have the proper namespace
+ /// prefix.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static TfTokenVector
+ GetSchemaAttributeNames(bool includeInherited, const TfToken &instanceName);
+
+ /// Returns the name of this multiple-apply schema instance
+ TfToken GetName() const {
+ return _GetInstanceName();
+ }
+{% endif %}
+{% if not cls.isAPISchemaBase %}
+
+ /// Return a {{ cls.cppClassName }} holding the prim adhering to this
+ /// schema at \p path on \p stage. If no prim exists at \p path on
+ /// \p stage, or if the prim at that path does not adhere to this schema,
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ /// return an invalid schema object. \p path must be of the format
+ /// .{{ cls.propertyNamespacePrefix }}:name .
+ ///
+ /// This is shorthand for the following:
+ ///
+ /// \code
+ /// TfToken name = SdfPath::StripNamespace(path.GetToken());
+ /// {{ cls.cppClassName }}(
+ /// stage->GetPrimAtPath(path.GetPrimPath()), name);
+ /// \endcode
+{% else %}
+ /// return an invalid schema object. This is shorthand for the following:
+ ///
+ /// \code
+ /// {{ cls.cppClassName }}(stage->GetPrimAtPath(path));
+ /// \endcode
+{% endif %}
+ ///
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static {{ cls.cppClassName }}
+ Get(const UsdStagePtr &stage, const SdfPath &path);
+{% if cls.isMultipleApply %}
+
+ /// Return a {{ cls.cppClassName }} with name \p name holding the
+ /// prim \p prim. Shorthand for {{ cls.cppClassName }}(prim, name);
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static {{ cls.cppClassName }}
+ Get(const UsdPrim &prim, const TfToken &name);
+
+ /// Return a vector of all named instances of {{ cls.cppClassName }} on the
+ /// given \p prim.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static std::vector<{{ cls.cppClassName }}>
+ GetAll(const UsdPrim &prim);
+{% endif %}
+{% endif %}
+
+{% if cls.isConcrete %}
+ /// Attempt to ensure a \a UsdPrim adhering to this schema at \p path
+ /// is defined (according to UsdPrim::IsDefined()) on this stage.
+ ///
+ /// If a prim adhering to this schema at \p path is already defined on this
+ /// stage, return that prim. Otherwise author an \a SdfPrimSpec with
+ /// \a specifier == \a SdfSpecifierDef and this schema's prim type name for
+ /// the prim at \p path at the current EditTarget. Author \a SdfPrimSpec s
+ /// with \p specifier == \a SdfSpecifierDef and empty typeName at the
+ /// current EditTarget for any nonexistent, or existing but not \a Defined
+ /// ancestors.
+ ///
+ /// The given \a path must be an absolute prim path that does not contain
+ /// any variant selections.
+ ///
+ /// If it is impossible to author any of the necessary PrimSpecs, (for
+ /// example, in case \a path cannot map to the current UsdEditTarget's
+ /// namespace) issue an error and return an invalid \a UsdPrim.
+ ///
+ /// Note that this method may return a defined prim whose typeName does not
+ /// specify this schema class, in case a stronger typeName opinion overrides
+ /// the opinion at the current EditTarget.
+ ///
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static {{ cls.cppClassName }}
+ Define(const UsdStagePtr &stage, const SdfPath &path);
+{% endif %}
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ /// Checks if the given name \p baseName is the base name of a property
+ /// of {{ cls.usdPrimTypeName }}.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static bool
+ IsSchemaPropertyBaseName(const TfToken &baseName);
+
+ /// Checks if the given path \p path is of an API schema of type
+ /// {{ cls.usdPrimTypeName }}. If so, it stores the instance name of
+ /// the schema in \p name and returns true. Otherwise, it returns false.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static bool
+ Is{{ cls.usdPrimTypeName }}Path(const SdfPath &path, TfToken *name);
+{% endif %}
+{% if cls.isAppliedAPISchema and not cls.isMultipleApply %}
+
+ /// Returns true if this single-apply API schema can be applied to
+ /// the given \p prim. If this schema can not be a applied to the prim,
+ /// this returns false and, if provided, populates \p whyNot with the
+ /// reason it can not be applied.
+ ///
+ /// Note that if CanApply returns false, that does not necessarily imply
+ /// that calling Apply will fail. Callers are expected to call CanApply
+ /// before calling Apply if they want to ensure that it is valid to
+ /// apply a schema.
+ ///
+ /// \sa UsdPrim::GetAppliedSchemas()
+ /// \sa UsdPrim::HasAPI()
+ /// \sa UsdPrim::CanApplyAPI()
+ /// \sa UsdPrim::ApplyAPI()
+ /// \sa UsdPrim::RemoveAPI()
+ ///
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static bool
+ CanApply(const UsdPrim &prim, std::string *whyNot=nullptr);
+
+ /// Applies this single-apply API schema to the given \p prim.
+ /// This information is stored by adding "{{ cls.primName }}" to the
+ /// token-valued, listOp metadata \em apiSchemas on the prim.
+ ///
+ /// \return A valid {{ cls.cppClassName }} object is returned upon success.
+ /// An invalid (or empty) {{ cls.cppClassName }} object is returned upon
+ /// failure. See \ref UsdPrim::ApplyAPI() for conditions
+ /// resulting in failure.
+ ///
+ /// \sa UsdPrim::GetAppliedSchemas()
+ /// \sa UsdPrim::HasAPI()
+ /// \sa UsdPrim::CanApplyAPI()
+ /// \sa UsdPrim::ApplyAPI()
+ /// \sa UsdPrim::RemoveAPI()
+ ///
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static {{ cls.cppClassName }}
+ Apply(const UsdPrim &prim);
+{% endif %}
+{% if cls.isAppliedAPISchema and cls.isMultipleApply %}
+
+ /// Returns true if this multiple-apply API schema can be applied,
+ /// with the given instance name, \p name, to the given \p prim. If this
+ /// schema can not be a applied the prim, this returns false and, if
+ /// provided, populates \p whyNot with the reason it can not be applied.
+ ///
+ /// Note that if CanApply returns false, that does not necessarily imply
+ /// that calling Apply will fail. Callers are expected to call CanApply
+ /// before calling Apply if they want to ensure that it is valid to
+ /// apply a schema.
+ ///
+ /// \sa UsdPrim::GetAppliedSchemas()
+ /// \sa UsdPrim::HasAPI()
+ /// \sa UsdPrim::CanApplyAPI()
+ /// \sa UsdPrim::ApplyAPI()
+ /// \sa UsdPrim::RemoveAPI()
+ ///
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static bool
+ CanApply(const UsdPrim &prim, const TfToken &name,
+ std::string *whyNot=nullptr);
+
+ /// Applies this multiple-apply API schema to the given \p prim
+ /// along with the given instance name, \p name.
+ ///
+ /// This information is stored by adding "{{ cls.primName }}:name"
+ /// to the token-valued, listOp metadata \em apiSchemas on the prim.
+ /// For example, if \p name is 'instance1', the token
+ /// '{{ cls.primName }}:instance1' is added to 'apiSchemas'.
+ ///
+ /// \return A valid {{ cls.cppClassName }} object is returned upon success.
+ /// An invalid (or empty) {{ cls.cppClassName }} object is returned upon
+ /// failure. See \ref UsdPrim::ApplyAPI() for
+ /// conditions resulting in failure.
+ ///
+ /// \sa UsdPrim::GetAppliedSchemas()
+ /// \sa UsdPrim::HasAPI()
+ /// \sa UsdPrim::CanApplyAPI()
+ /// \sa UsdPrim::ApplyAPI()
+ /// \sa UsdPrim::RemoveAPI()
+ ///
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static {{ cls.cppClassName }}
+ Apply(const UsdPrim &prim, const TfToken &name);
+{% endif %}
+
+protected:
+ /// Returns the kind of schema this class belongs to.
+ ///
+ /// \sa UsdSchemaKind
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ UsdSchemaKind _GetSchemaKind() const override;
+
+private:
+ // needs to invoke _GetStaticTfType.
+ friend class UsdSchemaRegistry;
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ static const TfType &_GetStaticTfType();
+
+ static bool _IsTypedSchema();
+
+ // override SchemaBase virtuals.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ const TfType &_GetTfType() const override;
+
+{% for attrName in cls.attrOrder %}
+{% set attr = cls.attrs[attrName]%}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+public:
+ // --------------------------------------------------------------------- //
+ // {{ Upper(attr.apiName) }}
+ // --------------------------------------------------------------------- //
+ /// {{ attr.doc }}
+ ///
+{% if attr.details %}
+ /// | ||
+ /// | -- | -- |
+{% for detail in attr.details %}
+ /// | {{ detail[0] }} | {{ detail[1] }} |
+{% endfor %}
+{% endif %}
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ UsdAttribute Get{{ Proper(attr.apiName) }}Attr() const;
+
+ /// See Get{{ Proper(attr.apiName) }}Attr(), and also
+ /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
+ /// If specified, author \p defaultValue as the attribute's default,
+ /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
+ /// the default for \p writeSparsely is \c false.
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ UsdAttribute Create{{ Proper(attr.apiName) }}Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
+
+{% endif %}
+{% endfor %}
+{% for relName in cls.relOrder %}
+{% set rel = cls.rels[relName]%}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% if rel.apiName != '' %}
+public:
+ // --------------------------------------------------------------------- //
+ // {{ Upper(rel.apiName) }}
+ // --------------------------------------------------------------------- //
+ /// {{ rel.doc }}
+ ///
+{% for detail in rel.details %}
+ /// \n {{ detail[0] }}: {{ detail[1] }}
+{% endfor %}
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ UsdRelationship Get{{ Proper(rel.apiName) }}Rel() const;
+
+ /// See Get{{ Proper(rel.apiName) }}Rel(), and also
+ /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create
+ {% if useExportAPI -%}
+ {{ Upper(libraryName) }}_API
+ {% endif -%}
+ UsdRelationship Create{{ Proper(rel.apiName) }}Rel() const;
+{% endif %}
+
+{% endfor %}
+public:
+ // ===================================================================== //
+ // Feel free to add custom code below this line, it will be preserved by
+ // the code generator.
+ //
+ // Just remember to:
+ // - Close the class declaration with };
+{% if useExportAPI %}
+ // - Close the namespace with {{ namespaceClose }}
+{% endif %}
+ // - Close the include guard with #endif
+ // ===================================================================== //
+ // --(BEGIN CUSTOM CODE)--
+
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+#include "{{ libraryPath }}/tokens.h"
+
+{% if useExportAPI %}
+{{ namespaceOpen }}
+
+{% endif %}
+{{ tokensPrefix }}TokensType::{{ tokensPrefix }}TokensType() :
+{% for token in tokens %}
+ {{ token.id }}("{{ token.value }}", TfToken::Immortal),
+{% endfor %}
+ allTokens({
+{% for token in tokens %}
+ {{ token.id }}{% if not loop.last %},{% endif %}
+
+{% endfor %}
+ })
+{
+}
+
+TfStaticData<{{ tokensPrefix }}TokensType> {{ tokensPrefix }}Tokens;
+{% if useExportAPI %}
+
+{{ namespaceClose }}
+{% endif %}
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+#ifndef {{ Upper(tokensPrefix) }}_TOKENS_H
+#define {{ Upper(tokensPrefix) }}_TOKENS_H
+
+/// \file {{ libraryName }}/tokens.h
+
+// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+//
+// This is an automatically generated file (by usdGenSchema.py).
+// Do not hand-edit!
+//
+// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+
+{% if useExportAPI %}
+#include "pxr/pxr.h"
+#include "{{ libraryPath }}/api.h"
+{% endif %}
+#include "pxr/base/tf/staticData.h"
+#include "pxr/base/tf/token.h"
+#include
+
+{% if useExportAPI %}
+{{ namespaceOpen }}
+
+{% endif %}
+
+/// \class {{ tokensPrefix }}TokensType
+///
+/// \link {{ tokensPrefix }}Tokens \endlink provides static, efficient
+/// \link TfToken TfTokens\endlink for use in all public USD API.
+///
+/// These tokens are auto-generated from the module's schema, representing
+/// property names, for when you need to fetch an attribute or relationship
+/// directly by name, e.g. UsdPrim::GetAttribute(), in the most efficient
+/// manner, and allow the compiler to verify that you spelled the name
+/// correctly.
+///
+/// {{ tokensPrefix }}Tokens also contains all of the \em allowedTokens values
+/// declared for schema builtin attributes of 'token' scene description type.
+{% if tokens %}
+/// Use {{ tokensPrefix }}Tokens like so:
+///
+/// \code
+/// gprim.GetMyTokenValuedAttr().Set({{ tokensPrefix }}Tokens->{{ tokens[0].id }});
+/// \endcode
+{% endif %}
+struct {{ tokensPrefix }}TokensType {
+ {% if useExportAPI %}{{ Upper(libraryName) }}_API {% endif %}{{ tokensPrefix }}TokensType();
+{% for token in tokens %}
+ /// \brief "{{ token.value }}"
+ ///
+ /// {{ token.desc }}
+ const TfToken {{ token.id }};
+{% endfor %}
+ /// A vector of all of the tokens listed above.
+ const std::vector allTokens;
+};
+
+/// \var {{ tokensPrefix }}Tokens
+///
+/// A global variable with static, efficient \link TfToken TfTokens\endlink
+/// for use in all public USD API. \sa {{ tokensPrefix }}TokensType
+extern{% if useExportAPI %} {{ Upper(libraryName) }}_API{% endif %} TfStaticData<{{ tokensPrefix }}TokensType> {{ tokensPrefix }}Tokens;
+{% if useExportAPI %}
+
+{{ namespaceClose }}
+{% endif %}
+
+#endif
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+#include "{{ libraryPath }}/{{ cls.GetHeaderFile() }}"
+#include "pxr/usd/usd/schemaBase.h"
+
+#include "pxr/usd/sdf/primSpec.h"
+
+#include "pxr/usd/usd/pyConversions.h"
+{% if cls.isAppliedAPISchema %}
+#include "pxr/base/tf/pyAnnotatedBoolResult.h"
+{% endif %}
+#include "pxr/base/tf/pyContainerConversions.h"
+#include "pxr/base/tf/pyResultConversions.h"
+#include "pxr/base/tf/pyUtils.h"
+#include "pxr/base/tf/wrapTypeHelpers.h"
+
+#include
+
+#include
+
+using namespace boost::python;
+
+{% if useExportAPI %}
+{{ namespaceUsing }}
+
+namespace {
+
+{% endif %}
+#define WRAP_CUSTOM \
+ template static void _CustomWrapCode(Cls &_class)
+
+// fwd decl.
+WRAP_CUSTOM;
+
+{% for attrName in cls.attrOrder -%}
+{% set attr = cls.attrs[attrName] %}
+{# Only emit Create/Get API if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+
+static UsdAttribute
+_Create{{ Proper(attr.apiName) }}Attr({{ cls.cppClassName }} &self,
+ object defaultVal, bool writeSparsely) {
+ return self.Create{{ Proper(attr.apiName) }}Attr(
+ UsdPythonToSdfType(defaultVal, {{ attr.usdType }}), writeSparsely);
+}
+{% endif %}
+{% endfor %}
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+
+static bool _WrapIs{{ cls.usdPrimTypeName }}Path(const SdfPath &path) {
+ TfToken collectionName;
+ return {{ cls.cppClassName }}::Is{{ cls.usdPrimTypeName }}Path(
+ path, &collectionName);
+}
+{% endif %}
+{% if not cls.isAPISchemaBase %}
+
+static std::string
+_Repr(const {{ cls.cppClassName }} &self)
+{
+ std::string primRepr = TfPyRepr(self.GetPrim());
+{% if cls.isMultipleApply %}
+ std::string instanceName = TfPyRepr(self.GetName());
+ return TfStringPrintf(
+ "{{ libraryName[0]|upper }}{{ libraryName[1:] }}.{{ cls.className }}(%s, '%s')",
+ primRepr.c_str(), instanceName.c_str());
+{% else %}
+ return TfStringPrintf(
+ "{{ libraryName[0]|upper }}{{ libraryName[1:] }}.{{ cls.className }}(%s)",
+ primRepr.c_str());
+{% endif %}
+}
+{% endif %}
+{% if cls.isAppliedAPISchema %}
+
+struct {{ cls.cppClassName }}_CanApplyResult :
+ public TfPyAnnotatedBoolResult
+{
+ {{ cls.cppClassName }}_CanApplyResult(bool val, std::string const &msg) :
+ TfPyAnnotatedBoolResult(val, msg) {}
+};
+
+{% if cls.isMultipleApply %}
+static {{ cls.cppClassName }}_CanApplyResult
+_WrapCanApply(const UsdPrim& prim, const TfToken& name)
+{
+ std::string whyNot;
+ bool result = {{ cls.cppClassName }}::CanApply(prim, name, &whyNot);
+ return {{ cls.cppClassName }}_CanApplyResult(result, whyNot);
+}
+{% else %}
+static {{ cls.cppClassName }}_CanApplyResult
+_WrapCanApply(const UsdPrim& prim)
+{
+ std::string whyNot;
+ bool result = {{ cls.cppClassName }}::CanApply(prim, &whyNot);
+ return {{ cls.cppClassName }}_CanApplyResult(result, whyNot);
+}
+{% endif %}
+{% endif %}
+{% if useExportAPI %}
+
+} // anonymous namespace
+{% endif %}
+
+void wrap{{ cls.cppClassName }}()
+{
+ typedef {{ cls.cppClassName }} This;
+
+{% if cls.isAppliedAPISchema %}
+ {{ cls.cppClassName }}_CanApplyResult::Wrap<{{ cls.cppClassName }}_CanApplyResult>(
+ "_CanApplyResult", "whyNot");
+
+{% endif %}
+{% if cls.isAPISchemaBase %}
+ class_< This , bases<{{ cls.parentCppClassName }}>, boost::noncopyable> cls ("APISchemaBase", "", no_init);
+{% else %}
+ class_ >
+ cls("{{ cls.className }}");
+{% endif %}
+
+ cls
+{% if not cls.isAPISchemaBase %}
+{% if cls.isMultipleApply %}
+ .def(init((arg("prim"), arg("name"))))
+ .def(init((arg("schemaObj"), arg("name"))))
+{% else %}
+ .def(init(arg("prim")))
+ .def(init(arg("schemaObj")))
+{% endif %}
+{% endif %}
+ .def(TfTypePythonClass())
+
+{% if not cls.isAPISchemaBase %}
+{% if cls.isMultipleApply %}
+ .def("Get",
+ ({{ cls.cppClassName }}(*)(const UsdStagePtr &stage,
+ const SdfPath &path))
+ &This::Get,
+ (arg("stage"), arg("path")))
+ .def("Get",
+ ({{ cls.cppClassName }}(*)(const UsdPrim &prim,
+ const TfToken &name))
+ &This::Get,
+ (arg("prim"), arg("name")))
+{% else %}
+ .def("Get", &This::Get, (arg("stage"), arg("path")))
+{% endif %}
+ .staticmethod("Get")
+{% endif %}
+{% if cls.isMultipleApply %}
+
+ .def("GetAll",
+ (std::vector<{{ cls.cppClassName }}>(*)(const UsdPrim &prim))
+ &This::GetAll,
+ arg("prim"),
+ return_value_policy())
+ .staticmethod("GetAll")
+{% endif %}
+{% if cls.isConcrete %}
+
+ .def("Define", &This::Define, (arg("stage"), arg("path")))
+ .staticmethod("Define")
+{% endif %}
+{% if cls.isAppliedAPISchema and not cls.isMultipleApply %}
+
+ .def("CanApply", &_WrapCanApply, (arg("prim")))
+ .staticmethod("CanApply")
+{% endif %}
+{% if cls.isAppliedAPISchema and cls.isMultipleApply %}
+
+ .def("CanApply", &_WrapCanApply, (arg("prim"), arg("name")))
+ .staticmethod("CanApply")
+{% endif %}
+{% if cls.isAppliedAPISchema and not cls.isMultipleApply %}
+
+ .def("Apply", &This::Apply, (arg("prim")))
+ .staticmethod("Apply")
+{% endif %}
+{% if cls.isAppliedAPISchema and cls.isMultipleApply %}
+
+ .def("Apply", &This::Apply, (arg("prim"), arg("name")))
+ .staticmethod("Apply")
+{% endif %}
+
+{% if cls.isMultipleApply %}
+ .def("GetSchemaAttributeNames",
+ (const TfTokenVector &(*)(bool))&This::GetSchemaAttributeNames,
+ arg("includeInherited")=true,
+ return_value_policy())
+ .def("GetSchemaAttributeNames",
+ (TfTokenVector(*)(bool, const TfToken &))
+ &This::GetSchemaAttributeNames,
+ arg("includeInherited"),
+ arg("instanceName"),
+ return_value_policy())
+{% else %}
+ .def("GetSchemaAttributeNames",
+ &This::GetSchemaAttributeNames,
+ arg("includeInherited")=true,
+ return_value_policy())
+{% endif %}
+ .staticmethod("GetSchemaAttributeNames")
+
+ .def("_GetStaticTfType", (TfType const &(*)()) TfType::Find,
+ return_value_policy())
+ .staticmethod("_GetStaticTfType")
+
+ .def(!self)
+
+{% for attrName in cls.attrOrder -%}
+{% set attr = cls.attrs[attrName] %}
+{# Only emit Create/Get API if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+
+ .def("Get{{ Proper(attr.apiName) }}Attr",
+ &This::Get{{ Proper(attr.apiName) }}Attr)
+ .def("Create{{ Proper(attr.apiName) }}Attr",
+ &_Create{{ Proper(attr.apiName) }}Attr,
+ (arg("defaultValue")=object(),
+ arg("writeSparsely")=false))
+{% endif %}
+{% endfor %}
+
+{% for relName in cls.relOrder -%}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% set rel = cls.rels[relName] %}
+{% if rel.apiName != '' %}
+
+ .def("Get{{ Proper(rel.apiName) }}Rel",
+ &This::Get{{ Proper(rel.apiName) }}Rel)
+ .def("Create{{ Proper(rel.apiName) }}Rel",
+ &This::Create{{ Proper(rel.apiName) }}Rel)
+{% endif %}
+{% endfor %}
+{% if cls.isMultipleApply and cls.propertyNamespacePrefix %}
+ .def("Is{{ cls.usdPrimTypeName }}Path", _WrapIs{{ cls.usdPrimTypeName }}Path)
+ .staticmethod("Is{{ cls.usdPrimTypeName }}Path")
+{% endif %}
+{% if not cls.isAPISchemaBase %}
+ .def("__repr__", ::_Repr)
+{% endif %}
+ ;
+
+ _CustomWrapCode(cls);
+}
+
+// ===================================================================== //
+// Feel free to add custom code below this line, it will be preserved by
+// the code generator. The entry point for your custom code should look
+// minimally like the following:
+//
+// WRAP_CUSTOM {
+// _class
+// .def("MyCustomMethod", ...)
+// ;
+// }
+//
+// Of course any other ancillary or support code may be provided.
+{% if useExportAPI %}
+//
+// Just remember to wrap code in the appropriate delimiters:
+// 'namespace {', '}'.
+//
+{% endif %}
+// ===================================================================== //
+// --(BEGIN CUSTOM CODE)--
+
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+// GENERATED FILE. DO NOT EDIT.
+#include
+#include "{{ libraryPath }}/tokens.h"
+
+{% if useExportAPI %}
+{{ namespaceUsing }}
+
+{% endif %}
+namespace {
+
+// Helper to return a static token as a string. We wrap tokens as Python
+// strings and for some reason simply wrapping the token using def_readonly
+// bypasses to-Python conversion, leading to the error that there's no
+// Python type for the C++ TfToken type. So we wrap this functor instead.
+class _WrapStaticToken {
+public:
+ _WrapStaticToken(const TfToken* token) : _token(token) { }
+
+ std::string operator()() const
+ {
+ return _token->GetString();
+ }
+
+private:
+ const TfToken* _token;
+};
+
+template
+void
+_AddToken(T& cls, const char* name, const TfToken& token)
+{
+ cls.add_static_property(name,
+ boost::python::make_function(
+ _WrapStaticToken(&token),
+ boost::python::return_value_policy<
+ boost::python::return_by_value>(),
+ boost::mpl::vector1()));
+}
+
+} // anonymous
+
+void wrap{{ tokensPrefix }}Tokens()
+{
+ boost::python::class_<{{ tokensPrefix }}TokensType, boost::noncopyable>
+ cls("Tokens", boost::python::no_init);
+{% for token in tokens %}
+ _AddToken(cls, "{{ token.id }}", {{ tokensPrefix }}Tokens->{{ token.id }});
+{% endfor %}
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class "Typed" (
+ doc = '''The base class for all typed schemas (those that can impart a
+ typeName to a UsdPrim), and therefore the base class for all
+ concrete, instantiable "IsA" schemas.
+
+ UsdTyped implements a typeName-based query for its override of
+ UsdSchemaBase::_IsCompatible(). It provides no other behavior.'''
+)
+{
+}
+
+class "APISchemaBase" (
+ doc = """The base class for all API schemas.
+
+ An API schema provides an interface to a prim's qualities, but does not
+ specify a typeName for the underlying prim. The prim's qualities include
+ its inheritance structure, attributes, relationships etc. Since it cannot
+ provide a typeName, an API schema is considered to be non-concrete.
+
+ To auto-generate an API schema using usdGenSchema, simply leave the
+ typeName empty and make it inherit from \"/APISchemaBase\" or from another
+ API schema. See UsdModelAPI, UsdClipsAPI and UsdCollectionAPI for examples.
+
+ API schemas are classified into applied and non-applied API schemas.
+ The author of an API schema has to decide on the type of API schema
+ at the time of its creation by setting customData['apiSchemaType'] in the
+ schema definition (i.e. in the associated primSpec inside the schema.usda
+ file). UsdAPISchemaBase implements methods that are used to record the
+ application of an API schema on a USD prim.
+
+ If an API schema only provides an interface to set certain core bits of
+ metadata (like UsdModelAPI, which sets model kind and UsdClipsAPI, which
+ sets clips-related metadata) OR if the API schema can apply to any type of
+ prim or only to a known fixed set of prim types OR if there is no use of
+ recording the application of the API schema, in such cases, it would be
+ better to make it a non-applied API schema. Examples of non-applied API
+ schemas include UsdModelAPI, UsdClipsAPI, UsdShadeConnectableAPI and
+ UsdGeomPrimvarsAPI.
+
+ If there is a need to discover (or record) whether a prim contains or
+ subscribes to a given API schema, it would be advantageous to make the API
+ schema be \"applied\". In general, API schemas that add one or more properties
+ to a prim should be tagged as applied API schemas. A public Apply() method
+ is generated for applied API schemas by usdGenSchema. An applied API schema
+ must be applied to a prim via a call to the generated Apply() method, for
+ the schema object to evaluate to true when converted to a bool using the
+ explicit bool conversion operator. Examples of applied API schemas include
+ UsdCollectionAPI, UsdGeomModelAPI and UsdGeomMotionAPI
+
+ \\anchor UsdAPISchemaBase_SingleVsMultipleApply
+ \\name Single vs. Multiple Apply API Schemas
+
+ Applied API schemas can further be classified into single-apply and
+ multiple-apply API schemas. As the name suggests, a single-apply API schema
+ can only be applied once to a prim. A multiple-apply API schema can be
+ applied multiple times with different 'instanceName' values. An example of
+ a multiple-apply API schema is UsdCollectionAPI, where the API schema is
+ applied to a prim once for every collection owned by the prim.
+
+ \\note An applied API schema can only inherit from another applied API
+ schema or directly from APISchemaBase. Similarly, a non-applied API schema
+ can only inherit from a non-applied API Schema or directly from
+ APISchemaBase. 'usdGenSchema' attempts to issue a warning if it detects
+ an incompatibility.
+
+ \\note A multiple-apply API schema may not inherit from a single-apply API
+ schema and vice versa.
+
+ \\note When the bool-conversion operator is invoked on an applied API
+ schema, it evaluates to true only if the application of the API schema has
+ been recorded on the prim via a call to the auto-generated Apply() method.
+
+ """
+)
+{
+}
+
+class "ModelAPI" (
+ doc = """UsdModelAPI is an API schema that provides an interface to a prim's
+ model qualities, if it does, in fact, represent the root prim of a model.
+
+ The first and foremost model quality is its kind, i.e. the metadata
+ that establishes it as a model (See KindRegistry). UsdModelAPI provides
+ various methods for setting and querying the prim's kind, as well as
+ queries (also available on UsdPrim) for asking what category of model
+ the prim is. See \"Kind and Model-ness\".
+
+ UsdModelAPI also provides access to a prim's \"assetInfo\"
+ data. While any prim can host assetInfo, it is common that published
+ (referenced) assets are packaged as models, therefore it is convenient
+ to provide access to the one from the other.
+
+ \\todo establish an _IsCompatible() override that returns IsModel()
+ \\todo GetModelInstanceName()
+ """
+)
+{
+}
+
+class "CollectionAPI" (
+ doc = """ This is a general purpose API schema, used to describe a
+ collection of heterogeneous objects within the scene. \"Objects\" here may be
+ prims or properties belonging to prims or other collections. It's an add-on
+ schema that can be applied many times to a prim with different collection
+ names.
+
+ A collection allows an enumeration of a set of paths to include and a
+ set of paths to exclude. Whether the descendants of an included
+ path are members of a collection are decided by its expansion rule
+ (see below). If the collection excludes paths that are not descendents
+ of included paths, the collection implicitly includes the root path
+ </>. If such a collection also includes paths that are not
+ descendants of the excluded paths, it is considered invalid, since
+ the intention is ambiguous.
+
+ All the properties authored by the schema are namespaced under
+ \"collection:\". The given name of the collection provides additional
+ namespacing for the various per-collection properties, which include the
+ following:
+
+
uniform token collection:collectionName:expansionRule -
+ specified how the paths that are included in the collection must be expanded
+ to determine its members. Possible values include:
+
+
explicitOnly - only paths in the includes rel targets and not
+ in the excludes rel targets belong to the collection.
+
+
expandPrims - all the prims at or below the includes rel-
+ targets (and not under the excludes rel-targets) belong to the
+ collection. Any property paths included in the collection would, of
+ course, also be honored. This is the default behavior as it satisfies
+ most use cases.
+
+
expandPrimsAndProperties - like expandPrims, but also
+ includes all properties on all matched prims. We're still not quite
+ sure what the use cases are for this, but you can use it to capture a
+ whole lot of UsdObjects very concisely.
+
+
+
+
bool collection:collectionName:includeRoot - boolean
+ attribute indicating whether the pseudo-root path </> should
+ be counted as one of the included target paths. The fallback is false.
+ This separate attribute is required because relationships cannot
+ directly target the root. When expansionRule is explicitOnly, this
+ attribute is ignored.
+
rel collection:collectionName:includes - specifies a list
+ of targets that are included in the collection. This can target prims or
+ properties directly. A collection can insert the rules of another
+ collection by making its includes relationship target the
+ collection:{collectionName} property on the owning prim of the
+ collection to be included (see UsdCollectionAPI::GetCollectionAttr).
+ It is important to note that including another collection does not
+ guarantee the contents of that collection will be in the final collection;
+ instead, the rules are merged. This means, for example, an exclude
+ entry may exclude a portion of the included collection.
+ When a collection includes one or more collections, the order in which
+ targets are added to the includes relationship may become significant, if
+ there are conflicting opinions about the same path. Targets that are added
+ later are considered to be stronger than earlier targets for the same path.
+
+
rel collection:collectionName:excludes - specifies a list
+ of targets that are excluded below the included paths in this
+ collection. This can target prims or properties directly, but cannot
+ target another collection. This is to keep the membership determining
+ logic simple, efficient and easier to reason about. Finally, it is invalid
+ for a collection to exclude paths that are not included in it. The presence
+ of such \"orphaned\" excluded paths will not affect the set of paths included
+ in the collection, but may affect the performance of querying membership of
+ a path in the collection (see UsdCollectionAPI::MembershipQuery::IsPathIncluded)
+ or of enumerating the objects belonging to the collection (see
+ UsdCollectionAPI::GetIncludedObjects).
+
+
uniform opaque collection:collectionName - opaque
+ attribute (meaning it can never have a value) that represents the collection
+ for the purpose of allowing another collection to include it. When this
+ property is targeted by another collection's includes relationship,
+ the rules of this collection will be inserted into the rules of the collection
+ that includes it.
+
+
+ Implicit inclusion
+
+ In some scenarios it is useful to express a collection that includes
+ everything except certain paths. To support this, a collection
+ that has an exclude that is not a descendent of any include
+ will include the root path </>.
+
+ Creating collections in C++
+
+ \\snippet examples_usd.cpp ApplyCollections
+ """
+)
+{
+ uniform opaque collection:__INSTANCE_NAME__ (
+ doc = """This property represents the collection for the purpose of
+ allowing another collection to include it. When this property is
+ targeted by another collection's includes relationship, the rules
+ of this collection will be inserted into the rules of the collection
+ that includes it.
+ """
+ )
+ rel collection:__INSTANCE_NAME__:excludes (
+ doc = '''Specifies a list of targets that are excluded below
+ the included paths in this collection. This can target prims or
+ properties directly, but cannot target another collection. This is to
+ keep the membership determining logic simple, efficient and easier to
+ reason about. Finally, it is invalid for a collection to exclude
+ paths that are not included in it. The presence of such "orphaned"
+ excluded paths will not affect the set of paths included in the
+ collection, but may affect the performance of querying membership of
+ a path in the collection (see
+ UsdCollectionAPI::MembershipQuery::IsPathIncluded)
+ or of enumerating the objects belonging to the collection (see
+ UsdCollectionAPI::GetIncludedObjects).'''
+ )
+ uniform token collection:__INSTANCE_NAME__:expansionRule = "expandPrims" (
+ allowedTokens = ["explicitOnly", "expandPrims", "expandPrimsAndProperties"]
+ doc = """Specifies how the paths that are included in
+ the collection must be expanded to determine its members."""
+ )
+ uniform bool collection:__INSTANCE_NAME__:includeRoot (
+ doc = """Boolean attribute indicating whether the pseudo-root
+ path </> should be counted as one of the included target
+ paths. The fallback is false. This separate attribute is
+ required because relationships cannot directly target the root."""
+ )
+ rel collection:__INSTANCE_NAME__:includes (
+ doc = """Specifies a list of targets that are included in the collection.
+ This can target prims or properties directly. A collection can insert
+ the rules of another collection by making its includes
+ relationship target the collection:{collectionName} property on
+ the owning prim of the collection to be included"""
+ )
+ uniform pathExpression collection:__INSTANCE_NAME__:membershipExpression (
+ doc = """Specifies a path expression that determines membership in this
+ collection."""
+ )
+}
+
+class "ClipsAPI" (
+ doc = """ UsdClipsAPI is an API schema that provides an interface to
+ a prim's clip metadata. Clips are a \"value resolution\" feature that
+ allows one to specify a sequence of usd files (clips) to be consulted,
+ over time, as a source of varying overrides for the prims at and
+ beneath this prim in namespace.
+
+ SetClipAssetPaths() establishes the set of clips that can be consulted.
+ SetClipActive() specifies the ordering of clip application over time
+ (clips can be repeated), while SetClipTimes() specifies time-mapping
+ from stage-time to clip-time for the clip active at a given stage-time,
+ which allows for time-dilation and repetition of clips.
+ Finally, SetClipPrimPath() determines the path within each clip that will
+ map to this prim, i.e. the location within the clip at which we will look
+ for opinions for this prim.
+
+ The clip asset paths, times and active metadata can also be specified
+ through template clip metadata. This can be desirable when your set of
+ assets is very large, as the template metadata is much more concise.
+ SetClipTemplateAssetPath() establishes the asset identifier pattern of the
+ set of clips to be consulted. SetClipTemplateStride(),
+ SetClipTemplateEndTime(), and SetClipTemplateStartTime() specify the range
+ in which USD will search, based on the template. From the set of resolved
+ asset paths, times and active will be derived internally.
+
+ A prim may have multiple \"clip sets\" -- named sets of clips that each
+ have their own values for the metadata described above. For example,
+ a prim might have a clip set named \"Clips_1\" that specifies some group
+ of clip asset paths, and another clip set named \"Clips_2\" that uses
+ an entirely different set of clip asset paths. These clip sets are
+ composed across composition arcs, so clip sets for a prim may be
+ defined in multiple sublayers or references, for example. Individual
+ metadata for a given clip set may be sparsely overridden.
+
+ Important facts about clips:
+ - Within the layerstack in which clips are established, the
+ opinions within the clips will be weaker than any local opinions
+ in the layerstack, but em stronger than varying opinions coming across
+ references and variants.
+ - We will never look for metadata or default opinions in clips
+ when performing value resolution on the owning stage, since these
+ quantities must be time-invariant.
+
+ This leads to the common structure in which we reference a model asset
+ on a prim, and then author clips at the same site: the asset reference
+ will provide the topology and unvarying data for the model, while the
+ clips will provide the time-sampled animation.
+
+ For further information, see \\ref Usd_Page_ValueClips
+ """
+)
+{
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "apiSchemas": {
+ "appliesTo": "prims",
+ "type": "tokenlistop"
+ },
+ "clipSets": {
+ "appliesTo": [
+ "prims"
+ ],
+ "type": "stringlistop"
+ },
+ "clips": {
+ "appliesTo": [
+ "prims"
+ ],
+ "type": "dictionary"
+ },
+ "fallbackPrimTypes": {
+ "appliesTo": [
+ "layers"
+ ],
+ "type": "dictionary"
+ }
+ },
+ "Types": {
+ "UsdAPISchemaBase": {
+ "alias": {
+ "UsdSchemaBase": "APISchemaBase"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdSchemaBase"
+ ],
+ "schemaKind": "abstractBase"
+ },
+ "UsdClipsAPI": {
+ "alias": {
+ "UsdSchemaBase": "ClipsAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "nonAppliedAPI"
+ },
+ "UsdCollectionAPI": {
+ "alias": {
+ "UsdSchemaBase": "CollectionAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "multipleApplyAPI"
+ },
+ "UsdModelAPI": {
+ "alias": {
+ "UsdSchemaBase": "ModelAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "nonAppliedAPI"
+ },
+ "UsdSchemaBase": {
+ "alias": {
+ "UsdSchemaBase": "SchemaBase"
+ },
+ "schemaKind": "abstractBase"
+ },
+ "UsdTyped": {
+ "alias": {
+ "UsdSchemaBase": "Typed"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdSchemaBase"
+ ],
+ "schemaKind": "abstractBase"
+ },
+ "UsdUsdFileFormat": {
+ "bases": [
+ "SdfFileFormat"
+ ],
+ "displayName": "USD File Format",
+ "extensions": [
+ "usd"
+ ],
+ "formatId": "usd",
+ "primary": true,
+ "target": "usd"
+ },
+ "UsdUsdaFileFormat": {
+ "bases": [
+ "SdfTextFileFormat"
+ ],
+ "displayName": "USD Text File Format",
+ "extensions": [
+ "usda"
+ ],
+ "formatId": "usda",
+ "primary": true,
+ "target": "usd"
+ },
+ "UsdUsdcFileFormat": {
+ "bases": [
+ "SdfFileFormat"
+ ],
+ "displayName": "USD Crate File Format",
+ "extensions": [
+ "usdc"
+ ],
+ "formatId": "usdc",
+ "primary": true,
+ "target": "usd"
+ },
+ "UsdUsdzFileFormat": {
+ "bases": [
+ "SdfFileFormat"
+ ],
+ "displayName": "USDZ File Format",
+ "extensions": [
+ "usdz"
+ ],
+ "formatId": "usdz",
+ "primary": true,
+ "supportsEditing": false,
+ "supportsWriting": false,
+ "target": "usd"
+ },
+ "Usd_UsdzResolver": {
+ "bases": [
+ "ArPackageResolver"
+ ],
+ "extensions": [
+ "usdz"
+ ]
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usd",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ "This file describes the USD primitive schemata and drives code generation."
+)
+
+def "GLOBAL" (
+ customData = {
+ string libraryName = "usd"
+ string libraryPath = "pxr/usd/usd"
+ # string libraryPrefix = "Usd"
+ # string tokensPrefix = "Usd"
+ dictionary libraryTokens = {
+ dictionary apiSchemas = {
+ string doc = """
+ A listop metadata containing the API schemas which have
+ been applied to this prim, using the Apply() method on
+ the particular schema class.
+ """
+ }
+ dictionary fallbackPrimTypes = {
+ string doc = """
+ A dictionary metadata that maps the name of a concrete schema
+ prim type to an ordered list of schema prim types to use instead
+ if the schema prim type doesn't exist in version of USD being
+ used.
+ """
+ }
+ }
+ }
+)
+{
+}
+
+class "Typed"
+(
+ doc = """The base class for all \\em typed schemas (those that can impart a
+ typeName to a UsdPrim), and therefore the base class for all
+ concrete, instantiable "IsA" schemas.
+
+ UsdTyped implements a typeName-based query for its override of
+ UsdSchemaBase::_IsCompatible(). It provides no other behavior."""
+)
+{
+}
+
+class "APISchemaBase"
+(
+ doc = """The base class for all \\em API schemas.
+
+ An API schema provides an interface to a prim's qualities, but does not
+ specify a typeName for the underlying prim. The prim's qualities include
+ its inheritance structure, attributes, relationships etc. Since it cannot
+ provide a typeName, an API schema is considered to be non-concrete.
+
+ To auto-generate an API schema using usdGenSchema, simply leave the
+ typeName empty and make it inherit from "/APISchemaBase" or from another
+ API schema. See UsdModelAPI, UsdClipsAPI and UsdCollectionAPI for examples.
+
+ API schemas are classified into applied and non-applied API schemas.
+ The author of an API schema has to decide on the type of API schema
+ at the time of its creation by setting customData['apiSchemaType'] in the
+ schema definition (i.e. in the associated primSpec inside the schema.usda
+ file). UsdAPISchemaBase implements methods that are used to record the
+ application of an API schema on a USD prim.
+
+ If an API schema only provides an interface to set certain core bits of
+ metadata (like UsdModelAPI, which sets model kind and UsdClipsAPI, which
+ sets clips-related metadata) OR if the API schema can apply to any type of
+ prim or only to a known fixed set of prim types OR if there is no use of
+ recording the application of the API schema, in such cases, it would be
+ better to make it a non-applied API schema. Examples of non-applied API
+ schemas include UsdModelAPI, UsdClipsAPI, UsdShadeConnectableAPI and
+ UsdGeomPrimvarsAPI.
+
+ If there is a need to discover (or record) whether a prim contains or
+ subscribes to a given API schema, it would be advantageous to make the API
+ schema be "applied". In general, API schemas that add one or more properties
+ to a prim should be tagged as applied API schemas. A public Apply() method
+ is generated for applied API schemas by usdGenSchema. An applied API schema
+ must be applied to a prim via a call to the generated Apply() method, for
+ the schema object to evaluate to true when converted to a bool using the
+ explicit bool conversion operator. Examples of applied API schemas include
+ UsdCollectionAPI, UsdGeomModelAPI and UsdGeomMotionAPI
+
+ \\anchor UsdAPISchemaBase_SingleVsMultipleApply
+ \\name Single vs. Multiple Apply API Schemas
+
+ Applied API schemas can further be classified into single-apply and
+ multiple-apply API schemas. As the name suggests, a single-apply API schema
+ can only be applied once to a prim. A multiple-apply API schema can be
+ applied multiple times with different 'instanceName' values. An example of
+ a multiple-apply API schema is UsdCollectionAPI, where the API schema is
+ applied to a prim once for every collection owned by the prim.
+
+ \\note An applied API schema can only inherit from another applied API
+ schema or directly from APISchemaBase. Similarly, a non-applied API schema
+ can only inherit from a non-applied API Schema or directly from
+ APISchemaBase. 'usdGenSchema' attempts to issue a warning if it detects
+ an incompatibility.
+
+ \\note A multiple-apply API schema may not inherit from a single-apply API
+ schema and vice versa.
+
+ \\note When the bool-conversion operator is invoked on an applied API
+ schema, it evaluates to true only if the application of the API schema has
+ been recorded on the prim via a call to the auto-generated Apply() method.
+
+ """
+ customData = {
+ string fileName = "apiSchemaBase"
+ }
+)
+{
+}
+
+class "ModelAPI"
+(
+ inherits =
+ doc = """UsdModelAPI is an API schema that provides an interface to a prim's
+ model qualities, if it does, in fact, represent the root prim of a model.
+
+ The first and foremost model quality is its \\em kind, i.e. the metadata
+ that establishes it as a model (See KindRegistry). UsdModelAPI provides
+ various methods for setting and querying the prim's kind, as well as
+ queries (also available on UsdPrim) for asking what category of model
+ the prim is. See \\ref Usd_ModelKind "Kind and Model-ness".
+
+ UsdModelAPI also provides access to a prim's \\ref Usd_Model_AssetInfo "assetInfo"
+ data. While any prim \\em can host assetInfo, it is common that published
+ (referenced) assets are packaged as models, therefore it is convenient
+ to provide access to the one from the other.
+
+ \\todo establish an _IsCompatible() override that returns IsModel()
+ \\todo GetModelInstanceName()
+ """
+ customData = {
+ string apiSchemaType = "nonApplied"
+ }
+)
+{
+}
+
+class "CollectionAPI"
+(
+ inherits =
+ doc = """ This is a general purpose API schema, used to describe a
+ collection of heterogeneous objects within the scene. "Objects" here may be
+ prims or properties belonging to prims or other collections. It's an add-on
+ schema that can be applied many times to a prim with different collection
+ names.
+
+ A collection allows an enumeration of a set of paths to include and a
+ set of paths to exclude. Whether the descendants of an included
+ path are members of a collection are decided by its expansion rule
+ (see below). If the collection excludes paths that are not descendents
+ of included paths, the collection implicitly includes the root path
+ </>. If such a collection also includes paths that are not
+ descendants of the excluded paths, it is considered invalid, since
+ the intention is ambiguous.
+
+ All the properties authored by the schema are namespaced under
+ "collection:". The given name of the collection provides additional
+ namespacing for the various per-collection properties, which include the
+ following:
+
+
uniform token collection:collectionName:expansionRule -
+ specified how the paths that are included in the collection must be expanded
+ to determine its members. Possible values include:
+
+
explicitOnly - only paths in the includes rel targets and not
+ in the excludes rel targets belong to the collection.
+
+
expandPrims - all the prims at or below the includes rel-
+ targets (and not under the excludes rel-targets) belong to the
+ collection. Any property paths included in the collection would, of
+ course, also be honored. This is the default behavior as it satisfies
+ most use cases.
+
+
expandPrimsAndProperties - like expandPrims, but also
+ includes all properties on all matched prims. We're still not quite
+ sure what the use cases are for this, but you can use it to capture a
+ whole lot of UsdObjects very concisely.
+
+
+
+
bool collection:collectionName:includeRoot - boolean
+ attribute indicating whether the pseudo-root path </> should
+ be counted as one of the included target paths. The fallback is false.
+ This separate attribute is required because relationships cannot
+ directly target the root. When expansionRule is explicitOnly, this
+ attribute is ignored.
+
rel collection:collectionName:includes - specifies a list
+ of targets that are included in the collection. This can target prims or
+ properties directly. A collection can insert the rules of another
+ collection by making its includes relationship target the
+ collection:{collectionName} property on the owning prim of the
+ collection to be included (see UsdCollectionAPI::GetCollectionAttr).
+ It is important to note that including another collection does not
+ guarantee the contents of that collection will be in the final collection;
+ instead, the rules are merged. This means, for example, an exclude
+ entry may exclude a portion of the included collection.
+ When a collection includes one or more collections, the order in which
+ targets are added to the includes relationship may become significant, if
+ there are conflicting opinions about the same path. Targets that are added
+ later are considered to be stronger than earlier targets for the same path.
+
+
rel collection:collectionName:excludes - specifies a list
+ of targets that are excluded below the included paths in this
+ collection. This can target prims or properties directly, but cannot
+ target another collection. This is to keep the membership determining
+ logic simple, efficient and easier to reason about. Finally, it is invalid
+ for a collection to exclude paths that are not included in it. The presence
+ of such "orphaned" excluded paths will not affect the set of paths included
+ in the collection, but may affect the performance of querying membership of
+ a path in the collection (see UsdCollectionAPI::MembershipQuery::IsPathIncluded)
+ or of enumerating the objects belonging to the collection (see
+ UsdCollectionAPI::GetIncludedObjects).
+
+
uniform opaque collection:collectionName - opaque
+ attribute (meaning it can never have a value) that represents the collection
+ for the purpose of allowing another collection to include it. When this
+ property is targeted by another collection's includes relationship,
+ the rules of this collection will be inserted into the rules of the collection
+ that includes it.
+
+
+ Implicit inclusion
+
+ In some scenarios it is useful to express a collection that includes
+ everything except certain paths. To support this, a collection
+ that has an exclude that is not a descendent of any include
+ will include the root path </>.
+
+ Creating collections in C++
+
+ \\snippet examples_usd.cpp ApplyCollections
+ """
+
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usd/collectionMembershipQuery.h"
+#include "pxr/usd/usd/primFlags.h"
+#include "pxr/usd/usd/tokens.h"
+#include "pxr/usd/sdf/pathExpression.h"
+"""
+ token apiSchemaType = "multipleApply"
+ token propertyNamespacePrefix = "collection"
+ dictionary schemaTokens = {
+ dictionary exclude = {
+ string doc = """
+ This is the token used to exclude a path from a collection.
+ Although it is not a possible value for the "expansionRule"
+ attribute, it is used as the expansionRule for excluded paths
+ in UsdCollectionAPI::MembershipQuery::IsPathIncluded.
+ """
+ }
+ }
+ }
+)
+{
+ uniform token expansionRule = "expandPrims" (
+ allowedTokens = ["explicitOnly", "expandPrims", "expandPrimsAndProperties"]
+ doc = """Specifies how the paths that are included in
+ the collection must be expanded to determine its members."""
+ )
+ uniform bool includeRoot (
+ doc = """Boolean attribute indicating whether the pseudo-root
+ path </> should be counted as one of the included target
+ paths. The fallback is false. This separate attribute is
+ required because relationships cannot directly target the root."""
+ )
+ rel includes (
+ doc = """Specifies a list of targets that are included in the collection.
+ This can target prims or properties directly. A collection can insert
+ the rules of another collection by making its includes
+ relationship target the collection:{collectionName} property on
+ the owning prim of the collection to be included"""
+ )
+ rel excludes (
+ doc = """Specifies a list of targets that are excluded below
+ the included paths in this collection. This can target prims or
+ properties directly, but cannot target another collection. This is to
+ keep the membership determining logic simple, efficient and easier to
+ reason about. Finally, it is invalid for a collection to exclude
+ paths that are not included in it. The presence of such "orphaned"
+ excluded paths will not affect the set of paths included in the
+ collection, but may affect the performance of querying membership of
+ a path in the collection (see
+ UsdCollectionAPI::MembershipQuery::IsPathIncluded)
+ or of enumerating the objects belonging to the collection (see
+ UsdCollectionAPI::GetIncludedObjects)."""
+ )
+ uniform pathExpression membershipExpression (
+ doc = """Specifies a path expression that determines membership in this
+ collection."""
+ )
+ uniform opaque __INSTANCE_NAME__ (
+ customData = {
+ string apiName = "Collection"
+ }
+ doc = """This property represents the collection for the purpose of
+ allowing another collection to include it. When this property is
+ targeted by another collection's includes relationship, the rules
+ of this collection will be inserted into the rules of the collection
+ that includes it.
+ """
+ )
+}
+
+class "ClipsAPI"
+(
+ inherits =
+ doc = """ UsdClipsAPI is an API schema that provides an interface to
+ a prim's clip metadata. Clips are a "value resolution" feature that
+ allows one to specify a sequence of usd files (clips) to be consulted,
+ over time, as a source of varying overrides for the prims at and
+ beneath this prim in namespace.
+
+ SetClipAssetPaths() establishes the set of clips that can be consulted.
+ SetClipActive() specifies the ordering of clip application over time
+ (clips can be repeated), while SetClipTimes() specifies time-mapping
+ from stage-time to clip-time for the clip active at a given stage-time,
+ which allows for time-dilation and repetition of clips.
+ Finally, SetClipPrimPath() determines the path within each clip that will
+ map to this prim, i.e. the location within the clip at which we will look
+ for opinions for this prim.
+
+ The clip asset paths, times and active metadata can also be specified
+ through template clip metadata. This can be desirable when your set of
+ assets is very large, as the template metadata is much more concise.
+ SetClipTemplateAssetPath() establishes the asset identifier pattern of the
+ set of clips to be consulted. SetClipTemplateStride(),
+ SetClipTemplateEndTime(), and SetClipTemplateStartTime() specify the range
+ in which USD will search, based on the template. From the set of resolved
+ asset paths, times and active will be derived internally.
+
+ A prim may have multiple "clip sets" -- named sets of clips that each
+ have their own values for the metadata described above. For example,
+ a prim might have a clip set named "Clips_1" that specifies some group
+ of clip asset paths, and another clip set named "Clips_2" that uses
+ an entirely different set of clip asset paths. These clip sets are
+ composed across composition arcs, so clip sets for a prim may be
+ defined in multiple sublayers or references, for example. Individual
+ metadata for a given clip set may be sparsely overridden.
+
+ Important facts about clips:
+ \\li Within the layerstack in which clips are established, the
+ opinions within the clips will be \\em weaker than any local opinions
+ in the layerstack, but \em stronger than varying opinions coming across
+ references and variants.
+ \\li We will never look for metadata or default opinions in clips
+ when performing value resolution on the owning stage, since these
+ quantities must be time-invariant.
+
+ This leads to the common structure in which we reference a model asset
+ on a prim, and then author clips at the same site: the asset reference
+ will provide the topology and unvarying data for the model, while the
+ clips will provide the time-sampled animation.
+
+ For further information, see \\ref Usd_Page_ValueClips
+ """
+ customData = {
+ token apiSchemaType = "nonApplied"
+ dictionary schemaTokens = {
+ dictionary clips = {
+ string doc = """
+ Dictionary that contains the definition of the clip sets on
+ this prim. See \\ref UsdClipsAPI::GetClips.
+ """
+ }
+
+ dictionary clipSets = {
+ string doc = """
+ ListOp that may be used to affect how opinions from
+ clip sets are applied during value resolution.
+ See \\ref UsdClipsAPI::GetClipSets.
+ """
+ }
+ }
+ }
+)
+{
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class "Imageable" (
+ doc = """Base class for all prims that may require rendering or
+ visualization of some sort. The primary attributes of Imageable
+ are visibility and purpose, which each provide instructions for
+ what geometry should be included for processing by rendering and other
+ computations.
+
+ \\deprecated Imageable also provides API for accessing primvars, which
+ has been moved to the UsdGeomPrimvarsAPI schema, because primvars can now
+ be applied on non-Imageable prim types. This API is planned
+ to be removed, UsdGeomPrimvarsAPI should be used directly instead."""
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+}
+
+class "VisibilityAPI" (
+ doc = '''
+ UsdGeomVisibilityAPI introduces properties that can be used to author
+ visibility opinions.
+
+ \\note
+ Currently, this schema only introduces the attributes that are used to
+ control purpose visibility. Later, this schema will define _all_
+ visibility-related properties and UsdGeomImageable will no longer define
+ those properties.
+
+ The purpose visibility attributes added by this schema,
+ _guideVisibility_, _proxyVisibility_, and _renderVisibility_ can each be
+ used to control visibility for geometry of the corresponding purpose
+ values, with the overall _visibility_ attribute acting as an
+ override. I.e., if _visibility_ evaluates to "invisible", purpose
+ visibility is invisible; otherwise, purpose visibility is determined by
+ the corresponding purpose visibility attribute.
+
+ Note that the behavior of _guideVisibility_ is subtly different from the
+ _proxyVisibility_ and _renderVisibility_ attributes, in that "guide"
+ purpose visibility always evaluates to either "invisible" or "visible",
+ whereas the other attributes may yield computed values of "inherited" if
+ there is no authored opinion on the attribute or inherited from an
+ ancestor. This is motivated by the fact that, in Pixar"s user workflows,
+ we have never found a need to have all guides visible in a scene by
+ default, whereas we do find that flexibility useful for "proxy" and
+ "render" geometry.
+
+ This schema can only be applied to UsdGeomImageable prims. The
+ UseGeomImageable schema provides API for computing the purpose visibility
+ values that result from the attributes introduced by this schema.
+ '''
+)
+{
+ uniform token guideVisibility = "invisible" (
+ allowedTokens = ["inherited", "invisible", "visible"]
+ doc = '''
+ This attribute controls visibility for geometry with purpose "guide".
+
+ Unlike overall _visibility_, _guideVisibility_ is uniform, and
+ therefore cannot be animated.
+
+ Also unlike overall _visibility_, _guideVisibility_ is tri-state, in
+ that a descendant with an opinion of "visible" overrides an ancestor
+ opinion of "invisible".
+
+ The _guideVisibility_ attribute works in concert with the overall
+ _visibility_ attribute: The visibility of a prim with purpose "guide"
+ is determined by the inherited values it receives for the _visibility_
+ and _guideVisibility_ attributes. If _visibility_ evaluates to
+ "invisible", the prim is invisible. If _visibility_ evaluates to
+ "inherited" and _guideVisibility_ evaluates to "visible", then the
+ prim is visible. __Otherwise, it is invisible.__
+ '''
+ )
+ uniform token proxyVisibility = "inherited" (
+ allowedTokens = ["inherited", "invisible", "visible"]
+ doc = '''
+ This attribute controls visibility for geometry with purpose "proxy".
+
+ Unlike overall _visibility_, _proxyVisibility_ is uniform, and
+ therefore cannot be animated.
+
+ Also unlike overall _visibility_, _proxyVisibility_ is tri-state, in
+ that a descendant with an opinion of "visible" overrides an ancestor
+ opinion of "invisible".
+
+ The _proxyVisibility_ attribute works in concert with the overall
+ _visibility_ attribute: The visibility of a prim with purpose "proxy"
+ is determined by the inherited values it receives for the _visibility_
+ and _proxyVisibility_ attributes. If _visibility_ evaluates to
+ "invisible", the prim is invisible. If _visibility_ evaluates to
+ "inherited" then: If _proxyVisibility_ evaluates to "visible", then
+ the prim is visible; if _proxyVisibility_ evaluates to "invisible",
+ then the prim is invisible; if _proxyVisibility_ evaluates to
+ "inherited", then the prim may either be visible or invisible,
+ depending on a fallback value determined by the calling context.
+ '''
+ )
+ uniform token renderVisibility = "inherited" (
+ allowedTokens = ["inherited", "invisible", "visible"]
+ doc = '''
+ This attribute controls visibility for geometry with purpose
+ "render".
+
+ Unlike overall _visibility_, _renderVisibility_ is uniform, and
+ therefore cannot be animated.
+
+ Also unlike overall _visibility_, _renderVisibility_ is tri-state, in
+ that a descendant with an opinion of "visible" overrides an ancestor
+ opinion of "invisible".
+
+ The _renderVisibility_ attribute works in concert with the overall
+ _visibility_ attribute: The visibility of a prim with purpose "render"
+ is determined by the inherited values it receives for the _visibility_
+ and _renderVisibility_ attributes. If _visibility_ evaluates to
+ "invisible", the prim is invisible. If _visibility_ evaluates to
+ "inherited" then: If _renderVisibility_ evaluates to "visible", then
+ the prim is visible; if _renderVisibility_ evaluates to "invisible",
+ then the prim is invisible; if _renderVisibility_ evaluates to
+ "inherited", then the prim may either be visible or invisible,
+ depending on a fallback value determined by the calling context.
+ '''
+ )
+}
+
+class "PrimvarsAPI" (
+ doc = """UsdGeomPrimvarsAPI encodes geometric \"primitive variables\",
+ as UsdGeomPrimvar, which interpolate across a primitive's topology,
+ can override shader inputs, and inherit down namespace.
+
+ Which Method to Use to Retrieve Primvars
+
+ While creating primvars is unambiguous (CreatePrimvar()), there are quite
+ a few methods available for retrieving primvars, making it potentially
+ confusing knowing which one to use. Here are some guidelines:
+
+ - If you are populating a GUI with the primvars already available for
+ authoring values on a prim, use GetPrimvars().
+ - If you want all of the \"useful\" (e.g. to a renderer) primvars
+ available at a prim, including those inherited from ancestor prims, use
+ FindPrimvarsWithInheritance(). Note that doing so individually for many
+ prims will be inefficient.
+ - To find a particular primvar defined directly on a prim, which may
+ or may not provide a value, use GetPrimvar().
+ - To find a particular primvar defined on a prim or inherited from
+ ancestors, which may or may not provide a value, use
+ FindPrimvarWithInheritance().
+ - To *efficiently* query for primvars using the overloads of
+ FindPrimvarWithInheritance() and FindPrimvarsWithInheritance(), one
+ must first cache the results of FindIncrementallyInheritablePrimvars() for
+ each non-leaf prim on the stage. """
+)
+{
+}
+
+class "Xformable" (
+ doc = """Base class for all transformable prims, which allows arbitrary
+ sequences of component affine transformations to be encoded.
+
+ \\note
+ You may find it useful to review while reading
+ this class description.
+
+ Supported Component Transformation Operations
+
+ UsdGeomXformable currently supports arbitrary sequences of the following
+ operations, each of which can be encoded in an attribute of the proper
+ shape in any supported precision:
+ - translate - 3D
+ - scale - 3D
+ - rotateX - 1D angle in degrees
+ - rotateY - 1D angle in degrees
+ - rotateZ - 1D angle in degrees
+ - rotateABC - 3D where ABC can be any combination of the six principle
+ Euler Angle sets: XYZ, XZY, YXZ, YZX, ZXY, ZYX. See
+ \"note on rotation packing order\"
+ - orient - 4D (quaternion)
+ - transform - 4x4D
+
+ Creating a Component Transformation
+
+ To add components to a UsdGeomXformable prim, simply call AddXformOp()
+ with the desired op type, as enumerated in \\ref UsdGeomXformOp::Type,
+ and the desired precision, which is one of \\ref UsdGeomXformOp::Precision.
+ Optionally, you can also provide an \"op suffix\" for the operator that
+ disambiguates it from other components of the same type on the same prim.
+ Application-specific transform schemas can use the suffixes to fill a role
+ similar to that played by AbcGeom::XformOp's \"Hint\" enums for their own
+ round-tripping logic.
+
+ We also provide specific \"Add\" API for each type, for clarity and
+ conciseness, e.g. AddTranslateOp(), AddRotateXYZOp() etc.
+
+ AddXformOp() will return a UsdGeomXformOp object, which is a schema on a
+ newly created UsdAttribute that provides convenience API for authoring
+ and computing the component transformations. The UsdGeomXformOp can then
+ be used to author any number of timesamples and default for the op.
+
+ Each successive call to AddXformOp() adds an operator that will be applied
+ \"more locally\" than the preceding operator, just as if we were pushing
+ transforms onto a transformation stack - which is precisely what should
+ happen when the operators are consumed by a reader.
+
+ \\note
+ If you can, please try to use the UsdGeomXformCommonAPI, which wraps
+ the UsdGeomXformable with an interface in which Op creation is taken
+ care of for you, and there is a much higher chance that the data you
+ author will be importable without flattening into other DCC's, as it
+ conforms to a fixed set of Scale-Rotate-Translate Ops.
+
+ \\sa \"Using the Authoring API\"
+
+ Data Encoding and Op Ordering
+
+ Because there is no \"fixed schema\" of operations, all of the attributes
+ that encode transform operations are dynamic, and are scoped in
+ the namespace \"xformOp\". The second component of an attribute's name provides
+ the type of operation, as listed above. An \"xformOp\" attribute can
+ have additional namespace components derived from the opSuffix argument
+ to the AddXformOp() suite of methods, which provides a preferred way of
+ naming the ops such that we can have multiple \"translate\" ops with unique
+ attribute names. For example, in the attribute named
+ \"xformOp:translate:maya:pivot\", \"translate\" is the type of operation and
+ \"maya:pivot\" is the suffix.
+
+ The following ordered list of attribute declarations in usda
+ define a basic Scale-Rotate-Translate with XYZ Euler angles, wherein the
+ translation is double-precision, and the remainder of the ops are single,
+ in which we will:
+
+
+
Scale by 2.0 in each dimension
+
Rotate about the X, Y, and Z axes by 30, 60, and 90 degrees, respectively
+
Translate by 100 units in the Y direction
+
+
+ \\code
+ float3 xformOp:rotateXYZ = (30, 60, 90)
+ float3 xformOp:scale = (2, 2, 2)
+ double3 xformOp:translate = (0, 100, 0)
+ uniform token[] xformOpOrder = [ \"xformOp:translate\", \"xformOp:rotateXYZ\", \"xformOp:scale\" ]
+ \\endcode
+
+ The attributes appear in the dictionary order in which USD, by default,
+ sorts them. To ensure the ops are recovered and evaluated in the correct
+ order, the schema introduces the **xformOpOrder** attribute, which
+ contains the names of the op attributes, in the precise sequence in which
+ they should be pushed onto a transform stack. **Note** that the order is
+ opposite to what you might expect, given the matrix algebra described in
+ This also dictates order of op creation,
+ since each call to AddXformOp() adds a new op to the end of the
+ \\b xformOpOrder array, as a new \"most-local\" operation. See
+ \"Example 2 below\" for C++ code that could
+ have produced this USD.
+
+ If it were important for the prim's rotations to be independently
+ overridable, we could equivalently (at some performance cost) encode
+ the transformation also like so:
+ \\code
+ float xformOp:rotateX = 30
+ float xformOp:rotateY = 60
+ float xformOp:rotateZ = 90
+ float3 xformOp:scale = (2, 2, 2)
+ double3 xformOp:translate = (0, 100, 0)
+ uniform token[] xformOpOrder = [ \"xformOp:translate\", \"xformOp:rotateZ\", \"xformOp:rotateY\", \"xformOp:rotateX\", \"xformOp:scale\" ]
+ \\endcode
+
+ Again, note that although we are encoding an XYZ rotation, the three
+ rotations appear in the **xformOpOrder** in the opposite order, with Z,
+ followed, by Y, followed by X.
+
+ Were we to add a Maya-style scalePivot to the above example, it might
+ look like the following:
+ \\code
+ float3 xformOp:rotateXYZ = (30, 60, 90)
+ float3 xformOp:scale = (2, 2, 2)
+ double3 xformOp:translate = (0, 100, 0)
+ double3 xformOp:translate:scalePivot
+ uniform token[] xformOpOrder = [ \"xformOp:translate\", \"xformOp:rotateXYZ\", \"xformOp:translate:scalePivot\", \"xformOp:scale\" ]
+ \\endcode
+
+ Paired \"Inverted\" Ops
+
+ We have been claiming that the ordered list of ops serves as a set
+ of instructions to a transform stack, but you may have noticed in the last
+ example that there is a missing operation - the pivot for the scale op
+ needs to be applied in its inverse-form as a final (most local) op! In the
+ AbcGeom::Xform schema, we would have encoded an actual \"final\" translation
+ op whose value was authored by the exporter as the negation of the pivot's
+ value. However, doing so would be brittle in USD, given that each op can
+ be independently overridden, and the constraint that one attribute must be
+ maintained as the negation of the other in order for successful
+ re-importation of the schema cannot be expressed in USD.
+
+ Our solution leverages the **xformOpOrder** member of the schema, which,
+ in addition to ordering the ops, may also contain one of two special
+ tokens that address the paired op and \"stack resetting\" behavior.
+
+ The \"paired op\" behavior is encoded as an \"!invert!\" prefix in
+ \\b xformOpOrder, as the result of an AddXformOp(isInverseOp=True) call.
+ The \\b xformOpOrder for the last example would look like:
+ \\code
+ uniform token[] xformOpOrder = [ \"xformOp:translate\", \"xformOp:rotateXYZ\", \"xformOp:translate:scalePivot\", \"xformOp:scale\", \"!invert!xformOp:translate:scalePivot\" ]
+ \\endcode
+
+ When asked for its value via UsdGeomXformOp::GetOpTransform(), an
+ \"inverted\" Op (i.e. the \"inverted\" half of a set of paired Ops) will fetch
+ the value of its paired attribute and return its negation. This works for
+ all op types - an error will be issued if a \"transform\" type op is singular
+ and cannot be inverted. When getting the authored value of an inverted op
+ via UsdGeomXformOp::Get(), the raw, uninverted value of the associated
+ attribute is returned.
+
+ For the sake of robustness, setting a value on an inverted op is disallowed.
+ Attempting to set a value on an inverted op will result in a coding error
+ and no value being set.
+
+ Resetting the Transform Stack
+
+ The other special op/token that can appear in xformOpOrder is
+ \"!resetXformStack!\", which, appearing as the first element of
+ xformOpOrder, indicates this prim should not inherit the transformation
+ of its namespace parent. See SetResetXformStack()
+
+ Expected Behavior for \"Missing\" Ops
+
+ If an importer expects Scale-Rotate-Translate operations, but a prim
+ has only translate and rotate ops authored, the importer should assume
+ an identity scale. This allows us to optimize the data a bit, if only
+ a few components of a very rich schema (like Maya's) are authored in the
+ app.
+
+ \\anchor usdGeom_xformableExamples
+ Using the C++ API
+
+ #1. Creating a simple transform matrix encoding
+ \\snippet examples_usdGeom.cpp CreateMatrixWithDefault
+
+ #2. Creating the simple SRT from the example above
+ \\snippet examples_usdGeom.cpp CreateExampleSRT
+
+ #3. Creating a parameterized SRT with pivot using UsdGeomXformCommonAPI
+ \\snippet examples_usdGeom.cpp CreateSRTWithDefaults
+
+ #4. Creating a rotate-only pivot transform with animated
+ rotation and translation
+ \\snippet examples_usdGeom.cpp CreateAnimatedTransform
+
+"""
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Scope "Scope" (
+ doc = """Scope is the simplest grouping primitive, and does not carry the
+ baggage of transformability. Note that transforms should inherit down
+ through a Scope successfully - it is just a guaranteed no-op from a
+ transformability perspective."""
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+}
+
+class Xform "Xform" (
+ doc = "Concrete prim schema for a transform, which implements Xformable "
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "Boundable" (
+ doc = """Boundable introduces the ability for a prim to persistently
+ cache a rectilinear, local-space, extent.
+
+ Why Extent and not Bounds ?
+ Boundable introduces the notion of \"extent\", which is a cached computation
+ of a prim's local-space 3D range for its resolved attributes at the
+ layer and time in which extent is authored. We have found that with
+ composed scene description, attempting to cache pre-computed bounds at
+ interior prims in a scene graph is very fragile, given the ease with which
+ one can author a single attribute in a stronger layer that can invalidate
+ many authored caches - or with which a re-published, referenced asset can
+ do the same.
+
+ Therefore, we limit to precomputing (generally) leaf-prim extent, which
+ avoids the need to read in large point arrays to compute bounds, and
+ provides UsdGeomBBoxCache the means to efficiently compute and
+ (session-only) cache intermediate bounds. You are free to compute and
+ author intermediate bounds into your scenes, of course, which may work
+ well if you have sufficient locks on your pipeline to guarantee that once
+ authored, the geometry and transforms upon which they are based will
+ remain unchanged, or if accuracy of the bounds is not an ironclad
+ requisite.
+
+ When intermediate bounds are authored on Boundable parents, the child prims
+ will be pruned from BBox computation; the authored extent is expected to
+ incorporate all child bounds."""
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "Gprim" (
+ doc = '''Base class for all geometric primitives.
+
+ Gprim encodes basic graphical properties such as doubleSided and
+ orientation, and provides primvars for "display color" and "display
+ opacity" that travel with geometry to be used as shader overrides. '''
+)
+{
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Cube "Cube" (
+ doc = """Defines a primitive rectilinear cube centered at the origin.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+)
+{
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-1, -1, -1), (1, 1, 1)] (
+ doc = """Extent is re-defined on Cube only to provide a fallback value.
+ \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double size = 2 (
+ doc = """Indicates the length of each edge of the cube. If you
+ author size you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Sphere "Sphere" (
+ doc = """Defines a primitive sphere centered at the origin.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+)
+{
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-1, -1, -1), (1, 1, 1)] (
+ doc = """Extent is re-defined on Sphere only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double radius = 1 (
+ doc = """Indicates the sphere's radius. If you
+ author radius you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Cylinder "Cylinder" (
+ doc = """Defines a primitive cylinder with closed ends, centered at the
+ origin, whose spine is along the specified axis.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+)
+{
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = "The axis along which the spine of the cylinder is aligned"
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-1, -1, -1), (1, 1, 1)] (
+ doc = """Extent is re-defined on Cylinder only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ double height = 2 (
+ doc = """The size of the cylinder's spine along the specified
+ axis. If you author height you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double radius = 1 (
+ doc = """The radius of the cylinder. If you author radius
+ you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Capsule "Capsule" (
+ doc = """Defines a primitive capsule, i.e. a cylinder capped by two half
+ spheres, centered at the origin, whose spine is along the specified
+ axis.
+ The spherical cap heights (sagitta) of the two endcaps are a function of
+ the relative radii of the endcaps, such that cylinder tangent and sphere
+ tangent are coincident and maintain C1 continuity."""
+)
+{
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = "The axis along which the spine of the capsule is aligned"
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-0.5, -0.5, -1), (0.5, 0.5, 1)] (
+ doc = """Extent is re-defined on Capsule only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ double height = 1 (
+ doc = """The length of the capsule's spine along the specified
+ axis excluding the size of the two half spheres, i.e.
+ the length of the cylinder portion of the capsule.
+ If you author height you must also author extent.
+ \\sa GetExtentAttr()"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double radius = 0.5 (
+ doc = """The radius of the capsule. If you
+ author radius you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Cone "Cone" (
+ doc = """Defines a primitive cone, centered at the origin, whose spine
+ is along the specified axis, with the apex of the cone pointing
+ in the direction of the positive axis.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+)
+{
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = "The axis along which the spine of the cone is aligned"
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-1, -1, -1), (1, 1, 1)] (
+ doc = """Extent is re-defined on Cone only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ double height = 2 (
+ doc = """The length of the cone's spine along the specified
+ axis. If you author height you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double radius = 1 (
+ doc = """The radius of the cone. If you
+ author radius you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Cylinder_1 "Cylinder_1" (
+ doc = """Defines a primitive cylinder with closed ends, centered at the
+ origin, whose spine is along the specified axis, with a pair of radii
+ describing the size of the end points.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+)
+{
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = "The axis along which the spine of the cylinder is aligned"
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-1, -1, -1), (1, 1, 1)] (
+ doc = """Extent is re-defined on Cylinder only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ double height = 2 (
+ doc = """The length of the cylinder's spine along the specified
+ axis. If you author height you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double radiusBottom = 1 (
+ doc = """The radius of the bottom of the cylinder - i.e. the face
+ point located along the negative axis. If you author
+ radiusBottom you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radiusTop = 1 (
+ doc = """The radius of the top of the cylinder - i.e. the face located
+ along the positive axis. If you author radiusTop you must also
+ author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Capsule_1 "Capsule_1" (
+ doc = """Defines a primitive capsule, i.e. a cylinder capped by two half
+ spheres, with potentially different radii, centered at the origin, and whose
+ spine is along the specified axis.
+ The spherical cap heights (sagitta) of the two endcaps are a function of
+ the relative radii of the endcaps, such that cylinder tangent and sphere
+ tangent are coincident and maintain C1 continuity."""
+)
+{
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = "The axis along which the spine of the capsule is aligned"
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent = [(-0.5, -0.5, -1), (0.5, 0.5, 1)] (
+ doc = """Extent is re-defined on Capsule only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ double height = 1 (
+ doc = """The length of the capsule's spine along the specified
+ axis excluding the size of the two half spheres, i.e.
+ the length of the cylinder portion of the capsule.
+ If you author height you must also author extent.
+ \\sa GetExtentAttr()"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double radiusBottom = 0.5 (
+ doc = """The radius of the capping sphere at the bottom of the capsule -
+ i.e. the sphere located in the direction of the negative axis. If
+ you author radius you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radiusTop = 0.5 (
+ doc = """The radius of the capping sphere at the top of the capsule -
+ i.e. the sphere in the direction of the positive axis. If you
+ author radius you must also author extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Plane "Plane" (
+ doc = """Defines a primitive plane, centered at the origin, and is defined by
+ a cardinal axis, width, and length. The plane is double-sided by default.
+
+ The axis of width and length are perpendicular to the plane's axis:
+
+ axis | width | length
+ ----- | ------ | -------
+ X | z-axis | y-axis
+ Y | x-axis | z-axis
+ Z | x-axis | y-axis
+
+ """
+)
+{
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the surface of the plane is aligned. When set
+ to 'Z' the plane is in the xy-plane; when axis is 'X' the plane is in
+ the yz-plane, and when axis is 'Y' the plane is in the xz-plane.
+
+ \\sa UsdGeomGprim::GetAxisAttr()."""
+ )
+ uniform bool doubleSided = 1 (
+ doc = """Planes are double-sided by default. Clients may also support
+ single-sided planes.
+
+ \\sa UsdGeomGprim::GetDoubleSidedAttr()"""
+ )
+ float3[] extent = [(-1, -1, 0), (1, 1, 0)] (
+ doc = """Extent is re-defined on Plane only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+ double length = 2 (
+ doc = """The length of the plane, which aligns to the y-axis when axis is
+ 'Z' or 'X', or to the z-axis when axis is 'Y'. If you author length
+ you must also author extent.
+
+ \\sa UsdGeomGprim::GetExtentAttr()"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ double width = 2 (
+ doc = """The width of the plane, which aligns to the x-axis when axis is
+ 'Z' or 'Y', or to the z-axis when axis is 'X'. If you author width
+ you must also author extent.
+
+ \\sa UsdGeomGprim::GetExtentAttr()"""
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "PointBased" (
+ doc = """Base class for all UsdGeomGprims that possess points,
+ providing common attributes such as normals and velocities."""
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Mesh "Mesh" (
+ doc = """Encodes a mesh with optional subdivision properties and features.
+
+ As a point-based primitive, meshes are defined in terms of points that
+ are connected into edges and faces. Many references to meshes use the
+ term 'vertex' in place of or interchangeably with 'points', while some
+ use 'vertex' to refer to the 'face-vertices' that define a face. To
+ avoid confusion, the term 'vertex' is intentionally avoided in favor of
+ 'points' or 'face-vertices'.
+
+ The connectivity between points, edges and faces is encoded using a
+ common minimal topological description of the faces of the mesh. Each
+ face is defined by a set of face-vertices using indices into the Mesh's
+ _points_ array (inherited from UsdGeomPointBased) and laid out in a
+ single linear _faceVertexIndices_ array for efficiency. A companion
+ _faceVertexCounts_ array provides, for each face, the number of
+ consecutive face-vertices in _faceVertexIndices_ that define the face.
+ No additional connectivity information is required or constructed, so
+ no adjacency or neighborhood queries are available.
+
+ A key property of this mesh schema is that it encodes both subdivision
+ surfaces and simpler polygonal meshes. This is achieved by varying the
+ _subdivisionScheme_ attribute, which is set to specify Catmull-Clark
+ subdivision by default, so polygonal meshes must always be explicitly
+ declared. The available subdivision schemes and additional subdivision
+ features encoded in optional attributes conform to the feature set of
+ OpenSubdiv
+ (https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html).
+
+ \\anchor UsdGeom_Mesh_Primvars
+ __A Note About Primvars__
+
+ The following list clarifies the number of elements for and the
+ interpolation behavior of the different primvar interpolation types
+ for meshes:
+
+ - __constant__: One element for the entire mesh; no interpolation.
+ - __uniform__: One element for each face of the mesh; elements are
+ typically not interpolated but are inherited by other faces derived
+ from a given face (via subdivision, tessellation, etc.).
+ - __varying__: One element for each point of the mesh;
+ interpolation of point data is always linear.
+ - __vertex__: One element for each point of the mesh;
+ interpolation of point data is applied according to the
+ _subdivisionScheme_ attribute.
+ - __faceVarying__: One element for each of the face-vertices that
+ define the mesh topology; interpolation of face-vertex data may
+ be smooth or linear, according to the _subdivisionScheme_ and
+ _faceVaryingLinearInterpolation_ attributes.
+
+ Primvar interpolation types and related utilities are described more
+ generally in \\ref Usd_InterpolationVals.
+
+ \\anchor UsdGeom_Mesh_Normals
+ __A Note About Normals__
+
+ Normals should not be authored on a subdivision mesh, since subdivision
+ algorithms define their own normals. They should only be authored for
+ polygonal meshes (_subdivisionScheme_ = \"none\").
+
+ The _normals_ attribute inherited from UsdGeomPointBased is not a generic
+ primvar, but the number of elements in this attribute will be determined by
+ its _interpolation_. See .
+ If _normals_ and _primvars:normals_ are both specified, the latter has
+ precedence. If a polygonal mesh specifies __neither__ _normals_ nor
+ _primvars:normals_, then it should be treated and rendered as faceted,
+ with no attempt to compute smooth normals.
+
+ The normals generated for smooth subdivision schemes, e.g. Catmull-Clark
+ and Loop, will likewise be smooth, but others, e.g. Bilinear, may be
+ discontinuous between faces and/or within non-planar irregular faces."""
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ int[] cornerIndices = [] (
+ doc = """The indices of points for which a corresponding sharpness
+ value is specified in _cornerSharpnesses_ (so the size of this array
+ must match that of _cornerSharpnesses_)."""
+ )
+ float[] cornerSharpnesses = [] (
+ doc = """The sharpness values associated with a corresponding set of
+ points specified in _cornerIndices_ (so the size of this array must
+ match that of _cornerIndices_). Use the constant `SHARPNESS_INFINITE`
+ for a perfectly sharp corner."""
+ )
+ int[] creaseIndices = [] (
+ doc = """The indices of points grouped into sets of successive pairs
+ that identify edges to be creased. The size of this array must be
+ equal to the sum of all elements of the _creaseLengths_ attribute."""
+ )
+ int[] creaseLengths = [] (
+ doc = """The length of this array specifies the number of creases
+ (sets of adjacent sharpened edges) on the mesh. Each element gives
+ the number of points of each crease, whose indices are successively
+ laid out in the _creaseIndices_ attribute. Since each crease must
+ be at least one edge long, each element of this array must be at
+ least two."""
+ )
+ float[] creaseSharpnesses = [] (
+ doc = """The per-crease or per-edge sharpness values for all creases.
+ Since _creaseLengths_ encodes the number of points in each crease,
+ the number of elements in this array will be either len(creaseLengths)
+ or the sum over all X of (creaseLengths[X] - 1). Note that while
+ the RI spec allows each crease to have either a single sharpness
+ or a value per-edge, USD will encode either a single sharpness
+ per crease on a mesh, or sharpnesses for all edges making up
+ the creases on a mesh. Use the constant `SHARPNESS_INFINITE` for a
+ perfectly sharp crease."""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ token faceVaryingLinearInterpolation = "cornersPlus1" (
+ allowedTokens = ["none", "cornersOnly", "cornersPlus1", "cornersPlus2", "boundaries", "all"]
+ doc = '''Specifies how elements of a primvar of interpolation type
+ "faceVarying" are interpolated for subdivision surfaces. Interpolation
+ can be as smooth as a "vertex" primvar or constrained to be linear at
+ features specified by several options. Valid values correspond to
+ choices available in OpenSubdiv:
+
+ - __none__: No linear constraints or sharpening, smooth everywhere
+ - __cornersOnly__: Sharpen corners of discontinuous boundaries only,
+ smooth everywhere else
+ - __cornersPlus1__: The default, same as "cornersOnly" plus additional
+ sharpening at points where three or more distinct face-varying
+ values occur
+ - __cornersPlus2__: Same as "cornersPlus1" plus additional sharpening
+ at points with at least one discontinuous boundary corner or
+ only one discontinuous boundary edge (a dart)
+ - __boundaries__: Piecewise linear along discontinuous boundaries,
+ smooth interior
+ - __all__: Piecewise linear everywhere
+
+ These are illustrated and described in more detail in the OpenSubdiv
+ documentation:
+ https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#face-varying-interpolation-rules'''
+ )
+ int[] faceVertexCounts (
+ doc = """Provides the number of vertices in each face of the mesh,
+ which is also the number of consecutive indices in _faceVertexIndices_
+ that define the face. The length of this attribute is the number of
+ faces in the mesh. If this attribute has more than
+ one timeSample, the mesh is considered to be topologically varying."""
+ )
+ int[] faceVertexIndices (
+ doc = """Flat list of the index (into the _points_ attribute) of each
+ vertex of each face in the mesh. If this attribute has more than
+ one timeSample, the mesh is considered to be topologically varying."""
+ )
+ int[] holeIndices = [] (
+ doc = """The indices of all faces that should be treated as holes,
+ i.e. made invisible. This is traditionally a feature of subdivision
+ surfaces and not generally applied to polygonal meshes."""
+ )
+ token interpolateBoundary = "edgeAndCorner" (
+ allowedTokens = ["none", "edgeOnly", "edgeAndCorner"]
+ doc = '''Specifies how subdivision is applied for faces adjacent to
+ boundary edges and boundary points. Valid values correspond to choices
+ available in OpenSubdiv:
+
+ - __none__: No boundary interpolation is applied and boundary faces are
+ effectively treated as holes
+ - __edgeOnly__: A sequence of boundary edges defines a smooth curve to
+ which the edges of subdivided boundary faces converge
+ - __edgeAndCorner__: The default, similar to "edgeOnly" but the smooth
+ boundary curve is made sharp at corner points
+
+ These are illustrated and described in more detail in the OpenSubdiv
+ documentation:
+ https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#boundary-interpolation-rules'''
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ uniform token subdivisionScheme = "catmullClark" (
+ allowedTokens = ["catmullClark", "loop", "bilinear", "none"]
+ doc = '''The subdivision scheme to be applied to the surface.
+ Valid values are:
+
+ - __catmullClark__: The default, Catmull-Clark subdivision; preferred
+ for quad-dominant meshes (generalizes B-splines); interpolation
+ of point data is smooth (non-linear)
+ - __loop__: Loop subdivision; preferred for purely triangular meshes;
+ interpolation of point data is smooth (non-linear)
+ - __bilinear__: Subdivision reduces all faces to quads (topologically
+ similar to "catmullClark"); interpolation of point data is bilinear
+ - __none__: No subdivision, i.e. a simple polygonal mesh; interpolation
+ of point data is linear
+
+ Polygonal meshes are typically lighter weight and faster to render,
+ depending on renderer and render mode. Use of "bilinear" will produce
+ a similar shape to a polygonal mesh and may offer additional guarantees
+ of watertightness and additional subdivision features (e.g. holes) but
+ may also not respect authored normals.'''
+ )
+ token triangleSubdivisionRule = "catmullClark" (
+ allowedTokens = ["catmullClark", "smooth"]
+ doc = '''Specifies an option to the subdivision rules for the
+ Catmull-Clark scheme to try and improve undesirable artifacts when
+ subdividing triangles. Valid values are "catmullClark" for the
+ standard rules (the default) and "smooth" for the improvement.
+
+ See https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#triangle-subdivision-rule'''
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class TetMesh "TetMesh" (
+ doc = """Encodes a tetrahedral mesh. A tetrahedral mesh is defined as a set of
+ tetrahedra. Each tetrahedron is defined by a set of 4 points, with the
+ triangles of the tetrahedron determined from these 4 points as described in
+ the tetVertexIndices attribute description. The mesh surface faces
+ are encoded as triangles. Surface faces must be provided for consumers
+ that need to do surface calculations, such as renderers or consumers using
+ physics attachments. Both tetrahedra and surface face definitions use
+ indices into the TetMesh's points attribute, inherited from
+ UsdGeomPointBased."""
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ int3[] surfaceFaceVertexIndices (
+ doc = """surfaceFaceVertexIndices defines the triangle
+ surface faces indices wrt. points of the tetmesh surface. Again
+ the orientation attribute inherited from UsdGeomPrim should be
+ set accordingly. The orientation for faces of tetrahedra and
+ surface faces must match."""
+ )
+ int4[] tetVertexIndices (
+ doc = '''Flat list of the index (into the points attribute) of
+ each vertex of each tetrahedron in the mesh. Each int4 corresponds to the
+ indices of a single tetrahedron. Users should set the orientation
+ attribute of UsdGeomPrim accordingly. That is if the orientation
+ is "rightHanded", the CCW face ordering of a tetrahedron is
+ [123],[032],[013],[021] with respect to the int4. This results in the
+ normals facing outward from the center of the tetrahedron. The following
+ diagram shows the face ordering of an unwrapped tetrahedron with
+ "rightHanded" orientation.
+
+ \\image html USDTetMeshRightHanded.svg
+
+ If the orientation attribute is set to "leftHanded" the face
+ ordering of the tetrahedron is [321],[230],[310],[120] and the
+ leftHanded CW face normals point outward from the center of the
+ tetrahedron. The following diagram shows the face ordering of an
+ unwrapped tetrahedron with "leftHanded" orientation.
+
+ \\image html USDTetMeshLeftHanded.svg
+
+ Setting the orientation attribute to align with the
+ ordering of the int4 for the tetrahedrons is the responsibility of the
+ user.'''
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class GeomSubset "GeomSubset" (
+ doc = """Encodes a subset of a piece of geometry (i.e. a UsdGeomImageable)
+ as a set of indices. Currently supports encoding subsets of faces,
+ points, edges, and tetrahedrons.
+
+ To apply to a geometric prim, a GeomSubset prim must be the prim's direct
+ child in namespace, and possess a concrete defining specifier (i.e. def).
+ This restriction makes it easy and efficient to discover subsets of a prim.
+ We might want to relax this restriction if it's common to have multiple
+ families of subsets on a gprim and if it's useful to be able to
+ organize subsets belonging to a family under a common scope. See
+ 'familyName' attribute for more info on defining a family of subsets.
+
+ Note that a GeomSubset isn't an imageable (i.e. doesn't derive from
+ UsdGeomImageable). So, you can't author visibility for it or
+ override its purpose.
+
+ Materials are bound to GeomSubsets just as they are for regular
+ geometry using API available in UsdShade (UsdShadeMaterial::Bind).
+"""
+)
+{
+ uniform token elementType = "face" (
+ allowedTokens = ["face", "point", "edge", "tetrahedron"]
+ doc = """The type of element that the indices target. \"elementType\" can
+ have one of the following values:
+
face: Identifies faces on a Gprim's surface. For a
+ UsdGeomMesh, each element of the _indices_ attribute would refer to
+ an element of the Mesh's _faceCounts_ attribute. For a UsdGeomTetMesh,
+ each element of the _indices_ attribute would refer to an element of
+ the Mesh's _surfaceFaceVertexIndices_ attribute.
+
point: for any UsdGeomPointBased, each
+ element of the _indices_ attribute would refer to an element of the
+ Mesh's _points_ attribute
+
edge: for any UsdGeomMesh, each pair of elements
+ in the _indices_ attribute would refer to a pair of points of the
+ Mesh's _points_ attribute that are connected as an implicit edge on the
+ Mesh. These edges are derived from the Mesh's _faceVertexIndices_
+ attribute. Edges are not currently defined for a UsdGeomTetMesh, but
+ could be derived from all tetrahedron edges or surface face edges only
+ if a specific use-case arises.
+
tetrahedron: for any UsdGeomTetMesh, each element of the
+ _indices_ attribute would refer to an element of the TetMesh's
+ _tetVertexIndices_ attribute.
+
"""
+ )
+ uniform token familyName = "" (
+ doc = '''The name of the family of subsets that this subset belongs to.
+ This is optional and is primarily useful when there are multiple
+ families of subsets under a geometric prim. In some cases, this could
+ also be used for achieving proper roundtripping of subset data between
+ DCC apps.
+ When multiple subsets belonging to a prim have the same familyName, they
+ are said to belong to the family. A familyType value can be
+ encoded on the owner of a family of subsets as a token using the static
+ method UsdGeomSubset::SetFamilyType(). "familyType" can have one of the
+ following values:
+
UsdGeomTokens->partition: implies that every element of
+ the whole geometry appears exactly once in only one of the subsets
+ belonging to the family.
+
UsdGeomTokens->nonOverlapping: an element that appears in one
+ subset may not appear in any other subset belonging to the family, and
+ appears only once in the subset in which it appears.
+
UsdGeomTokens->unrestricted: implies that there are no
+ restrictions w.r.t. the membership of elements in the subsets. They
+ could be overlapping and the union of all subsets in the family may
+ not represent the whole.
+
+ \\note The validity of subset data is not enforced by the authoring
+ APIs, however they can be checked using UsdGeomSubset::ValidateFamily().
+ '''
+ )
+ int[] indices = [] (
+ doc = """The set of indices included in this subset. The indices need not
+ be sorted, but the same index should not appear more than once. Indices
+ are invalid if outside the range [0, elementCount) for the given time on
+ the parent geometric prim."""
+ )
+}
+
+class NurbsPatch "NurbsPatch" (
+ doc = """Encodes a rational or polynomial non-uniform B-spline
+ surface, with optional trim curves.
+
+ The encoding mostly follows that of RiNuPatch and RiTrimCurve:
+ https://renderman.pixar.com/resources/RenderMan_20/geometricPrimitives.html#rinupatch , with some minor renaming and coalescing for clarity.
+
+ The layout of control vertices in the points attribute inherited
+ from UsdGeomPointBased is row-major with U considered rows, and V columns.
+
+ \\anchor UsdGeom_NurbsPatch_Form
+ NurbsPatch Form
+
+ The authored points, orders, knots, weights, and ranges are all that is
+ required to render the nurbs patch. However, the only way to model closed
+ surfaces with nurbs is to ensure that the first and last control points
+ along the given axis are coincident. Similarly, to ensure the surface is
+ not only closed but also C2 continuous, the last order - 1 control
+ points must be (correspondingly) coincident with the first order - 1
+ control points, and also the spacing of the last corresponding knots
+ must be the same as the first corresponding knots.
+
+ Form is provided as an aid to interchange between modeling and
+ animation applications so that they can robustly identify the intent with
+ which the surface was modelled, and take measures (if they are able) to
+ preserve the continuity/concidence constraints as the surface may be rigged
+ or deformed.
+ - An open-form NurbsPatch has no continuity constraints.
+ - A closed-form NurbsPatch expects the first and last control points
+ to overlap
+ - A periodic-form NurbsPatch expects the first and last
+ order - 1 control points to overlap.
+
+ Nurbs vs Subdivision Surfaces
+
+ Nurbs are an important modeling primitive in CAD/CAM tools and early
+ computer graphics DCC's. Because they have a natural UV parameterization
+ they easily support \"trim curves\", which allow smooth shapes to be
+ carved out of the surface.
+
+ However, the topology of the patch is always rectangular, and joining two
+ nurbs patches together (especially when they have differing numbers of
+ spans) is difficult to do smoothly. Also, nurbs are not supported by
+ the Ptex texturing technology (http://ptex.us).
+
+ Neither of these limitations are shared by subdivision surfaces; therefore,
+ although they do not subscribe to trim-curve-based shaping, subdivs are
+ often considered a more flexible modeling primitive.
+ """
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ double[] pointWeights (
+ doc = """Optionally provides \"w\" components for each control point,
+ thus must be the same length as the points attribute. If authored,
+ the patch will be rational. If unauthored, the patch will be
+ polynomial, i.e. weight for all points is 1.0.
+ \\note Some DCC's pre-weight the points, but in this schema,
+ points are not pre-weighted."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ int[] trimCurve:counts (
+ doc = '''Each element specifies how many curves are present in each
+ "loop" of the trimCurve, and the length of the array determines how
+ many loops the trimCurve contains. The sum of all elements is the
+ total nuber of curves in the trim, to which we will refer as
+ nCurves in describing the other trim attributes.'''
+ )
+ double[] trimCurve:knots (
+ doc = """Flat list of parametric values for each of the
+ nCurves curves. There will be as many knots as the sum over
+ all elements of vertexCounts plus the sum over all elements of
+ orders."""
+ )
+ int[] trimCurve:orders (
+ doc = "Flat list of orders for each of the nCurves curves."
+ )
+ double3[] trimCurve:points (
+ doc = """Flat list of homogeneous 2D points (u, v, w) that comprise
+ the nCurves curves. The number of points should be equal to the
+ um over all elements of vertexCounts."""
+ )
+ double2[] trimCurve:ranges (
+ doc = """Flat list of minimum and maximum parametric values
+ (as defined by knots) for each of the nCurves curves."""
+ )
+ int[] trimCurve:vertexCounts (
+ doc = """Flat list of number of vertices for each of the
+ nCurves curves."""
+ )
+ uniform token uForm = "open" (
+ allowedTokens = ["open", "closed", "periodic"]
+ doc = '''Interpret the control grid and knot vectors as representing
+ an open, geometrically closed, or geometrically closed and C2 continuous
+ surface along the U dimension.
+ \\sa "NurbsPatch Form" '''
+ )
+ double[] uKnots (
+ doc = """Knot vector for U direction providing U parameterization.
+ The length of this array must be ( uVertexCount + uOrder ), and its
+ entries must take on monotonically increasing values."""
+ )
+ int uOrder (
+ doc = """Order in the U direction. Order must be positive and is
+ equal to the degree of the polynomial basis to be evaluated, plus 1."""
+ )
+ double2 uRange (
+ doc = """Provides the minimum and maximum parametric values (as defined
+ by uKnots) over which the surface is actually defined. The minimum
+ must be less than the maximum, and greater than or equal to the
+ value of uKnots[uOrder-1]. The maxium must be less than or equal
+ to the last element's value in uKnots."""
+ )
+ int uVertexCount (
+ doc = """Number of vertices in the U direction. Should be at least as
+ large as uOrder."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ uniform token vForm = "open" (
+ allowedTokens = ["open", "closed", "periodic"]
+ doc = '''Interpret the control grid and knot vectors as representing
+ an open, geometrically closed, or geometrically closed and C2 continuous
+ surface along the V dimension.
+ \\sa "NurbsPatch Form" '''
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ double[] vKnots (
+ doc = """Knot vector for V direction providing U parameterization.
+ The length of this array must be ( vVertexCount + vOrder ), and its
+ entries must take on monotonically increasing values."""
+ )
+ int vOrder (
+ doc = """Order in the V direction. Order must be positive and is
+ equal to the degree of the polynomial basis to be evaluated, plus 1."""
+ )
+ double2 vRange (
+ doc = """Provides the minimum and maximum parametric values (as defined
+ by vKnots) over which the surface is actually defined. The minimum
+ must be less than the maximum, and greater than or equal to the
+ value of vKnots[vOrder-1]. The maxium must be less than or equal
+ to the last element's value in vKnots."""
+ )
+ int vVertexCount (
+ doc = """Number of vertices in the V direction. Should be at least as
+ large as vOrder."""
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "Curves" (
+ doc = """Base class for UsdGeomBasisCurves, UsdGeomNurbsCurves, and
+ UsdGeomHermiteCurves. The BasisCurves schema is designed to be
+ analagous to offline renderers' notion of batched curves (such as
+ the classical RIB definition via Basis and Curves statements),
+ while the NurbsCurve schema is designed to be analgous to the
+ NURBS curves found in packages like Maya and Houdini while
+ retaining their consistency with the RenderMan specification for
+ NURBS Patches. HermiteCurves are useful for the
+ interchange of animation guides and paths.
+
+ It is safe to use the length of the curve vertex count to derive
+ the number of curves and the number and layout of curve vertices,
+ but this schema should NOT be used to derive the number of curve
+ points. While vertex indices are implicit in all shipped
+ descendent types of this schema, one should not assume that all
+ internal or future shipped schemas will follow this pattern. Be
+ sure to key any indexing behavior off the concrete type, not this
+ abstract type.
+ """
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ int[] curveVertexCounts (
+ doc = """Curves-derived primitives can represent multiple distinct,
+ potentially disconnected curves. The length of 'curveVertexCounts'
+ gives the number of such curves, and each element describes the
+ number of vertices in the corresponding curve"""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ float[] widths (
+ doc = """Provides width specification for the curves, whose application
+ will depend on whether the curve is oriented (normals are defined for
+ it), in which case widths are \"ribbon width\", or unoriented, in which
+ case widths are cylinder width. 'widths' is not a generic Primvar,
+ but the number of elements in this attribute will be determined by
+ its 'interpolation'. See . If 'widths'
+ and 'primvars:widths' are both specified, the latter has precedence."""
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class BasisCurves "BasisCurves" (
+ doc = """BasisCurves are a batched curve representation analogous to the
+ classic RIB definition via Basis and Curves statements. BasisCurves are
+ often used to render dense aggregate geometry like hair or grass.
+
+ A 'matrix' and 'vstep' associated with the basis are used to
+ interpolate the vertices of a cubic BasisCurves. (The basis attribute
+ is unused for linear BasisCurves.)
+
+ A single prim may have many curves whose count is determined implicitly by
+ the length of the curveVertexCounts vector. Each individual curve is
+ composed of one or more segments. Each segment is defined by four vertices
+ for cubic curves and two vertices for linear curves. See the next section
+ for more information on how to map curve vertex counts to segment counts.
+
+ Segment Indexing
+ Interpolating a curve requires knowing how to decompose it into its
+ individual segments.
+
+ The segments of a cubic curve are determined by the vertex count,
+ the wrap (periodicity), and the vstep of the basis. For linear
+ curves, the basis token is ignored and only the vertex count and
+ wrap are needed.
+
+ cubic basis | vstep
+ ------------- | ------
+ bezier | 3
+ catmullRom | 1
+ bspline | 1
+
+ The first segment of a cubic (nonperiodic) curve is always defined by its
+ first four points. The vstep is the increment used to determine what
+ vertex indices define the next segment. For a two segment (nonperiodic)
+ bspline basis curve (vstep = 1), the first segment will be defined by
+ interpolating vertices [0, 1, 2, 3] and the second segment will be defined
+ by [1, 2, 3, 4]. For a two segment bezier basis curve (vstep = 3), the
+ first segment will be defined by interpolating vertices [0, 1, 2, 3] and
+ the second segment will be defined by [3, 4, 5, 6]. If the vstep is not
+ one, then you must take special care to make sure that the number of cvs
+ properly divides by your vstep. (The indices described are relative to
+ the initial vertex index for a batched curve.)
+
+ For periodic curves, at least one of the curve's initial vertices are
+ repeated to close the curve. For cubic curves, the number of vertices
+ repeated is '4 - vstep'. For linear curves, only one vertex is repeated
+ to close the loop.
+
+ Pinned curves are a special case of nonperiodic curves that only affects
+ the behavior of cubic Bspline and Catmull-Rom curves. To evaluate or render
+ pinned curves, a client must effectively add 'phantom points' at the
+ beginning and end of every curve in a batch. These phantom points
+ are injected to ensure that the interpolated curve begins at P[0] and
+ ends at P[n-1].
+
+ For a curve with initial point P[0] and last point P[n-1], the phantom
+ points are defined as.
+ P[-1] = 2 * P[0] - P[1]
+ P[n] = 2 * P[n-1] - P[n-2]
+
+ Pinned cubic curves will (usually) have to be unpacked into the standard
+ nonperiodic representation before rendering. This unpacking can add some
+ additional overhead. However, using pinned curves reduces the amount of
+ data recorded in a scene and (more importantly) better records the
+ authors' intent for interchange.
+
+ \\note The additional phantom points mean that the minimum curve vertex
+ count for cubic bspline and catmullRom curves is 2.
+
+ Linear curve segments are defined by two vertices.
+ A two segment linear curve's first segment would be defined by
+ interpolating vertices [0, 1]. The second segment would be defined by
+ vertices [1, 2]. (Again, for a batched curve, indices are relative to
+ the initial vertex index.)
+
+ When validating curve topology, each renderable entry in the
+ curveVertexCounts vector must pass this check.
+
+ type | wrap | validitity
+ ------- | --------------------------- | ----------------
+ linear | nonperiodic | curveVertexCounts[i] > 2
+ linear | periodic | curveVertexCounts[i] > 3
+ cubic | nonperiodic | (curveVertexCounts[i] - 4) % vstep == 0
+ cubic | periodic | (curveVertexCounts[i]) % vstep == 0
+ cubic | pinned (catmullRom/bspline) | (curveVertexCounts[i] - 2) >= 0
+
+ Cubic Vertex Interpolation
+
+ \\image html USDCurveBasisMatrix.png width=750
+
+ Linear Vertex Interpolation
+
+ Linear interpolation is always used on curves of type linear.
+ 't' with domain [0, 1], the curve is defined by the equation
+ P0 * (1-t) + P1 * t. t at 0 describes the first point and t at 1 describes
+ the end point.
+
+ Primvar Interpolation
+
+ For cubic curves, primvar data can be either interpolated cubically between
+ vertices or linearly across segments. The corresponding token
+ for cubic interpolation is 'vertex' and for linear interpolation is
+ 'varying'. Per vertex data should be the same size as the number
+ of vertices in your curve. Segment varying data is dependent on the
+ wrap (periodicity) and number of segments in your curve. For linear curves,
+ varying and vertex data would be interpolated the same way. By convention
+ varying is the preferred interpolation because of the association of
+ varying with linear interpolation.
+
+ \\image html USDCurvePrimvars.png
+
+ To convert an entry in the curveVertexCounts vector into a segment count
+ for an individual curve, apply these rules. Sum up all the results in
+ order to compute how many total segments all curves have.
+
+ The following tables describe the expected segment count for the 'i'th
+ curve in a curve batch as well as the entire batch. Python syntax
+ like '[:]' (to describe all members of an array) and 'len(...)'
+ (to describe the length of an array) are used.
+
+ type | wrap | curve segment count | batch segment count
+ ------- | --------------------------- | -------------------------------------- | --------------------------
+ linear | nonperiodic | curveVertexCounts[i] - 1 | sum(curveVertexCounts[:]) - len(curveVertexCounts)
+ linear | periodic | curveVertexCounts[i] | sum(curveVertexCounts[:])
+ cubic | nonperiodic | (curveVertexCounts[i] - 4) / vstep + 1 | sum(curveVertexCounts[:] - 4) / vstep + len(curveVertexCounts)
+ cubic | periodic | curveVertexCounts[i] / vstep | sum(curveVertexCounts[:]) / vstep
+ cubic | pinned (catmullRom/bspline) | (curveVertexCounts[i] - 2) + 1 | sum(curveVertexCounts[:] - 2) + len(curveVertexCounts)
+
+ The following table descrives the expected size of varying
+ (linearly interpolated) data, derived from the segment counts computed
+ above.
+
+ wrap | curve varying count | batch varying count
+ ------------------- | ---------------------------- | ------------------------------------------------
+ nonperiodic/pinned | segmentCounts[i] + 1 | sum(segmentCounts[:]) + len(curveVertexCounts)
+ periodic | segmentCounts[i] | sum(segmentCounts[:])
+
+ Both curve types additionally define 'constant' interpolation for the
+ entire prim and 'uniform' interpolation as per curve data.
+
+
+ \\note Take care when providing support for linearly interpolated data for
+ cubic curves. Its shape doesn't provide a one to one mapping with either
+ the number of curves (like 'uniform') or the number of vertices (like
+ 'vertex') and so it is often overlooked. This is the only primitive in
+ UsdGeom (as of this writing) where this is true. For meshes, while they
+ use different interpolation methods, 'varying' and 'vertex' are both
+ specified per point. It's common to assume that curves follow a similar
+ pattern and build in structures and language for per primitive, per
+ element, and per point data only to come upon these arrays that don't
+ quite fit into either of those categories. It is
+ also common to conflate 'varying' with being per segment data and use the
+ segmentCount rules table instead of its neighboring varying data table
+ rules. We suspect that this is because for the common case of
+ nonperiodic cubic curves, both the provided segment count and varying data
+ size formula end with '+ 1'. While debugging, users may look at the double
+ '+ 1' as a mistake and try to remove it. We take this time to enumerate
+ these issues because we've fallen into them before and hope that we save
+ others time in their own implementations.
+
+ As an example of deriving per curve segment and varying primvar data counts from
+ the wrap, type, basis, and curveVertexCount, the following table is provided.
+
+ wrap | type | basis | curveVertexCount | curveSegmentCount | varyingDataCount
+ ------------- | ------- | ------- | ----------------- | ------------------ | -------------------------
+ nonperiodic | linear | N/A | [2 3 2 5] | [1 2 1 4] | [2 3 2 5]
+ nonperiodic | cubic | bezier | [4 7 10 4 7] | [1 2 3 1 2] | [2 3 4 2 3]
+ nonperiodic | cubic | bspline | [5 4 6 7] | [2 1 3 4] | [3 2 4 5]
+ periodic | cubic | bezier | [6 9 6] | [2 3 2] | [2 3 2]
+ periodic | linear | N/A | [3 7] | [3 7] | [3 7]
+
+ Tubes and Ribbons
+
+ The strictest definition of a curve as an infinitely thin wire is not
+ particularly useful for describing production scenes. The additional
+ widths and normals attributes can be used to describe cylindrical
+ tubes and or flat oriented ribbons.
+
+ Curves with only widths defined are imaged as tubes with radius
+ 'width / 2'. Curves with both widths and normals are imaged as ribbons
+ oriented in the direction of the interpolated normal vectors.
+
+ While not technically UsdGeomPrimvars, widths and normals
+ also have interpolation metadata. It's common for authored widths to have
+ constant, varying, or vertex interpolation
+ (see UsdGeomCurves::GetWidthsInterpolation()). It's common for
+ authored normals to have varying interpolation
+ (see UsdGeomPointBased::GetNormalsInterpolation()).
+
+ \\image html USDCurveHydra.png
+
+ The file used to generate these curves can be found in
+ extras/usd/examples/usdGeomExamples/basisCurves.usda. It's provided
+ as a reference on how to properly image both tubes and ribbons. The first
+ row of curves are linear; the second are cubic bezier. (We aim in future
+ releases of HdSt to fix the discontinuity seen with broken tangents to
+ better match offline renderers like RenderMan.) The yellow and violet
+ cubic curves represent cubic vertex width interpolation for which there is
+ no equivalent for linear curves.
+
+ \\note How did this prim type get its name? This prim is a portmanteau of
+ two different statements in the original RenderMan specification:
+ 'Basis' and 'Curves'.
+"""
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ uniform token basis = "bezier" (
+ allowedTokens = ["bezier", "bspline", "catmullRom"]
+ doc = """The basis specifies the vstep and matrix used for cubic
+ interpolation. \\note The 'hermite' and 'power' tokens have been
+ removed. We've provided UsdGeomHermiteCurves
+ as an alternative for the 'hermite' basis."""
+ )
+ int[] curveVertexCounts (
+ doc = """Curves-derived primitives can represent multiple distinct,
+ potentially disconnected curves. The length of 'curveVertexCounts'
+ gives the number of such curves, and each element describes the
+ number of vertices in the corresponding curve"""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ uniform token type = "cubic" (
+ allowedTokens = ["linear", "cubic"]
+ doc = """Linear curves interpolate linearly between two vertices.
+ Cubic curves use a basis matrix with four vertices to interpolate a segment."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ float[] widths (
+ doc = """Provides width specification for the curves, whose application
+ will depend on whether the curve is oriented (normals are defined for
+ it), in which case widths are \"ribbon width\", or unoriented, in which
+ case widths are cylinder width. 'widths' is not a generic Primvar,
+ but the number of elements in this attribute will be determined by
+ its 'interpolation'. See . If 'widths'
+ and 'primvars:widths' are both specified, the latter has precedence."""
+ )
+ uniform token wrap = "nonperiodic" (
+ allowedTokens = ["nonperiodic", "periodic", "pinned"]
+ doc = """If wrap is set to periodic, the curve when rendered will
+ repeat the initial vertices (dependent on the vstep) to close the
+ curve. If wrap is set to 'pinned', phantom points may be created
+ to ensure that the curve interpolation starts at P[0] and ends at P[n-1].
+ """
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class NurbsCurves "NurbsCurves" (
+ doc = """This schema is analagous to NURBS Curves in packages like Maya
+ and Houdini, often used for interchange of rigging and modeling curves.
+ Unlike Maya, this curve spec supports batching of multiple curves into a
+ single prim, widths, and normals in the schema. Additionally, we require
+ 'numSegments + 2 * degree + 1' knots (2 more than maya does). This is to
+ be more consistent with RenderMan's NURBS patch specification.
+
+ To express a periodic curve:
+ - knot[0] = knot[1] - (knots[-2] - knots[-3];
+ - knot[-1] = knot[-2] + (knot[2] - knots[1]);
+
+ To express a nonperiodic curve:
+ - knot[0] = knot[1];
+ - knot[-1] = knot[-2];
+
+ In spite of these slight differences in the spec, curves generated in Maya
+ should be preserved when roundtripping.
+
+ order and range, when representing a batched NurbsCurve should be
+ authored one value per curve. knots should be the concatentation of
+ all batched curves."""
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ int[] curveVertexCounts (
+ doc = """Curves-derived primitives can represent multiple distinct,
+ potentially disconnected curves. The length of 'curveVertexCounts'
+ gives the number of such curves, and each element describes the
+ number of vertices in the corresponding curve"""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ double[] knots (
+ doc = """Knot vector providing curve parameterization.
+ The length of the slice of the array for the ith curve
+ must be ( curveVertexCount[i] + order[i] ), and its
+ entries must take on monotonically increasing values."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ int[] order = [] (
+ doc = """Order of the curve. Order must be positive and is
+ equal to the degree of the polynomial basis to be evaluated, plus 1.
+ Its value for the 'i'th curve must be less than or equal to
+ curveVertexCount[i]"""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ double[] pointWeights (
+ doc = """Optionally provides \"w\" components for each control point,
+ thus must be the same length as the points attribute. If authored,
+ the curve will be rational. If unauthored, the curve will be
+ polynomial, i.e. weight for all points is 1.0.
+ \\note Some DCC's pre-weight the points, but in this schema,
+ points are not pre-weighted."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double2[] ranges (
+ doc = """Provides the minimum and maximum parametric values (as defined
+ by knots) over which the curve is actually defined. The minimum must
+ be less than the maximum, and greater than or equal to the value of the
+ knots['i'th curve slice][order[i]-1]. The maxium must be less
+ than or equal to the last element's value in knots['i'th curve slice].
+\tRange maps to (vmin, vmax) in the RenderMan spec."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ float[] widths (
+ doc = """Provides width specification for the curves, whose application
+ will depend on whether the curve is oriented (normals are defined for
+ it), in which case widths are \"ribbon width\", or unoriented, in which
+ case widths are cylinder width. 'widths' is not a generic Primvar,
+ but the number of elements in this attribute will be determined by
+ its 'interpolation'. See . If 'widths'
+ and 'primvars:widths' are both specified, the latter has precedence."""
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Points "Points" (
+ doc = """Points are analogous to the RiPoints spec.
+
+ Points can be an efficient means of storing and rendering particle
+ effects comprised of thousands or millions of small particles. Points
+ generally receive a single shading sample each, which should take
+ normals into account, if present.
+
+ While not technically UsdGeomPrimvars, the widths and normals also
+ have interpolation metadata. It's common for authored widths and normals
+ to have constant or varying interpolation."""
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ int64[] ids (
+ doc = """Ids are optional; if authored, the ids array should be the same
+ length as the points array, specifying (at each timesample if
+ point identities are changing) the id of each point. The
+ type is signed intentionally, so that clients can encode some
+ binary state on Id'd points without adding a separate
+ primvar."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ float[] widths (
+ doc = """Widths are defined as the diameter of the points, in
+ object space. 'widths' is not a generic Primvar, but
+ the number of elements in this attribute will be determined by
+ its 'interpolation'. See . If
+ 'widths' and 'primvars:widths' are both specified, the latter
+ has precedence."""
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class PointInstancer "PointInstancer" (
+ doc = """Encodes vectorized instancing of multiple, potentially
+ animated, prototypes (object/instance masters), which can be arbitrary
+ prims/subtrees on a UsdStage.
+
+ PointInstancer is a \"multi instancer\", as it allows multiple prototypes
+ to be scattered among its \"points\". We use a UsdRelationship
+ prototypes to identify and order all of the possible prototypes, by
+ targeting the root prim of each prototype. The ordering imparted by
+ relationships associates a zero-based integer with each prototype, and
+ it is these integers we use to identify the prototype of each instance,
+ compactly, and allowing prototypes to be swapped out without needing to
+ reauthor all of the per-instance data.
+
+ The PointInstancer schema is designed to scale to billions of instances,
+ which motivates the choice to split the per-instance transformation into
+ position, (quaternion) orientation, and scales, rather than a
+ 4x4 matrix per-instance. In addition to requiring fewer bytes even if
+ all elements are authored (32 bytes vs 64 for a single-precision 4x4
+ matrix), we can also be selective about which attributes need to animate
+ over time, for substantial data reduction in many cases.
+
+ Note that PointInstancer is not a Gprim, since it is not a graphical
+ primitive by any stretch of the imagination. It is, however,
+ Boundable, since we will sometimes want to treat the entire PointInstancer
+ similarly to a procedural, from the perspective of inclusion or framing.
+
+ Varying Instance Identity over Time
+
+ PointInstancers originating from simulations often have the characteristic
+ that points/instances are \"born\", move around for some time period, and then
+ die (or leave the area of interest). In such cases, billions of instances
+ may be birthed over time, while at any specific time, only a much
+ smaller number are actually alive. To encode this situation efficiently,
+ the simulator may re-use indices in the instance arrays, when a particle
+ dies, its index will be taken over by a new particle that may be birthed in
+ a much different location. This presents challenges both for
+ identity-tracking, and for motion-blur.
+
+ We facilitate identity tracking by providing an optional, animatable
+ ids attribute, that specifies the 64 bit integer ID of the particle
+ at each index, at each point in time. If the simulator keeps monotonically
+ increasing a particle-count each time a new particle is birthed, it will
+ serve perfectly as particle ids.
+
+ We facilitate motion blur for varying-topology particle streams by
+ optionally allowing per-instance velocities and angularVelocities
+ to be authored. If instance transforms are requested at a time between
+ samples and either of the velocity attributes is authored, then we will
+ not attempt to interpolate samples of positions or orientations.
+ If not authored, and the bracketing samples have the same length, then we
+ will interpolate.
+
+ Computing an Instance Transform
+
+ Each instance's transformation is a combination of the SRT affine transform
+ described by its scale, orientation, and position, applied after
+ (i.e. less locally than) the local to parent transformation computed at
+ the root of the prototype it is instancing.
+
+ If your processing of prototype geometry naturally takes into account the
+ transform of the prototype root, then this term can be omitted from the
+ computation of each instance transform, and this can be controlled when
+ computing instance transformation matrices using the
+ UsdGeomPointInstancer::PrototypeXformInclusion enumeration.
+
+ To understand the computation of the instance transform, in order to put
+ an instance of a PointInstancer into the space of the PointInstancer's
+ parent prim we do the following:
+
+ 1. Apply (most locally) the authored local to parent transformation for
+ prototypes[protoIndices[i]]
+ 2. If *scales* is authored, next apply the scaling matrix from *scales[i]*
+ 3. If *orientations* is authored: **if *angularVelocities* is authored**,
+ first multiply *orientations[i]* by the unit quaternion derived by scaling
+ *angularVelocities[i]* by the \"time differential\"
+ from the left-bracketing timeSample for *orientation* to the requested
+ evaluation time *t*, storing the result in *R*, **else** assign *R*
+ directly from *orientations[i]*. Apply the rotation matrix derived
+ from *R*.
+ 4. Apply the translation derived from *positions[i]*. If *velocities* is
+ authored, apply the translation deriving from *velocities[i]* scaled by
+ the time differential from the left-bracketing timeSample for *positions*
+ to the requested evaluation time *t*.
+ 5. Least locally, apply the transformation authored on the PointInstancer
+ prim itself (or the UsdGeomImageable::ComputeLocalToWorldTransform() of the
+ PointInstancer to put the instance directly into world space)
+
+ If neither *velocities* nor *angularVelocities* are authored, we fallback to
+ standard position and orientation computation logic (using linear
+ interpolation between timeSamples) as described by
+ .
+
+ \\anchor UsdGeom_PITimeScaling
+ Scaling Velocities for Interpolation
+
+ When computing time-differentials by which to apply velocity or
+ angularVelocity to positions or orientations, we must scale by
+ ( 1.0 / UsdStage::GetTimeCodesPerSecond() ), because velocities are recorded
+ in units/second, while we are interpolating in UsdTimeCode ordinates.
+
+ We provide both high and low-level API's for dealing with the
+ transformation as a matrix, both will compute the instance matrices using
+ multiple threads; the low-level API allows the client to cache unvarying
+ inputs so that they need not be read duplicately when computing over
+ time.
+
+ See also .
+
+ Primvars on PointInstancer
+
+ \"Primvars\" authored on a PointInstancer prim should
+ always be applied to each instance with constant interpolation at
+ the root of the instance. When you are authoring primvars on a
+ PointInstancer, think about it as if you were authoring them on a
+ point-cloud (e.g. a UsdGeomPoints gprim). The same
+ interpolation rules for points apply here, substituting
+ \"instance\" for \"point\".
+
+ In other words, the (constant) value extracted for each instance
+ from the authored primvar value depends on the authored interpolation
+ and elementSize of the primvar, as follows:
+ - constant or uniform : the entire authored value of the
+ primvar should be applied exactly to each instance.
+ - varying, vertex, or faceVarying: the first
+ elementSize elements of the authored primvar array should be assigned to
+ instance zero, the second elementSize elements should be assigned to
+ instance one, and so forth.
+
+
+ Masking Instances: \"Deactivating\" and Invising
+
+ Often a PointInstancer is created \"upstream\" in a graphics pipeline, and
+ the needs of \"downstream\" clients necessitate eliminating some of the
+ instances from further consideration. Accomplishing this pruning by
+ re-authoring all of the per-instance attributes is not very attractive,
+ since it may mean destructively editing a large quantity of data. We
+ therefore provide means of \"masking\" instances by ID, such that the
+ instance data is unmolested, but per-instance transform and primvar data
+ can be retrieved with the no-longer-desired instances eliminated from the
+ (smaller) arrays. PointInstancer allows two independent means of masking
+ instances by ID, each with different features that meet the needs of
+ various clients in a pipeline. Both pruning features' lists of ID's are
+ combined to produce the mask returned by ComputeMaskAtTime().
+
+ \\note If a PointInstancer has no authored ids attribute, the masking
+ features will still be available, with the integers specifying element
+ position in the protoIndices array rather than ID.
+
+ \\subsection UsdGeomPointInstancer_inactiveIds InactiveIds: List-edited, Unvarying Masking
+
+ The first masking feature encodes a list of IDs in a list-editable metadatum
+ called inactiveIds, which, although it does not have any similar
+ impact to stage population as \"prim activation\",
+ it shares with that feature that its application is uniform over all time.
+ Because it is list-editable, we can sparsely add and remove instances
+ from it in many layers.
+
+ This sparse application pattern makes inactiveIds a good choice when
+ further downstream clients may need to reverse masking decisions made
+ upstream, in a manner that is robust to many kinds of future changes to
+ the upstream data.
+
+ See ActivateId(), ActivateIds(), DeactivateId(), DeactivateIds(),
+ ActivateAllIds()
+
+ \\subsection UsdGeomPointInstancer_invisibleIds invisibleIds: Animatable Masking
+
+ The second masking feature encodes a list of IDs in a time-varying
+ Int64Array-valued UsdAttribute called invisibleIds , since it shares
+ with \"Imageable visibility\"
+ the ability to animate object visibility.
+
+ Unlike inactiveIds, overriding a set of opinions for invisibleIds
+ is not at all straightforward, because one will, in general need to
+ reauthor (in the overriding layer) **all** timeSamples for the attribute
+ just to change one Id's visibility state, so it cannot be authored
+ sparsely. But it can be a very useful tool for situations like encoding
+ pre-computed camera-frustum culling of geometry when either or both of
+ the instances or the camera is animated.
+
+ See VisId(), VisIds(), InvisId(), InvisIds(), VisAllIds()
+
+ Processing and Not Processing Prototypes
+
+ Any prim in the scenegraph can be targeted as a prototype by the
+ prototypes relationship. We do not, however, provide a specific
+ mechanism for identifying prototypes as geometry that should not be drawn
+ (or processed) in their own, local spaces in the scenegraph. We
+ encourage organizing all prototypes as children of the PointInstancer
+ prim that consumes them, and pruning \"raw\" processing and drawing
+ traversals when they encounter a PointInstancer prim; this is what the
+ UsdGeomBBoxCache and UsdImaging engines do.
+
+ There is a pattern one can deploy for organizing the prototypes
+ such that they will automatically be skipped by basic UsdPrim::GetChildren()
+ or UsdPrimRange traversals. Usd prims each have a
+ \"specifier\" of \"def\", \"over\", or \"class\". The
+ default traversals skip over prims that are \"pure overs\" or classes. So
+ to protect prototypes from all generic traversals and processing, place
+ them under a prim that is just an \"over\". For example,
+ \\code
+ 01 def PointInstancer \"Crowd_Mid\"
+ 02 {
+ 03 rel prototypes = [ , ]
+ 04
+ 05 over \"Prototypes\"
+ 06 {
+ 07 def \"MaleThin_Business\" (
+ 08 references = [@MaleGroupA/usd/MaleGroupA.usd@]
+ 09 variants = {
+ 10 string modelingVariant = \"Thin\"
+ 11 string costumeVariant = \"BusinessAttire\"
+ 12 }
+ 13 )
+ 14 { ... }
+ 15
+ 16 def \"MaleThin_Casual\"
+ 17 ...
+ 18 }
+ 19 }
+ \\endcode
+ """
+)
+{
+ vector3f[] accelerations (
+ doc = """If authored, per-instance 'accelerations' will be used with
+ velocities to compute positions between samples for the 'positions'
+ attribute rather than interpolating between neighboring 'positions'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ vector3f[] angularVelocities (
+ doc = """If authored, per-instance angular velocity vector to be used for
+ interoplating orientations. Angular velocities should be considered
+ mandatory if both protoIndices and orientations are animated.
+ Angular velocity is measured in degrees per second. To convert
+ to degrees per UsdTimeCode, divide by
+ UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ int64[] ids (
+ doc = """Ids are optional; if authored, the ids array should be the same
+ length as the protoIndices array, specifying (at each timeSample if
+ instance identities are changing) the id of each instance. The
+ type is signed intentionally, so that clients can encode some
+ binary state on Id'd instances without adding a separate primvar.
+ See also \\ref UsdGeomPointInstancer_varyingTopo"""
+ )
+ int64[] invisibleIds = [] (
+ doc = """A list of id's to make invisible at the evaluation time.
+ See ."""
+ )
+ quath[] orientations (
+ doc = """If authored, per-instance orientation of each instance about its
+ prototype's origin, represented as a unit length quaternion, which
+ allows us to encode it with sufficient precision in a compact GfQuath.
+
+ It is client's responsibility to ensure that authored quaternions are
+ unit length; the convenience API below for authoring orientations from
+ rotation matrices will ensure that quaternions are unit length, though
+ it will not make any attempt to select the \"better (for interpolation
+ with respect to neighboring samples)\" of the two possible quaternions
+ that encode the rotation.
+
+ See also ."""
+ )
+ quatf[] orientationsf (
+ doc = """If authored, per-instance orientation of each instance about its
+ prototype's origin, represented as a unit length quaternion, encoded
+ as a GfQuatf to support higher precision computations.
+
+ It is client's responsibility to ensure that authored quaternions are
+ unit length; the convenience API below for authoring orientations from
+ rotation matrices will ensure that quaternions are unit length, though
+ it will not make any attempt to select the \"better (for interpolation
+ with respect to neighboring samples)\" of the two possible quaternions
+ that encode the rotation. Note that if the earliest time sample (or
+ default value if there are no time samples) of orientationsf is not empty
+ orientationsf will be preferred over orientations if both are authored.
+
+ See also ."""
+ )
+ point3f[] positions (
+ doc = """Required property. Per-instance position. See also
+ ."""
+ )
+ int[] protoIndices (
+ doc = """Required property. Per-instance index into
+ prototypes relationship that identifies what geometry should be
+ drawn for each instance. Topology attribute - can be animated,
+ but at a potential performance impact for streaming."""
+ )
+ rel prototypes (
+ doc = """Required property. Orders and targets the prototype root
+ prims, which can be located anywhere in the scenegraph that is convenient,
+ although we promote organizing prototypes as children of the
+ PointInstancer. The position of a prototype in this relationship defines
+ the value an instance would specify in the protoIndices attribute to
+ instance that prototype. Since relationships are uniform, this property
+ cannot be animated."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ float3[] scales (
+ doc = """If authored, per-instance scale to be applied to
+ each instance, before any rotation is applied.
+
+ See also ."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, per-instance 'velocities' will be used to
+ compute positions between samples for the 'positions' attribute,
+ rather than interpolating between neighboring 'positions' samples.
+ Velocities should be considered mandatory if both protoIndices
+ and positions are animated. Velocity is measured in position
+ units per second, as per most simulation software. To convert to
+ position units per UsdTimeCode, divide by
+ UsdStage::GetTimeCodesPerSecond().
+
+ See also
+ ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Camera "Camera" (
+ doc = """Transformable camera.
+
+ Describes optical properties of a camera via a common set of attributes
+ that provide control over the camera's frustum as well as its depth of
+ field. For stereo, the left and right camera are individual prims tagged
+ through the \"stereoRole attribute\".
+
+ There is a corresponding class GfCamera, which can hold the state of a
+ camera (at a particular time). and
+ convert between a USD camera prim and
+ a GfCamera.
+
+ To obtain the camera's location in world space, call the following on a
+ UsdGeomCamera 'camera':
+ \\code
+ GfMatrix4d camXform = camera.ComputeLocalToWorldTransform(time);
+ \\endcode
+ \\note
+ Cameras in USD are always \"Y up\", regardless of the stage's orientation
+ (i.e. UsdGeomGetStageUpAxis()). This means that the inverse of
+ 'camXform' (the VIEW half of the MODELVIEW transform in OpenGL parlance)
+ will transform the world such that the camera is at the origin, looking
+ down the -Z axis, with +Y as the up axis, and +X pointing to the right.
+ This describes a __right handed coordinate system__.
+
+ Units of Measure for Camera Properties
+
+ Despite the familiarity of millimeters for specifying some physical
+ camera properties, UsdGeomCamera opts for greater consistency with all
+ other UsdGeom schemas, which measure geometric properties in scene units,
+ as determined by UsdGeomGetStageMetersPerUnit(). We do make a
+ concession, however, in that lens and filmback properties are measured in
+ __tenths of a scene unit__ rather than \"raw\" scene units. This means
+ that with the fallback value of .01 for _metersPerUnit_ - i.e. scene unit
+ of centimeters - then these \"tenth of scene unit\" properties are
+ effectively millimeters.
+
+ \\note If one adds a Camera prim to a UsdStage whose scene unit is not
+ centimeters, the fallback values for filmback properties will be
+ incorrect (or at the least, unexpected) in an absolute sense; however,
+ proper imaging through a \"default camera\" with focusing disabled depends
+ only on ratios of the other properties, so the camera is still usable.
+ However, it follows that if even one property is authored in the correct
+ scene units, then they all must be.
+
+
+ \\sa \\ref UsdGeom_LinAlgBasics
+ """
+)
+{
+ float4[] clippingPlanes = [] (
+ doc = """Additional, arbitrarily oriented clipping planes.
+ A vector (a,b,c,d) encodes a clipping plane that cuts off
+ (x,y,z) with a * x + b * y + c * z + d * 1 < 0 where (x,y,z)
+ are the coordinates in the camera's space."""
+ )
+ float2 clippingRange = (1, 1000000) (
+ doc = """Near and far clipping distances in scene units; see
+ ."""
+ )
+ float exposure = 0 (
+ doc = """Exposure adjustment, as a log base-2 value. The default
+ of 0.0 has no effect. A value of 1.0 will double the
+ image-plane intensities in a rendered image; a value of
+ -1.0 will halve them."""
+ )
+ float focalLength = 50 (
+ doc = """Perspective focal length in tenths of a scene unit; see
+ ."""
+ )
+ float focusDistance = 0 (
+ doc = """Distance from the camera to the focus plane in scene units; see
+ ."""
+ )
+ float fStop = 0 (
+ doc = "Lens aperture. Defaults to 0.0, which turns off focusing."
+ )
+ float horizontalAperture = 20.955 (
+ doc = """Horizontal aperture in tenths of a scene unit; see
+ . Default is the equivalent of
+ the standard 35mm spherical projector aperture."""
+ )
+ float horizontalApertureOffset = 0 (
+ doc = """Horizontal aperture offset in the same units as
+ horizontalAperture. Defaults to 0."""
+ )
+ token projection = "perspective" (
+ allowedTokens = ["perspective", "orthographic"]
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ double shutter:close = 0 (
+ doc = """Frame relative shutter close time, analogous comments from
+ shutter:open apply. A value greater or equal to shutter:open
+ should be authored, otherwise there is no exposure and a
+ renderer should produce a black image."""
+ )
+ double shutter:open = 0 (
+ doc = """Frame relative shutter open time in UsdTimeCode units (negative
+ value indicates that the shutter opens before the current
+ frame time). Used for motion blur."""
+ )
+ uniform token stereoRole = "mono" (
+ allowedTokens = ["mono", "left", "right"]
+ doc = """If different from mono, the camera is intended to be the left
+ or right camera of a stereo setup."""
+ )
+ float verticalAperture = 15.2908 (
+ doc = """Vertical aperture in tenths of a scene unit; see
+ . Default is the equivalent of
+ the standard 35mm spherical projector aperture."""
+ )
+ float verticalApertureOffset = 0 (
+ doc = """Vertical aperture offset in the same units as
+ verticalAperture. Defaults to 0."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "GeomModelAPI" (
+ doc = """UsdGeomModelAPI extends the generic UsdModelAPI schema with
+ geometry specific concepts such as cached extents for the entire model,
+ constraint targets, and geometry-inspired extensions to the payload
+ lofting process.
+
+ As described in GetExtentsHint() below, it is useful to cache extents
+ at the model level. UsdGeomModelAPI provides schema for computing and
+ storing these cached extents, which can be consumed by UsdGeomBBoxCache to
+ provide fast access to precomputed extents that will be used as the model's
+ bounds ( see UsdGeomBBoxCache::UsdGeomBBoxCache() ).
+
+ Draw Modes
+
+ Draw modes provide optional alternate imaging behavior for USD subtrees with
+ kind model. model:drawMode (which is inheritable) and
+ model:applyDrawMode (which is not) are resolved into a decision to stop
+ traversing the scene graph at a certain point, and replace a USD subtree
+ with proxy geometry.
+
+ The value of model:drawMode determines the type of proxy geometry:
+ - origin - Draw the model-space basis vectors of the replaced prim.
+ - bounds - Draw the model-space bounding box of the replaced prim.
+ - cards - Draw textured quads as a placeholder for the replaced prim.
+ - default - An explicit opinion to draw the USD subtree as normal.
+ - inherited - Defer to the parent opinion.
+
+ model:drawMode falls back to _inherited_ so that a whole scene,
+ a large group, or all prototypes of a model hierarchy PointInstancer can
+ be assigned a draw mode with a single attribute edit. If no draw mode is
+ explicitly set in a hierarchy, the resolved value is _default_.
+
+ model:applyDrawMode is meant to be written when an asset is authored,
+ and provides flexibility for different asset types. For example,
+ a character assembly (composed of character, clothes, etc) might have
+ model:applyDrawMode set at the top of the subtree so the whole group
+ can be drawn as a single card object. An effects subtree might have
+ model:applyDrawMode set at a lower level so each particle
+ group draws individually.
+
+ Models of kind component are automatically treated as if
+ model:applyDrawMode were true if model:applyDrawMode is not
+ authored on the component prim. A component prim will be drawn drawn with a
+ simplified representation when the prim has kind component,
+ model:applyDrawMode is not authored (or authored to be true), and the
+ resolved (i.e. inherited down namespace) value for model:drawMode is
+ not _default_. If you don't want component prims to use the resolved
+ non-default drawMode, you must apply the UsdGeomModelAPI schema on the prim
+ and explicitly set model:applyDrawMode to false.
+
+ Cards Geometry
+
+ The specific geometry used in cards mode is controlled by the
+ model:cardGeometry attribute:
+ - cross - Generate a quad normal to each basis direction and negative.
+ Locate each quad so that it bisects the model extents.
+ - box - Generate a quad normal to each basis direction and negative.
+ Locate each quad on a face of the model extents, facing out.
+ - fromTexture - Generate a quad for each supplied texture from
+ attributes stored in that texture's metadata.
+
+ For cross and box mode, the extents are calculated for purposes
+ default, proxy, and render, at their earliest authored time.
+ If the model has no textures, all six card faces are rendered using
+ model:drawModeColor. If one or more textures are present, only axes
+ with one or more textures assigned are drawn. For each axis, if both
+ textures (positive and negative) are specified, they'll be used on the
+ corresponding card faces; if only one texture is specified, it will be
+ mapped to the opposite card face after being flipped on the texture's
+ s-axis. Any card faces with invalid asset paths will be drawn with
+ model:drawModeColor.
+
+ Both model:cardGeometry and model:drawModeColor should be
+ authored on the prim where the draw mode takes effect, since these
+ attributes are not inherited.
+
+ For fromTexture mode, only card faces with valid textures assigned
+ are drawn. The geometry is generated by pulling the worldtoscreen
+ attribute out of texture metadata. This is expected to be a 4x4 matrix
+ mapping the model-space position of the card quad to the clip-space quad
+ with corners (-1,-1,0) and (1,1,0). The card vertices are generated by
+ transforming the clip-space corners by the inverse of worldtoscreen.
+ Textures are mapped so that (s) and (t) map to (+x) and (+y) in clip space.
+ If the metadata cannot be read in the right format, or the matrix can't
+ be inverted, the card face is not drawn.
+
+ All card faces are drawn and textured as single-sided.
+
+ \\todo CreatePayload() """
+)
+{
+ uniform bool model:applyDrawMode = 0 (
+ doc = """If true, and the resolved value of model:drawMode is
+ non-default, apply an alternate imaging mode to this prim. See
+ \\ref UsdGeomModelAPI_drawMode."""
+ )
+ uniform token model:cardGeometry = "cross" (
+ allowedTokens = ["cross", "box", "fromTexture"]
+ doc = """The geometry to generate for imaging prims inserted for \\em
+ cards imaging mode. See for
+ geometry descriptions."""
+ )
+ asset model:cardTextureXNeg (
+ doc = """In cards imaging mode, the texture applied to the X- quad.
+ The texture axes (s,t) are mapped to model-space axes (y, -z)."""
+ )
+ asset model:cardTextureXPos (
+ doc = """In cards imaging mode, the texture applied to the X+ quad.
+ The texture axes (s,t) are mapped to model-space axes (-y, -z)."""
+ )
+ asset model:cardTextureYNeg (
+ doc = """In cards imaging mode, the texture applied to the Y- quad.
+ The texture axes (s,t) are mapped to model-space axes (-x, -z)."""
+ )
+ asset model:cardTextureYPos (
+ doc = """In cards imaging mode, the texture applied to the Y+ quad.
+ The texture axes (s,t) are mapped to model-space axes (x, -z)."""
+ )
+ asset model:cardTextureZNeg (
+ doc = """In cards imaging mode, the texture applied to the Z- quad.
+ The texture axes (s,t) are mapped to model-space axes (-x, -y)."""
+ )
+ asset model:cardTextureZPos (
+ doc = """In cards imaging mode, the texture applied to the Z+ quad.
+ The texture axes (s,t) are mapped to model-space axes (x, -y)."""
+ )
+ uniform token model:drawMode = "inherited" (
+ allowedTokens = ["origin", "bounds", "cards", "default", "inherited"]
+ doc = """Alternate imaging mode; applied to this prim or child prims
+ where model:applyDrawMode is true, or where the prim
+ has kind component and model:applyDrawMode is not
+ authored. See \\ref UsdGeomModelAPI_drawMode
+ for mode descriptions."""
+ )
+ uniform float3 model:drawModeColor = (0.18, 0.18, 0.18) (
+ doc = """The base color of imaging prims inserted for alternate
+ imaging modes. For origin and bounds modes, this
+ controls line color; for cards mode, this controls the
+ fallback quad color."""
+ )
+}
+
+class "MotionAPI" (
+ doc = '''UsdGeomMotionAPI encodes data that can live on any prim that
+ may affect computations involving:
+ - computed motion for motion blur
+ - sampling for motion blur
+
+ The "motion:blurScale" attribute allows
+ artists to scale the __amount__ of motion blur to be rendered for parts
+ of the scene without changing the recorded animation. See
+ for use and implementation details.
+
+ '''
+)
+{
+ float motion:blurScale = 1 (
+ doc = """BlurScale is an __inherited__ float attribute that stipulates
+ the rendered motion blur (as typically specified via UsdGeomCamera's
+ _shutter:open_ and _shutter:close_ properties) should be scaled for
+ __all objects__ at and beneath the prim in namespace on which the
+ _motion:blurScale_ value is specified.
+
+ Without changing any other data in the scene, _blurScale_ allows artists to
+ \"dial in\" the amount of blur on a per-object basis. A _blurScale_
+ value of zero removes all blur, a value of 0.5 reduces blur by half,
+ and a value of 2.0 doubles the blur. The legal range for _blurScale_
+ is [0, inf), although very high values may result in extremely expensive
+ renders, and may exceed the capabilities of some renderers.
+
+ Although renderers are free to implement this feature however they see
+ fit, see for our guidance on implementing
+ the feature universally and efficiently.
+
+ \\sa ComputeMotionBlurScale()
+ """
+ )
+ int motion:nonlinearSampleCount = 3 (
+ doc = """Determines the number of position or transformation samples
+ created when motion is described by attributes contributing non-linear
+ terms.
+
+ To give an example, imagine an application (such as a
+ renderer) consuming 'points' and the USD document also
+ contains 'accelerations' for the same prim. Unless the
+ application can consume these 'accelerations' itself, an
+ intermediate layer has to compute samples within the sampling
+ interval for the point positions based on the value of
+ 'points', 'velocities' and 'accelerations'. The number of these
+ samples is given by 'nonlinearSampleCount'. The samples are
+ equally spaced within the sampling interval.
+
+ Another example involves the PointInstancer where
+ 'nonlinearSampleCount' is relevant when 'angularVelocities'
+ or 'accelerations' are authored.
+
+ 'nonlinearSampleCount' is an **inherited** attribute, also
+ see ComputeNonlinearSampleCount()"""
+ )
+ float motion:velocityScale = 1 (
+ doc = """\\deprecated
+
+ VelocityScale is an **inherited** float attribute that
+ velocity-based schemas (e.g. PointBased, PointInstancer) can consume
+ to compute interpolated positions and orientations by applying
+ velocity and angularVelocity, which is required for interpolating
+ between samples when topology is varying over time. Although these
+ quantities are generally physically computed by a simulator, sometimes
+ we require more or less motion-blur to achieve the desired look.
+ VelocityScale allows artists to dial-in, as a post-sim correction,
+ a scale factor to be applied to the velocity prior to computing
+ interpolated positions from it."""
+ )
+}
+
+class "XformCommonAPI" (
+ doc = """This class provides API for authoring and retrieving a standard set
+ of component transformations which include a scale, a rotation, a
+ scale-rotate pivot and a translation. The goal of the API is to enhance
+ component-wise interchange. It achieves this by limiting the set of allowed
+ basic ops and by specifying the order in which they are applied. In addition
+ to the basic set of ops, the 'resetXformStack' bit can also be set to
+ indicate whether the underlying xformable resets the parent transformation
+ (i.e. does not inherit it's parent's transformation).
+
+ \\sa UsdGeomXformCommonAPI::GetResetXformStack()
+ \\sa UsdGeomXformCommonAPI::SetResetXformStack()
+
+ The operator-bool for the class will inform you whether an existing
+ xformable is compatible with this API.
+
+ The scale-rotate pivot is represented by a pair of (translate,
+ inverse-translate) xformOps around the scale and rotate operations.
+ The rotation operation can be any of the six allowed Euler angle sets.
+ \\sa UsdGeomXformOp::Type.
+
+ The xformOpOrder of an xformable that has all of the supported basic ops
+ is as follows:
+ [\"xformOp:translate\", \"xformOp:translate:pivot\", \"xformOp:rotateXYZ\",
+ \"xformOp:scale\", \"!invert!xformOp:translate:pivot\"].
+
+ It is worth noting that all of the ops are optional. For example, an
+ xformable may have only a translate or a rotate. It would still be
+ considered as compatible with this API. Individual SetTranslate(),
+ SetRotate(), SetScale() and SetPivot() methods are provided by this API
+ to allow such sparse authoring."""
+)
+{
+}
+
+class HermiteCurves "HermiteCurves" (
+ doc = """This schema specifies a cubic hermite interpolated curve batch as
+ sometimes used for defining guides for animation. While hermite curves can
+ be useful because they interpolate through their control points, they are
+ not well supported by high-end renderers for imaging. Therefore, while we
+ include this schema for interchange, we strongly recommend the use of
+ UsdGeomBasisCurves as the representation of curves intended to be rendered
+ (ie. hair or grass). Hermite curves can be converted to a Bezier
+ representation (though not from Bezier back to Hermite in general).
+
+ Point Interpolation
+
+ The initial cubic curve segment is defined by the first two points and
+ first two tangents. Additional segments are defined by additional
+ point / tangent pairs. The number of segments for each non-batched hermite
+ curve would be len(curve.points) - 1. The total number of segments
+ for the batched UsdGeomHermiteCurves representation is
+ len(points) - len(curveVertexCounts).
+
+ Primvar, Width, and Normal Interpolation
+
+ Primvar interpolation is not well specified for this type as it is not
+ intended as a rendering representation. We suggest that per point
+ primvars would be linearly interpolated across each segment and should
+ be tagged as 'varying'.
+
+ It is not immediately clear how to specify cubic or 'vertex' interpolation
+ for this type, as we lack a specification for primvar tangents. This
+ also means that width and normal interpolation should be restricted to
+ varying (linear), uniform (per curve element), or constant (per prim).
+ """
+)
+{
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+ int[] curveVertexCounts (
+ doc = """Curves-derived primitives can represent multiple distinct,
+ potentially disconnected curves. The length of 'curveVertexCounts'
+ gives the number of such curves, and each element describes the
+ number of vertices in the corresponding curve"""
+ )
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ vector3f[] tangents = [] (
+ doc = """Defines the outgoing trajectory tangent for each point.
+ Tangents should be the same size as the points attribute."""
+ )
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also ."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ float[] widths (
+ doc = """Provides width specification for the curves, whose application
+ will depend on whether the curve is oriented (normals are defined for
+ it), in which case widths are \"ribbon width\", or unoriented, in which
+ case widths are cylinder width. 'widths' is not a generic Primvar,
+ but the number of elements in this attribute will be determined by
+ its 'interpolation'. See . If 'widths'
+ and 'primvars:widths' are both specified, the latter has precedence."""
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "constraintTargetIdentifier": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": "",
+ "documentation": "Unique identifier within a model's namespace for an matrix-valued attribute representing a constraint target",
+ "type": "token"
+ },
+ "elementSize": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": 1,
+ "displayGroup": "Primvars",
+ "documentation": "The number of values in a primvar's value array that must be aggregated for each element on the primitive.",
+ "type": "int"
+ },
+ "inactiveIds": {
+ "appliesTo": [
+ "prims"
+ ],
+ "type": "int64listop"
+ },
+ "interpolation": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": "constant",
+ "displayGroup": "Primvars",
+ "documentation": "How a primvar interpolates across a primitive; equivalent to RenderMan's 'class specifier'",
+ "type": "token"
+ },
+ "metersPerUnit": {
+ "appliesTo": [
+ "layers"
+ ],
+ "default": 0.01,
+ "displayGroup": "Stage",
+ "type": "double"
+ },
+ "unauthoredValuesIndex": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": -1,
+ "displayGroup": "Primvars",
+ "documentation": "The index that represents unauthored values in the indices array of an indexed primvar.",
+ "type": "int"
+ },
+ "upAxis": {
+ "appliesTo": [
+ "layers"
+ ],
+ "default": "Y",
+ "displayGroup": "Stage",
+ "type": "token"
+ }
+ },
+ "Types": {
+ "UsdGeomBasisCurves": {
+ "alias": {
+ "UsdSchemaBase": "BasisCurves"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomCurves"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomBoundable": {
+ "alias": {
+ "UsdSchemaBase": "Boundable"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdGeomCamera": {
+ "alias": {
+ "UsdSchemaBase": "Camera"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomCapsule": {
+ "alias": {
+ "UsdSchemaBase": "Capsule"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomCapsule_1": {
+ "alias": {
+ "UsdSchemaBase": "Capsule_1"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomCone": {
+ "alias": {
+ "UsdSchemaBase": "Cone"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomCube": {
+ "alias": {
+ "UsdSchemaBase": "Cube"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomCurves": {
+ "alias": {
+ "UsdSchemaBase": "Curves"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomPointBased"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "abstractTyped"
+ },
+ "UsdGeomCylinder": {
+ "alias": {
+ "UsdSchemaBase": "Cylinder"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomCylinder_1": {
+ "alias": {
+ "UsdSchemaBase": "Cylinder_1"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomGprim": {
+ "alias": {
+ "UsdSchemaBase": "Gprim"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomBoundable"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdGeomHermiteCurves": {
+ "alias": {
+ "UsdSchemaBase": "HermiteCurves"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomCurves"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomImageable": {
+ "alias": {
+ "UsdSchemaBase": "Imageable"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdGeomMesh": {
+ "alias": {
+ "UsdSchemaBase": "Mesh"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomPointBased"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomModelAPI": {
+ "alias": {
+ "UsdSchemaBase": "GeomModelAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdGeomMotionAPI": {
+ "alias": {
+ "UsdSchemaBase": "MotionAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdGeomNurbsCurves": {
+ "alias": {
+ "UsdSchemaBase": "NurbsCurves"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomCurves"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomNurbsPatch": {
+ "alias": {
+ "UsdSchemaBase": "NurbsPatch"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomPointBased"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomPlane": {
+ "alias": {
+ "UsdSchemaBase": "Plane"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomPointBased": {
+ "alias": {
+ "UsdSchemaBase": "PointBased"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "abstractTyped"
+ },
+ "UsdGeomPointInstancer": {
+ "alias": {
+ "UsdSchemaBase": "PointInstancer"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomBoundable"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomPoints": {
+ "alias": {
+ "UsdSchemaBase": "Points"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomPointBased"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomPrimvarsAPI": {
+ "alias": {
+ "UsdSchemaBase": "PrimvarsAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "nonAppliedAPI"
+ },
+ "UsdGeomScope": {
+ "alias": {
+ "UsdSchemaBase": "Scope"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomImageable"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomSphere": {
+ "alias": {
+ "UsdSchemaBase": "Sphere"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomSubset": {
+ "alias": {
+ "UsdSchemaBase": "GeomSubset"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomTetMesh": {
+ "alias": {
+ "UsdSchemaBase": "TetMesh"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomPointBased"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomVisibilityAPI": {
+ "alias": {
+ "UsdSchemaBase": "VisibilityAPI"
+ },
+ "apiSchemaCanOnlyApplyTo": [
+ "Imageable"
+ ],
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdGeomXform": {
+ "alias": {
+ "UsdSchemaBase": "Xform"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdGeomXformCommonAPI": {
+ "alias": {
+ "UsdSchemaBase": "XformCommonAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "nonAppliedAPI"
+ },
+ "UsdGeomXformable": {
+ "alias": {
+ "UsdSchemaBase": "Xformable"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomImageable"
+ ],
+ "schemaKind": "abstractTyped"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdGeom",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ "This file describes the USD Geometric schemata for code generation."
+ subLayers = [
+ @usd/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdGeom"
+ string libraryPath = "pxr/usd/usdGeom"
+ # string libraryPrefix = "UsdGeom"
+ # string tokensPrefix = "UsdGeom"
+ bool useLiteralIdentifier = 0
+ dictionary libraryTokens = {
+ dictionary interpolation = {
+ string doc = """UsdGeomPrimvar - How a Primvar interpolates
+ across a primitive; equivalent to RenderMan's \\ref Usd_InterpolationVals "class specifier" """
+ }
+ dictionary elementSize = {
+ string doc = """UsdGeomPrimvar - The number of values in the
+ value array that must be aggregated for each element on the
+ primitive."""
+ }
+ dictionary unauthoredValuesIndex = {
+ string doc = """UsdGeomPrimvar - The index that represents
+ unauthored values in the indices array of an indexed primvar."""
+ }
+ dictionary constant ={
+ string doc = """Possible value for UsdGeomPrimvar::SetInterpolation.
+ Default value for UsdGeomPrimvar::GetInterpolation. One value
+ remains constant over the entire surface primitive."""
+ }
+ dictionary uniform = {
+ string doc = """Possible value for UsdGeomPrimvar::SetInterpolation.
+ One value remains constant for each uv patch segment of the
+ surface primitive (which is a \\em face for meshes)."""
+ }
+ dictionary varying = {
+ string doc = """Possible value for UsdGeomPrimvar::SetInterpolation.
+ Four values are interpolated over each uv patch segment of the
+ surface. Bilinear interpolation is used for interpolation
+ between the four values."""
+ }
+ dictionary vertex = {
+ string doc = """Possible value for UsdGeomPrimvar::SetInterpolation.
+ Values are interpolated between each vertex in the surface
+ primitive. The basis function of the surface is used for
+ interpolation between vertices."""
+ }
+ dictionary faceVarying = {
+ string doc = """Possible value for UsdGeomPrimvar::SetInterpolation.
+ For polygons and subdivision surfaces, four values are
+ interpolated over each face of the mesh. Bilinear interpolation
+ is used for interpolation between the four values."""
+ }
+ dictionary upAxis = {
+ string doc = """Stage-level metadata that encodes a scene's
+ orientation as a token whose value can be "Y" or "Z"."""
+ }
+ dictionary metersPerUnit = {
+ string doc = """Stage-level metadata that encodes a scene's
+ linear unit of measure as meters per encoded unit."""
+ }
+ dictionary partition = {
+ string doc = """A type of family of GeomSubsets. It implies
+ that every element appears exacly once in only one of the
+ subsets in the family."""
+ }
+ dictionary nonOverlapping = {
+ string doc = """A type of family of GeomSubsets. It implies that
+ the elements in the various subsets belonging to the family are
+ mutually exclusive, i.e., an element that appears in one
+ subset may not belong to any other subset in the family."""
+ }
+ dictionary unrestricted = {
+ string doc = """A type of family of GeomSubsets. It implies that
+ there are no restrictions w.r.t. the membership of elements in
+ the subsets. There could be overlapping members in subsets
+ belonging to the family and the union of all subsets in the
+ family may not contain all the elements."""
+ }
+ dictionary hermite = {
+ string doc = """A deprecated basis token for
+ UsdGeomBasisCurves. Consumers of USD should transition
+ to using the UsdGeomHermiteCurves schema."""
+ }
+ dictionary power = {
+ string doc = """A deprecated basis token for
+ UsdGeomBasisCurves."""
+ }
+ }
+ }
+)
+{
+}
+
+class "Imageable" (
+ inherits =
+ doc = """Base class for all prims that may require rendering or
+ visualization of some sort. The primary attributes of Imageable
+ are \\em visibility and \\em purpose, which each provide instructions for
+ what geometry should be included for processing by rendering and other
+ computations.
+
+ \\deprecated Imageable also provides API for accessing primvars, which
+ has been moved to the UsdGeomPrimvarsAPI schema, because primvars can now
+ be applied on non-Imageable prim types. This API is planned
+ to be removed, UsdGeomPrimvarsAPI should be used directly instead."""
+ customData = {
+ string extraIncludes = """
+#include "pxr/base/gf/bbox3d.h"
+#include "pxr/usd/usdGeom/primvar.h" """
+ }
+) {
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = """Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc."""
+ )
+
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See \\ref UsdGeom_ImageablePurpose for more detail about how
+ \\em purpose is computed and used."""
+ )
+ rel proxyPrim (
+ doc = """The \\em proxyPrim relationship allows us to link a
+ prim whose \\em purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ \\li In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ \\li DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ \\li With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render"."""
+ )
+}
+
+class "VisibilityAPI"
+(
+ inherits =
+ customData = {
+ token[] apiSchemaCanOnlyApplyTo = [
+ "Imageable"
+ ]
+ }
+ doc = """
+ UsdGeomVisibilityAPI introduces properties that can be used to author
+ visibility opinions.
+
+ \\note
+ Currently, this schema only introduces the attributes that are used to
+ control purpose visibility. Later, this schema will define _all_
+ visibility-related properties and UsdGeomImageable will no longer define
+ those properties.
+
+ The purpose visibility attributes added by this schema,
+ _guideVisibility_, _proxyVisibility_, and _renderVisibility_ can each be
+ used to control visibility for geometry of the corresponding purpose
+ values, with the overall _visibility_ attribute acting as an
+ override. I.e., if _visibility_ evaluates to "invisible", purpose
+ visibility is invisible; otherwise, purpose visibility is determined by
+ the corresponding purpose visibility attribute.
+
+ Note that the behavior of _guideVisibility_ is subtly different from the
+ _proxyVisibility_ and _renderVisibility_ attributes, in that "guide"
+ purpose visibility always evaluates to either "invisible" or "visible",
+ whereas the other attributes may yield computed values of "inherited" if
+ there is no authored opinion on the attribute or inherited from an
+ ancestor. This is motivated by the fact that, in Pixar"s user workflows,
+ we have never found a need to have all guides visible in a scene by
+ default, whereas we do find that flexibility useful for "proxy" and
+ "render" geometry.
+
+ This schema can only be applied to UsdGeomImageable prims. The
+ UseGeomImageable schema provides API for computing the purpose visibility
+ values that result from the attributes introduced by this schema.
+ """
+)
+{
+ uniform token guideVisibility = "invisible" (
+ allowedTokens = ["inherited", "invisible", "visible"]
+ doc = """
+ This attribute controls visibility for geometry with purpose "guide".
+
+ Unlike overall _visibility_, _guideVisibility_ is uniform, and
+ therefore cannot be animated.
+
+ Also unlike overall _visibility_, _guideVisibility_ is tri-state, in
+ that a descendant with an opinion of "visible" overrides an ancestor
+ opinion of "invisible".
+
+ The _guideVisibility_ attribute works in concert with the overall
+ _visibility_ attribute: The visibility of a prim with purpose "guide"
+ is determined by the inherited values it receives for the _visibility_
+ and _guideVisibility_ attributes. If _visibility_ evaluates to
+ "invisible", the prim is invisible. If _visibility_ evaluates to
+ "inherited" and _guideVisibility_ evaluates to "visible", then the
+ prim is visible. __Otherwise, it is invisible.__
+ """
+ )
+
+ uniform token proxyVisibility = "inherited" (
+ allowedTokens = ["inherited", "invisible", "visible"]
+ doc = """
+ This attribute controls visibility for geometry with purpose "proxy".
+
+ Unlike overall _visibility_, _proxyVisibility_ is uniform, and
+ therefore cannot be animated.
+
+ Also unlike overall _visibility_, _proxyVisibility_ is tri-state, in
+ that a descendant with an opinion of "visible" overrides an ancestor
+ opinion of "invisible".
+
+ The _proxyVisibility_ attribute works in concert with the overall
+ _visibility_ attribute: The visibility of a prim with purpose "proxy"
+ is determined by the inherited values it receives for the _visibility_
+ and _proxyVisibility_ attributes. If _visibility_ evaluates to
+ "invisible", the prim is invisible. If _visibility_ evaluates to
+ "inherited" then: If _proxyVisibility_ evaluates to "visible", then
+ the prim is visible; if _proxyVisibility_ evaluates to "invisible",
+ then the prim is invisible; if _proxyVisibility_ evaluates to
+ "inherited", then the prim may either be visible or invisible,
+ depending on a fallback value determined by the calling context.
+ """
+ )
+
+ uniform token renderVisibility = "inherited" (
+ allowedTokens = ["inherited", "invisible", "visible"]
+ doc = """
+ This attribute controls visibility for geometry with purpose
+ "render".
+
+ Unlike overall _visibility_, _renderVisibility_ is uniform, and
+ therefore cannot be animated.
+
+ Also unlike overall _visibility_, _renderVisibility_ is tri-state, in
+ that a descendant with an opinion of "visible" overrides an ancestor
+ opinion of "invisible".
+
+ The _renderVisibility_ attribute works in concert with the overall
+ _visibility_ attribute: The visibility of a prim with purpose "render"
+ is determined by the inherited values it receives for the _visibility_
+ and _renderVisibility_ attributes. If _visibility_ evaluates to
+ "invisible", the prim is invisible. If _visibility_ evaluates to
+ "inherited" then: If _renderVisibility_ evaluates to "visible", then
+ the prim is visible; if _renderVisibility_ evaluates to "invisible",
+ then the prim is invisible; if _renderVisibility_ evaluates to
+ "inherited", then the prim may either be visible or invisible,
+ depending on a fallback value determined by the calling context.
+ """
+ )
+}
+
+class "PrimvarsAPI" (
+ inherits =
+ doc = """UsdGeomPrimvarsAPI encodes geometric "primitive variables",
+ as UsdGeomPrimvar, which interpolate across a primitive's topology,
+ can override shader inputs, and inherit down namespace.
+
+ \\section usdGeom_PrimvarFetchingAPI Which Method to Use to Retrieve Primvars
+
+ While creating primvars is unambiguous (CreatePrimvar()), there are quite
+ a few methods available for retrieving primvars, making it potentially
+ confusing knowing which one to use. Here are some guidelines:
+
+ \\li If you are populating a GUI with the primvars already available for
+ authoring values on a prim, use GetPrimvars().
+ \\li If you want all of the "useful" (e.g. to a renderer) primvars
+ available at a prim, including those inherited from ancestor prims, use
+ FindPrimvarsWithInheritance(). Note that doing so individually for many
+ prims will be inefficient.
+ \\li To find a particular primvar defined directly on a prim, which may
+ or may not provide a value, use GetPrimvar().
+ \\li To find a particular primvar defined on a prim or inherited from
+ ancestors, which may or may not provide a value, use
+ FindPrimvarWithInheritance().
+ \\li To *efficiently* query for primvars using the overloads of
+ FindPrimvarWithInheritance() and FindPrimvarsWithInheritance(), one
+ must first cache the results of FindIncrementallyInheritablePrimvars() for
+ each non-leaf prim on the stage. """
+ customData = {
+ token apiSchemaType = "nonApplied"
+ string extraIncludes = """
+#include "pxr/usd/usdGeom/primvar.h" """
+ }
+) {
+}
+
+class "Xformable" (
+ inherits =
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usdGeom/xformOp.h"
+#include """
+ }
+ doc = """Base class for all transformable prims, which allows arbitrary
+ sequences of component affine transformations to be encoded.
+
+ \\note
+ You may find it useful to review \\ref UsdGeom_LinAlgBasics while reading
+ this class description.
+
+ Supported Component Transformation Operations
+
+ UsdGeomXformable currently supports arbitrary sequences of the following
+ operations, each of which can be encoded in an attribute of the proper
+ shape in any supported precision:
+ \\li translate - 3D
+ \\li scale - 3D
+ \\li rotateX - 1D angle in degrees
+ \\li rotateY - 1D angle in degrees
+ \\li rotateZ - 1D angle in degrees
+ \\li rotateABC - 3D where ABC can be any combination of the six principle
+ Euler Angle sets: XYZ, XZY, YXZ, YZX, ZXY, ZYX. See
+ \\ref usdGeom_rotationPackingOrder "note on rotation packing order"
+ \\li orient - 4D (quaternion)
+ \\li transform - 4x4D
+
+ Creating a Component Transformation
+
+ To add components to a UsdGeomXformable prim, simply call AddXformOp()
+ with the desired op type, as enumerated in \\ref UsdGeomXformOp::Type,
+ and the desired precision, which is one of \\ref UsdGeomXformOp::Precision.
+ Optionally, you can also provide an "op suffix" for the operator that
+ disambiguates it from other components of the same type on the same prim.
+ Application-specific transform schemas can use the suffixes to fill a role
+ similar to that played by AbcGeom::XformOp's "Hint" enums for their own
+ round-tripping logic.
+
+ We also provide specific "Add" API for each type, for clarity and
+ conciseness, e.g. AddTranslateOp(), AddRotateXYZOp() etc.
+
+ AddXformOp() will return a UsdGeomXformOp object, which is a schema on a
+ newly created UsdAttribute that provides convenience API for authoring
+ and computing the component transformations. The UsdGeomXformOp can then
+ be used to author any number of timesamples and default for the op.
+
+ Each successive call to AddXformOp() adds an operator that will be applied
+ "more locally" than the preceding operator, just as if we were pushing
+ transforms onto a transformation stack - which is precisely what should
+ happen when the operators are consumed by a reader.
+
+ \\note
+ If you can, please try to use the UsdGeomXformCommonAPI, which wraps
+ the UsdGeomXformable with an interface in which Op creation is taken
+ care of for you, and there is a much higher chance that the data you
+ author will be importable without flattening into other DCC's, as it
+ conforms to a fixed set of Scale-Rotate-Translate Ops.
+
+ \\sa \\ref usdGeom_xformableExamples "Using the Authoring API"
+
+ Data Encoding and Op Ordering
+
+ Because there is no "fixed schema" of operations, all of the attributes
+ that encode transform operations are dynamic, and are scoped in
+ the namespace "xformOp". The second component of an attribute's name provides
+ the \\em type of operation, as listed above. An "xformOp" attribute can
+ have additional namespace components derived from the \\em opSuffix argument
+ to the AddXformOp() suite of methods, which provides a preferred way of
+ naming the ops such that we can have multiple "translate" ops with unique
+ attribute names. For example, in the attribute named
+ "xformOp:translate:maya:pivot", "translate" is the type of operation and
+ "maya:pivot" is the suffix.
+
+ The following ordered list of attribute declarations in usda
+ define a basic Scale-Rotate-Translate with XYZ Euler angles, wherein the
+ translation is double-precision, and the remainder of the ops are single,
+ in which we will:
+
+
+
Scale by 2.0 in each dimension
+
Rotate about the X, Y, and Z axes by 30, 60, and 90 degrees, respectively
+
Translate by 100 units in the Y direction
+
+
+ \\code
+ float3 xformOp:rotateXYZ = (30, 60, 90)
+ float3 xformOp:scale = (2, 2, 2)
+ double3 xformOp:translate = (0, 100, 0)
+ uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale" ]
+ \\endcode
+
+ The attributes appear in the dictionary order in which USD, by default,
+ sorts them. To ensure the ops are recovered and evaluated in the correct
+ order, the schema introduces the **xformOpOrder** attribute, which
+ contains the names of the op attributes, in the precise sequence in which
+ they should be pushed onto a transform stack. **Note** that the order is
+ opposite to what you might expect, given the matrix algebra described in
+ \\ref UsdGeom_LinAlgBasics. This also dictates order of op creation,
+ since each call to AddXformOp() adds a new op to the end of the
+ \\b xformOpOrder array, as a new "most-local" operation. See
+ \\ref usdGeom_xformableExamples "Example 2 below" for C++ code that could
+ have produced this USD.
+
+ If it were important for the prim's rotations to be independently
+ overridable, we could equivalently (at some performance cost) encode
+ the transformation also like so:
+ \\code
+ float xformOp:rotateX = 30
+ float xformOp:rotateY = 60
+ float xformOp:rotateZ = 90
+ float3 xformOp:scale = (2, 2, 2)
+ double3 xformOp:translate = (0, 100, 0)
+ uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateZ", "xformOp:rotateY", "xformOp:rotateX", "xformOp:scale" ]
+ \\endcode
+
+ Again, note that although we are encoding an XYZ rotation, the three
+ rotations appear in the **xformOpOrder** in the opposite order, with Z,
+ followed, by Y, followed by X.
+
+ Were we to add a Maya-style scalePivot to the above example, it might
+ look like the following:
+ \\code
+ float3 xformOp:rotateXYZ = (30, 60, 90)
+ float3 xformOp:scale = (2, 2, 2)
+ double3 xformOp:translate = (0, 100, 0)
+ double3 xformOp:translate:scalePivot
+ uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateXYZ", "xformOp:translate:scalePivot", "xformOp:scale" ]
+ \\endcode
+
+ Paired "Inverted" Ops
+
+ We have been claiming that the ordered list of ops serves as a set
+ of instructions to a transform stack, but you may have noticed in the last
+ example that there is a missing operation - the pivot for the scale op
+ needs to be applied in its inverse-form as a final (most local) op! In the
+ AbcGeom::Xform schema, we would have encoded an actual "final" translation
+ op whose value was authored by the exporter as the negation of the pivot's
+ value. However, doing so would be brittle in USD, given that each op can
+ be independently overridden, and the constraint that one attribute must be
+ maintained as the negation of the other in order for successful
+ re-importation of the schema cannot be expressed in USD.
+
+ Our solution leverages the **xformOpOrder** member of the schema, which,
+ in addition to ordering the ops, may also contain one of two special
+ tokens that address the paired op and "stack resetting" behavior.
+
+ The "paired op" behavior is encoded as an "!invert!" prefix in
+ \\b xformOpOrder, as the result of an AddXformOp(isInverseOp=True) call.
+ The \\b xformOpOrder for the last example would look like:
+ \\code
+ uniform token[] xformOpOrder = [ "xformOp:translate", "xformOp:rotateXYZ", "xformOp:translate:scalePivot", "xformOp:scale", "!invert!xformOp:translate:scalePivot" ]
+ \\endcode
+
+ When asked for its value via UsdGeomXformOp::GetOpTransform(), an
+ "inverted" Op (i.e. the "inverted" half of a set of paired Ops) will fetch
+ the value of its paired attribute and return its negation. This works for
+ all op types - an error will be issued if a "transform" type op is singular
+ and cannot be inverted. When getting the authored value of an inverted op
+ via UsdGeomXformOp::Get(), the raw, uninverted value of the associated
+ attribute is returned.
+
+ For the sake of robustness, setting a value on an inverted op is disallowed.
+ Attempting to set a value on an inverted op will result in a coding error
+ and no value being set.
+
+ Resetting the Transform Stack
+
+ The other special op/token that can appear in \\em xformOpOrder is
+ \\em "!resetXformStack!", which, appearing as the first element of
+ \\em xformOpOrder, indicates this prim should not inherit the transformation
+ of its namespace parent. See SetResetXformStack()
+
+ Expected Behavior for "Missing" Ops
+
+ If an importer expects Scale-Rotate-Translate operations, but a prim
+ has only translate and rotate ops authored, the importer should assume
+ an identity scale. This allows us to optimize the data a bit, if only
+ a few components of a very rich schema (like Maya's) are authored in the
+ app.
+
+ \\anchor usdGeom_xformableExamples
+ Using the C++ API
+
+ #1. Creating a simple transform matrix encoding
+ \\snippet examples_usdGeom.cpp CreateMatrixWithDefault
+
+ #2. Creating the simple SRT from the example above
+ \\snippet examples_usdGeom.cpp CreateExampleSRT
+
+ #3. Creating a parameterized SRT with pivot using UsdGeomXformCommonAPI
+ \\snippet examples_usdGeom.cpp CreateSRTWithDefaults
+
+ #4. Creating a rotate-only pivot transform with animated
+ rotation and translation
+ \\snippet examples_usdGeom.cpp CreateAnimatedTransform
+
+"""
+) {
+
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Scope "Scope" (
+ inherits =
+ doc = """Scope is the simplest grouping primitive, and does not carry the
+ baggage of transformability. Note that transforms should inherit down
+ through a Scope successfully - it is just a guaranteed no-op from a
+ transformability perspective."""
+) {
+}
+
+class Xform "Xform" (
+ inherits =
+ doc = """Concrete prim schema for a transform, which implements Xformable """
+) {
+}
+
+class "Boundable" (
+ inherits =
+ doc = """Boundable introduces the ability for a prim to persistently
+ cache a rectilinear, local-space, extent.
+
+ \\section UsdGeom_Boundable_Extent Why Extent and not Bounds ?
+ Boundable introduces the notion of "extent", which is a cached computation
+ of a prim's local-space 3D range for its resolved attributes at the
+ layer and time in which extent is authored. We have found that with
+ composed scene description, attempting to cache pre-computed bounds at
+ interior prims in a scene graph is very fragile, given the ease with which
+ one can author a single attribute in a stronger layer that can invalidate
+ many authored caches - or with which a re-published, referenced asset can
+ do the same.
+
+ Therefore, we limit to precomputing (generally) leaf-prim extent, which
+ avoids the need to read in large point arrays to compute bounds, and
+ provides UsdGeomBBoxCache the means to efficiently compute and
+ (session-only) cache intermediate bounds. You are free to compute and
+ author intermediate bounds into your scenes, of course, which may work
+ well if you have sufficient locks on your pipeline to guarantee that once
+ authored, the geometry and transforms upon which they are based will
+ remain unchanged, or if accuracy of the bounds is not an ironclad
+ requisite.
+
+ When intermediate bounds are authored on Boundable parents, the child prims
+ will be pruned from BBox computation; the authored extent is expected to
+ incorporate all child bounds."""
+)
+{
+ # XXX: Note this is really a GfRange3f, which is not fully supported
+ # in Vt I/O.
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), \\em without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+}
+
+class "Gprim" (
+ inherits =
+ doc = """Base class for all geometric primitives.
+
+ Gprim encodes basic graphical properties such as \\em doubleSided and
+ \\em orientation, and provides primvars for "display color" and "display
+ opacity" that travel with geometry to be used as shader overrides. """
+
+) {
+ color3f[] primvars:displayColor (
+ customData = {
+ string apiName = "displayColor"
+ }
+ doc = """It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a \\em displayColor parameter."""
+ )
+
+ float[] primvars:displayOpacity (
+ customData = {
+ string apiName = "displayOpacity"
+ }
+ doc = """Companion to \\em displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+
+ uniform bool doubleSided = false (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ \\em orientation. By doing so they can perform "backface culling" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's \\em doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see \\ref UsdGeom_WindingOrder for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+}
+
+class Cube "Cube" (
+ inherits =
+ doc = """Defines a primitive rectilinear cube centered at the origin.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double size = 2.0 (
+ doc = """Indicates the length of each edge of the cube. If you
+ author \\em size you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+
+ float3[] extent = [(-1.0, -1.0, -1.0), (1.0, 1.0, 1.0)] (
+ doc = """Extent is re-defined on Cube only to provide a fallback value.
+ \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+
+}
+
+class Sphere "Sphere" (
+ inherits =
+ doc = """Defines a primitive sphere centered at the origin.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double radius = 1.0 (
+ doc = """Indicates the sphere's radius. If you
+ author \\em radius you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+
+ float3[] extent = [(-1.0, -1.0, -1.0), (1.0, 1.0, 1.0)] (
+ doc = """Extent is re-defined on Sphere only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class Cylinder "Cylinder" (
+ inherits =
+ doc = """Defines a primitive cylinder with closed ends, centered at the
+ origin, whose spine is along the specified \\em axis.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double height = 2 (
+ doc = """The size of the cylinder's spine along the specified
+ \\em axis. If you author \\em height you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radius = 1.0 (
+ doc = """The radius of the cylinder. If you author \\em radius
+ you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the spine of the cylinder is aligned"""
+ )
+
+ float3[] extent = [(-1.0, -1.0, -1.0), (1.0, 1.0, 1.0)] (
+ doc = """Extent is re-defined on Cylinder only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class Capsule "Capsule" (
+ inherits =
+ doc = """Defines a primitive capsule, i.e. a cylinder capped by two half
+ spheres, centered at the origin, whose spine is along the specified
+ \\em axis.
+ The spherical cap heights (sagitta) of the two endcaps are a function of
+ the relative radii of the endcaps, such that cylinder tangent and sphere
+ tangent are coincident and maintain C1 continuity."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double height = 1.0 (
+ doc = """The length of the capsule's spine along the specified
+ \\em axis excluding the size of the two half spheres, i.e.
+ the length of the cylinder portion of the capsule.
+ If you author \\em height you must also author \\em extent.
+ \\sa GetExtentAttr()"""
+ )
+ double radius = 0.5 (
+ doc = """The radius of the capsule. If you
+ author \\em radius you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the spine of the capsule is aligned"""
+ )
+
+ float3[] extent = [(-0.5, -0.5, -1.0), (0.5, 0.5, 1.0)] (
+ doc = """Extent is re-defined on Capsule only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class Cone "Cone" (
+ inherits =
+ doc = """Defines a primitive cone, centered at the origin, whose spine
+ is along the specified \\em axis, with the apex of the cone pointing
+ in the direction of the positive axis.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double height = 2.0 (
+ doc = """The length of the cone's spine along the specified
+ \\em axis. If you author \\em height you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radius = 1.0 (
+ doc = """The radius of the cone. If you
+ author \\em radius you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the spine of the cone is aligned"""
+ )
+
+ float3[] extent = [(-1.0, -1.0, -1.0), (1.0, 1.0, 1.0)] (
+ doc = """Extent is re-defined on Cone only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class Cylinder_1 "Cylinder_1" (
+ inherits =
+ doc = """Defines a primitive cylinder with closed ends, centered at the
+ origin, whose spine is along the specified \\em axis, with a pair of radii
+ describing the size of the end points.
+
+ The fallback values for Cube, Sphere, Cone, and Cylinder are set so that
+ they all pack into the same volume/bounds."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double height = 2 (
+ doc = """The length of the cylinder's spine along the specified
+ \\em axis. If you author \\em height you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radiusTop = 1.0 (
+ doc = """The radius of the top of the cylinder - i.e. the face located
+ along the positive \\em axis. If you author \\em radiusTop you must also
+ author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radiusBottom = 1.0 (
+ doc = """The radius of the bottom of the cylinder - i.e. the face
+ point located along the negative \\em axis. If you author
+ \\em radiusBottom you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the spine of the cylinder is aligned"""
+ )
+
+ float3[] extent = [(-1.0, -1.0, -1.0), (1.0, 1.0, 1.0)] (
+ doc = """Extent is re-defined on Cylinder only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class Capsule_1 "Capsule_1" (
+ inherits =
+ doc = """Defines a primitive capsule, i.e. a cylinder capped by two half
+ spheres, with potentially different radii, centered at the origin, and whose
+ spine is along the specified \\em axis.
+ The spherical cap heights (sagitta) of the two endcaps are a function of
+ the relative radii of the endcaps, such that cylinder tangent and sphere
+ tangent are coincident and maintain C1 continuity."""
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ double height = 1.0 (
+ doc = """The length of the capsule's spine along the specified
+ \\em axis excluding the size of the two half spheres, i.e.
+ the length of the cylinder portion of the capsule.
+ If you author \\em height you must also author \\em extent.
+ \\sa GetExtentAttr()"""
+ )
+ double radiusTop = 0.5 (
+ doc = """The radius of the capping sphere at the top of the capsule -
+ i.e. the sphere in the direction of the positive \\em axis. If you
+ author \\em radius you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ double radiusBottom = 0.5 (
+ doc = """The radius of the capping sphere at the bottom of the capsule -
+ i.e. the sphere located in the direction of the negative \\em axis. If
+ you author \\em radius you must also author \\em extent.
+
+ \\sa GetExtentAttr()"""
+ )
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the spine of the capsule is aligned"""
+ )
+
+ float3[] extent = [(-0.5, -0.5, -1.0), (0.5, 0.5, 1.0)] (
+ doc = """Extent is re-defined on Capsule only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class Plane "Plane" (
+ inherits =
+ doc = """Defines a primitive plane, centered at the origin, and is defined by
+ a cardinal axis, width, and length. The plane is double-sided by default.
+
+ The axis of width and length are perpendicular to the plane's \\em axis:
+
+ axis | width | length
+ ----- | ------ | -------
+ X | z-axis | y-axis
+ Y | x-axis | z-axis
+ Z | x-axis | y-axis
+
+ """
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ uniform bool doubleSided = true (
+ doc = """Planes are double-sided by default. Clients may also support
+ single-sided planes.
+
+ \\sa UsdGeomGprim::GetDoubleSidedAttr()"""
+ )
+ double width = 2.0 (
+ doc = """The width of the plane, which aligns to the x-axis when \\em axis is
+ 'Z' or 'Y', or to the z-axis when \\em axis is 'X'. If you author \\em width
+ you must also author \\em extent.
+
+ \\sa UsdGeomGprim::GetExtentAttr()"""
+ )
+ double length = 2.0 (
+ doc = """The length of the plane, which aligns to the y-axis when \\em axis is
+ 'Z' or 'X', or to the z-axis when \\em axis is 'Y'. If you author \\em length
+ you must also author \\em extent.
+
+ \\sa UsdGeomGprim::GetExtentAttr()"""
+ )
+ uniform token axis = "Z" (
+ allowedTokens = ["X", "Y", "Z"]
+ doc = """The axis along which the surface of the plane is aligned. When set
+ to 'Z' the plane is in the xy-plane; when \\em axis is 'X' the plane is in
+ the yz-plane, and when \\em axis is 'Y' the plane is in the xz-plane.
+
+ \\sa UsdGeomGprim::GetAxisAttr()."""
+ )
+ float3[] extent = [(-1.0, -1.0, 0.0), (1.0, 1.0, 0.0)] (
+ doc = """Extent is re-defined on Plane only to provide a fallback
+ value. \\sa UsdGeomGprim::GetExtentAttr()."""
+ )
+}
+
+class "PointBased" (
+ doc = """Base class for all UsdGeomGprims that possess points,
+ providing common attributes such as normals and velocities."""
+
+ inherits =
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+ # positional
+ point3f[] points (
+ doc = """The primary geometry attribute for all PointBased
+ primitives, describes points in (local) space."""
+ )
+
+ vector3f[] velocities (
+ doc = """If provided, 'velocities' should be used by renderers to
+
+ compute positions between samples for the 'points' attribute, rather
+ than interpolating between neighboring 'points' samples. This is the
+ only reasonable means of computing motion blur for topologically
+ varying PointBased primitives. It follows that the length of each
+ 'velocities' sample must match the length of the corresponding
+ 'points' sample. Velocity is measured in position units per second,
+ as per most simulation software. To convert to position units per
+ UsdTimeCode, divide by UsdStage::GetTimeCodesPerSecond().
+
+ See also \\ref UsdGeom_VelocityInterpolation ."""
+ )
+
+ vector3f[] accelerations (
+ doc = """If provided, 'accelerations' should be used with
+ velocities to compute positions between samples for the 'points'
+ attribute rather than interpolating between neighboring 'points'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+
+ # shaping
+ normal3f[] normals (
+ doc = """Provide an object-space orientation for individual points,
+ which, depending on subclass, may define a surface, curve, or free
+ points. Note that 'normals' should not be authored on any Mesh that
+ is subdivided, since the subdivision algorithm will define its own
+ normals. 'normals' is not a generic primvar, but the number of elements
+ in this attribute will be determined by its 'interpolation'. See
+ \\ref SetNormalsInterpolation() . If 'normals' and 'primvars:normals'
+ are both specified, the latter has precedence."""
+ )
+}
+
+class Mesh "Mesh" (
+ inherits =
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usd/timeCode.h" """
+ }
+ doc="""Encodes a mesh with optional subdivision properties and features.
+
+ As a point-based primitive, meshes are defined in terms of points that
+ are connected into edges and faces. Many references to meshes use the
+ term 'vertex' in place of or interchangeably with 'points', while some
+ use 'vertex' to refer to the 'face-vertices' that define a face. To
+ avoid confusion, the term 'vertex' is intentionally avoided in favor of
+ 'points' or 'face-vertices'.
+
+ The connectivity between points, edges and faces is encoded using a
+ common minimal topological description of the faces of the mesh. Each
+ face is defined by a set of face-vertices using indices into the Mesh's
+ _points_ array (inherited from UsdGeomPointBased) and laid out in a
+ single linear _faceVertexIndices_ array for efficiency. A companion
+ _faceVertexCounts_ array provides, for each face, the number of
+ consecutive face-vertices in _faceVertexIndices_ that define the face.
+ No additional connectivity information is required or constructed, so
+ no adjacency or neighborhood queries are available.
+
+ A key property of this mesh schema is that it encodes both subdivision
+ surfaces and simpler polygonal meshes. This is achieved by varying the
+ _subdivisionScheme_ attribute, which is set to specify Catmull-Clark
+ subdivision by default, so polygonal meshes must always be explicitly
+ declared. The available subdivision schemes and additional subdivision
+ features encoded in optional attributes conform to the feature set of
+ OpenSubdiv
+ (https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html).
+
+ \\anchor UsdGeom_Mesh_Primvars
+ __A Note About Primvars__
+
+ The following list clarifies the number of elements for and the
+ interpolation behavior of the different primvar interpolation types
+ for meshes:
+
+ - __constant__: One element for the entire mesh; no interpolation.
+ - __uniform__: One element for each face of the mesh; elements are
+ typically not interpolated but are inherited by other faces derived
+ from a given face (via subdivision, tessellation, etc.).
+ - __varying__: One element for each point of the mesh;
+ interpolation of point data is always linear.
+ - __vertex__: One element for each point of the mesh;
+ interpolation of point data is applied according to the
+ _subdivisionScheme_ attribute.
+ - __faceVarying__: One element for each of the face-vertices that
+ define the mesh topology; interpolation of face-vertex data may
+ be smooth or linear, according to the _subdivisionScheme_ and
+ _faceVaryingLinearInterpolation_ attributes.
+
+ Primvar interpolation types and related utilities are described more
+ generally in \\ref Usd_InterpolationVals.
+
+ \\anchor UsdGeom_Mesh_Normals
+ __A Note About Normals__
+
+ Normals should not be authored on a subdivision mesh, since subdivision
+ algorithms define their own normals. They should only be authored for
+ polygonal meshes (_subdivisionScheme_ = "none").
+
+ The _normals_ attribute inherited from UsdGeomPointBased is not a generic
+ primvar, but the number of elements in this attribute will be determined by
+ its _interpolation_. See \\ref UsdGeomPointBased::GetNormalsInterpolation() .
+ If _normals_ and _primvars:normals_ are both specified, the latter has
+ precedence. If a polygonal mesh specifies __neither__ _normals_ nor
+ _primvars:normals_, then it should be treated and rendered as faceted,
+ with no attempt to compute smooth normals.
+
+ The normals generated for smooth subdivision schemes, e.g. Catmull-Clark
+ and Loop, will likewise be smooth, but others, e.g. Bilinear, may be
+ discontinuous between faces and/or within non-planar irregular faces."""
+) {
+ #
+ # Common Properties
+ #
+ int[] faceVertexIndices (
+ doc = """Flat list of the index (into the _points_ attribute) of each
+ vertex of each face in the mesh. If this attribute has more than
+ one timeSample, the mesh is considered to be topologically varying."""
+ )
+
+ int[] faceVertexCounts (
+ doc = """Provides the number of vertices in each face of the mesh,
+ which is also the number of consecutive indices in _faceVertexIndices_
+ that define the face. The length of this attribute is the number of
+ faces in the mesh. If this attribute has more than
+ one timeSample, the mesh is considered to be topologically varying."""
+ )
+
+ #
+ # Subdiv Properties
+ #
+
+ uniform token subdivisionScheme = "catmullClark" (
+ allowedTokens = ["catmullClark", "loop", "bilinear", "none"]
+ doc = """The subdivision scheme to be applied to the surface.
+ Valid values are:
+
+ - __catmullClark__: The default, Catmull-Clark subdivision; preferred
+ for quad-dominant meshes (generalizes B-splines); interpolation
+ of point data is smooth (non-linear)
+ - __loop__: Loop subdivision; preferred for purely triangular meshes;
+ interpolation of point data is smooth (non-linear)
+ - __bilinear__: Subdivision reduces all faces to quads (topologically
+ similar to "catmullClark"); interpolation of point data is bilinear
+ - __none__: No subdivision, i.e. a simple polygonal mesh; interpolation
+ of point data is linear
+
+ Polygonal meshes are typically lighter weight and faster to render,
+ depending on renderer and render mode. Use of "bilinear" will produce
+ a similar shape to a polygonal mesh and may offer additional guarantees
+ of watertightness and additional subdivision features (e.g. holes) but
+ may also not respect authored normals.""")
+
+ token interpolateBoundary = "edgeAndCorner" (
+ allowedTokens = ["none", "edgeOnly", "edgeAndCorner"]
+ doc = """Specifies how subdivision is applied for faces adjacent to
+ boundary edges and boundary points. Valid values correspond to choices
+ available in OpenSubdiv:
+
+ - __none__: No boundary interpolation is applied and boundary faces are
+ effectively treated as holes
+ - __edgeOnly__: A sequence of boundary edges defines a smooth curve to
+ which the edges of subdivided boundary faces converge
+ - __edgeAndCorner__: The default, similar to "edgeOnly" but the smooth
+ boundary curve is made sharp at corner points
+
+ These are illustrated and described in more detail in the OpenSubdiv
+ documentation:
+ https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#boundary-interpolation-rules""")
+
+ token faceVaryingLinearInterpolation = "cornersPlus1" (
+ allowedTokens = ["none", "cornersOnly", "cornersPlus1",
+ "cornersPlus2", "boundaries", "all"]
+ doc = """Specifies how elements of a primvar of interpolation type
+ "faceVarying" are interpolated for subdivision surfaces. Interpolation
+ can be as smooth as a "vertex" primvar or constrained to be linear at
+ features specified by several options. Valid values correspond to
+ choices available in OpenSubdiv:
+
+ - __none__: No linear constraints or sharpening, smooth everywhere
+ - __cornersOnly__: Sharpen corners of discontinuous boundaries only,
+ smooth everywhere else
+ - __cornersPlus1__: The default, same as "cornersOnly" plus additional
+ sharpening at points where three or more distinct face-varying
+ values occur
+ - __cornersPlus2__: Same as "cornersPlus1" plus additional sharpening
+ at points with at least one discontinuous boundary corner or
+ only one discontinuous boundary edge (a dart)
+ - __boundaries__: Piecewise linear along discontinuous boundaries,
+ smooth interior
+ - __all__: Piecewise linear everywhere
+
+ These are illustrated and described in more detail in the OpenSubdiv
+ documentation:
+ https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#face-varying-interpolation-rules""")
+
+ token triangleSubdivisionRule = "catmullClark" (
+ allowedTokens = ["catmullClark", "smooth"]
+ doc = """Specifies an option to the subdivision rules for the
+ Catmull-Clark scheme to try and improve undesirable artifacts when
+ subdividing triangles. Valid values are "catmullClark" for the
+ standard rules (the default) and "smooth" for the improvement.
+
+ See https://graphics.pixar.com/opensubdiv/docs/subdivision_surfaces.html#triangle-subdivision-rule""")
+
+ int[] holeIndices = [] (
+ doc = """The indices of all faces that should be treated as holes,
+ i.e. made invisible. This is traditionally a feature of subdivision
+ surfaces and not generally applied to polygonal meshes.""")
+
+ int[] cornerIndices = [] (
+ doc = """The indices of points for which a corresponding sharpness
+ value is specified in _cornerSharpnesses_ (so the size of this array
+ must match that of _cornerSharpnesses_).""")
+
+ float[] cornerSharpnesses = [] (
+ doc = """The sharpness values associated with a corresponding set of
+ points specified in _cornerIndices_ (so the size of this array must
+ match that of _cornerIndices_). Use the constant `SHARPNESS_INFINITE`
+ for a perfectly sharp corner.""")
+
+ int[] creaseIndices = [] (
+ doc = """The indices of points grouped into sets of successive pairs
+ that identify edges to be creased. The size of this array must be
+ equal to the sum of all elements of the _creaseLengths_ attribute.""")
+
+ int[] creaseLengths = [] (
+ doc = """The length of this array specifies the number of creases
+ (sets of adjacent sharpened edges) on the mesh. Each element gives
+ the number of points of each crease, whose indices are successively
+ laid out in the _creaseIndices_ attribute. Since each crease must
+ be at least one edge long, each element of this array must be at
+ least two.""")
+
+ float[] creaseSharpnesses = [] (
+ doc = """The per-crease or per-edge sharpness values for all creases.
+ Since _creaseLengths_ encodes the number of points in each crease,
+ the number of elements in this array will be either len(creaseLengths)
+ or the sum over all X of (creaseLengths[X] - 1). Note that while
+ the RI spec allows each crease to have either a single sharpness
+ or a value per-edge, USD will encode either a single sharpness
+ per crease on a mesh, or sharpnesses for all edges making up
+ the creases on a mesh. Use the constant `SHARPNESS_INFINITE` for a
+ perfectly sharp crease.""")
+}
+
+class TetMesh "TetMesh" (
+ inherits =
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usd/timeCode.h" """
+ }
+ doc="""Encodes a tetrahedral mesh. A tetrahedral mesh is defined as a set of
+ tetrahedra. Each tetrahedron is defined by a set of 4 points, with the
+ triangles of the tetrahedron determined from these 4 points as described in
+ the tetVertexIndices attribute description. The mesh surface faces
+ are encoded as triangles. Surface faces must be provided for consumers
+ that need to do surface calculations, such as renderers or consumers using
+ physics attachments. Both tetrahedra and surface face definitions use
+ indices into the TetMesh's points attribute, inherited from
+ UsdGeomPointBased."""
+) {
+ #
+ # Common Properties
+ #
+ int4[] tetVertexIndices (
+ doc = """Flat list of the index (into the points attribute) of
+ each vertex of each tetrahedron in the mesh. Each int4 corresponds to the
+ indices of a single tetrahedron. Users should set the orientation
+ attribute of UsdGeomPrim accordingly. That is if the orientation
+ is "rightHanded", the CCW face ordering of a tetrahedron is
+ [123],[032],[013],[021] with respect to the int4. This results in the
+ normals facing outward from the center of the tetrahedron. The following
+ diagram shows the face ordering of an unwrapped tetrahedron with
+ "rightHanded" orientation.
+
+ \\image html USDTetMeshRightHanded.svg
+
+ If the orientation attribute is set to "leftHanded" the face
+ ordering of the tetrahedron is [321],[230],[310],[120] and the
+ leftHanded CW face normals point outward from the center of the
+ tetrahedron. The following diagram shows the face ordering of an
+ unwrapped tetrahedron with "leftHanded" orientation.
+
+ \\image html USDTetMeshLeftHanded.svg
+
+ Setting the orientation attribute to align with the
+ ordering of the int4 for the tetrahedrons is the responsibility of the
+ user."""
+ )
+
+ int3[] surfaceFaceVertexIndices (
+ doc = """surfaceFaceVertexIndices defines the triangle
+ surface faces indices wrt. points of the tetmesh surface. Again
+ the orientation attribute inherited from UsdGeomPrim should be
+ set accordingly. The orientation for faces of tetrahedra and
+ surface faces must match."""
+ )
+}
+
+class GeomSubset "GeomSubset" (
+ inherits =
+ doc = """Encodes a subset of a piece of geometry (i.e. a UsdGeomImageable)
+ as a set of indices. Currently supports encoding subsets of faces,
+ points, edges, and tetrahedrons.
+
+ To apply to a geometric prim, a GeomSubset prim must be the prim's direct
+ child in namespace, and possess a concrete defining specifier (i.e. def).
+ This restriction makes it easy and efficient to discover subsets of a prim.
+ We might want to relax this restriction if it's common to have multiple
+ families of subsets on a gprim and if it's useful to be able to
+ organize subsets belonging to a family under a common scope. See
+ 'familyName' attribute for more info on defining a family of subsets.
+
+ Note that a GeomSubset isn't an imageable (i.e. doesn't derive from
+ UsdGeomImageable). So, you can't author visibility for it or
+ override its purpose.
+
+ Materials are bound to GeomSubsets just as they are for regular
+ geometry using API available in UsdShade (UsdShadeMaterial::Bind).
+"""
+ customData = {
+ string className = "Subset"
+ string extraIncludes = """
+#include "pxr/base/tf/token.h"
+#include "pxr/usd/usdGeom/imageable.h"
+#include "pxr/usd/usdGeom/mesh.h"
+#include "pxr/usd/usdGeom/tetMesh.h"
+"""
+ }
+)
+{
+ uniform token elementType = "face" (
+ allowedTokens = ["face", "point", "edge", "tetrahedron"]
+ doc = """The type of element that the indices target. "elementType" can
+ have one of the following values:
+
face: Identifies faces on a Gprim's surface. For a
+ UsdGeomMesh, each element of the _indices_ attribute would refer to
+ an element of the Mesh's _faceCounts_ attribute. For a UsdGeomTetMesh,
+ each element of the _indices_ attribute would refer to an element of
+ the Mesh's _surfaceFaceVertexIndices_ attribute.
+
point: for any UsdGeomPointBased, each
+ element of the _indices_ attribute would refer to an element of the
+ Mesh's _points_ attribute
+
edge: for any UsdGeomMesh, each pair of elements
+ in the _indices_ attribute would refer to a pair of points of the
+ Mesh's _points_ attribute that are connected as an implicit edge on the
+ Mesh. These edges are derived from the Mesh's _faceVertexIndices_
+ attribute. Edges are not currently defined for a UsdGeomTetMesh, but
+ could be derived from all tetrahedron edges or surface face edges only
+ if a specific use-case arises.
+
tetrahedron: for any UsdGeomTetMesh, each element of the
+ _indices_ attribute would refer to an element of the TetMesh's
+ _tetVertexIndices_ attribute.
+
"""
+ )
+ int[] indices = [] (
+ doc = """The set of indices included in this subset. The indices need not
+ be sorted, but the same index should not appear more than once. Indices
+ are invalid if outside the range [0, elementCount) for the given time on
+ the parent geometric prim."""
+ )
+ uniform token familyName = "" (
+ doc = """The name of the family of subsets that this subset belongs to.
+ This is optional and is primarily useful when there are multiple
+ families of subsets under a geometric prim. In some cases, this could
+ also be used for achieving proper roundtripping of subset data between
+ DCC apps.
+ When multiple subsets belonging to a prim have the same familyName, they
+ are said to belong to the family. A familyType value can be
+ encoded on the owner of a family of subsets as a token using the static
+ method UsdGeomSubset::SetFamilyType(). "familyType" can have one of the
+ following values:
+
UsdGeomTokens->partition: implies that every element of
+ the whole geometry appears exactly once in only one of the subsets
+ belonging to the family.
+
UsdGeomTokens->nonOverlapping: an element that appears in one
+ subset may not appear in any other subset belonging to the family, and
+ appears only once in the subset in which it appears.
+
UsdGeomTokens->unrestricted: implies that there are no
+ restrictions w.r.t. the membership of elements in the subsets. They
+ could be overlapping and the union of all subsets in the family may
+ not represent the whole.
+
+ \\note The validity of subset data is not enforced by the authoring
+ APIs, however they can be checked using UsdGeomSubset::ValidateFamily().
+ """
+ )
+}
+
+class NurbsPatch "NurbsPatch" (
+ inherits =
+ doc = """Encodes a rational or polynomial non-uniform B-spline
+ surface, with optional trim curves.
+
+ The encoding mostly follows that of RiNuPatch and RiTrimCurve:
+ https://renderman.pixar.com/resources/RenderMan_20/geometricPrimitives.html#rinupatch , with some minor renaming and coalescing for clarity.
+
+ The layout of control vertices in the \\em points attribute inherited
+ from UsdGeomPointBased is row-major with U considered rows, and V columns.
+
+ \\anchor UsdGeom_NurbsPatch_Form
+ NurbsPatch Form
+
+ The authored points, orders, knots, weights, and ranges are all that is
+ required to render the nurbs patch. However, the only way to model closed
+ surfaces with nurbs is to ensure that the first and last control points
+ along the given axis are coincident. Similarly, to ensure the surface is
+ not only closed but also C2 continuous, the last \\em order - 1 control
+ points must be (correspondingly) coincident with the first \\em order - 1
+ control points, and also the spacing of the last corresponding knots
+ must be the same as the first corresponding knots.
+
+ Form is provided as an aid to interchange between modeling and
+ animation applications so that they can robustly identify the intent with
+ which the surface was modelled, and take measures (if they are able) to
+ preserve the continuity/concidence constraints as the surface may be rigged
+ or deformed.
+ \\li An \\em open-form NurbsPatch has no continuity constraints.
+ \\li A \\em closed-form NurbsPatch expects the first and last control points
+ to overlap
+ \\li A \\em periodic-form NurbsPatch expects the first and last
+ \\em order - 1 control points to overlap.
+
+ Nurbs vs Subdivision Surfaces
+
+ Nurbs are an important modeling primitive in CAD/CAM tools and early
+ computer graphics DCC's. Because they have a natural UV parameterization
+ they easily support "trim curves", which allow smooth shapes to be
+ carved out of the surface.
+
+ However, the topology of the patch is always rectangular, and joining two
+ nurbs patches together (especially when they have differing numbers of
+ spans) is difficult to do smoothly. Also, nurbs are not supported by
+ the Ptex texturing technology (http://ptex.us).
+
+ Neither of these limitations are shared by subdivision surfaces; therefore,
+ although they do not subscribe to trim-curve-based shaping, subdivs are
+ often considered a more flexible modeling primitive.
+ """
+) {
+ int uVertexCount (
+ doc = """Number of vertices in the U direction. Should be at least as
+ large as uOrder."""
+ )
+
+ int vVertexCount (
+ doc = """Number of vertices in the V direction. Should be at least as
+ large as vOrder."""
+ )
+
+ int uOrder (
+ doc = """Order in the U direction. Order must be positive and is
+ equal to the degree of the polynomial basis to be evaluated, plus 1."""
+ )
+
+ int vOrder (
+ doc = """Order in the V direction. Order must be positive and is
+ equal to the degree of the polynomial basis to be evaluated, plus 1."""
+ )
+
+ double[] uKnots (
+ doc = """Knot vector for U direction providing U parameterization.
+ The length of this array must be ( uVertexCount + uOrder ), and its
+ entries must take on monotonically increasing values."""
+ )
+
+ double[] vKnots (
+ doc = """Knot vector for V direction providing U parameterization.
+ The length of this array must be ( vVertexCount + vOrder ), and its
+ entries must take on monotonically increasing values."""
+ )
+
+ uniform token uForm = "open" (
+ allowedTokens = ["open", "closed", "periodic"]
+ doc = """Interpret the control grid and knot vectors as representing
+ an open, geometrically closed, or geometrically closed and C2 continuous
+ surface along the U dimension.
+ \\sa \\ref UsdGeom_NurbsPatch_Form "NurbsPatch Form" """
+ )
+
+ uniform token vForm = "open" (
+ allowedTokens = ["open", "closed", "periodic"]
+ doc = """Interpret the control grid and knot vectors as representing
+ an open, geometrically closed, or geometrically closed and C2 continuous
+ surface along the V dimension.
+ \\sa \\ref UsdGeom_NurbsPatch_Form "NurbsPatch Form" """
+ )
+
+ # Alembic's NuPatch does not encode these... wonder how they
+ # get away with that? Just assume it's the full range, presumably.
+ double2 uRange (
+ doc = """Provides the minimum and maximum parametric values (as defined
+ by uKnots) over which the surface is actually defined. The minimum
+ must be less than the maximum, and greater than or equal to the
+ value of uKnots[uOrder-1]. The maxium must be less than or equal
+ to the last element's value in uKnots."""
+ )
+
+ double2 vRange (
+ doc = """Provides the minimum and maximum parametric values (as defined
+ by vKnots) over which the surface is actually defined. The minimum
+ must be less than the maximum, and greater than or equal to the
+ value of vKnots[vOrder-1]. The maxium must be less than or equal
+ to the last element's value in vKnots."""
+ )
+
+ double[] pointWeights (
+ doc = """Optionally provides "w" components for each control point,
+ thus must be the same length as the points attribute. If authored,
+ the patch will be rational. If unauthored, the patch will be
+ polynomial, i.e. weight for all points is 1.0.
+ \\note Some DCC's pre-weight the \\em points, but in this schema,
+ \\em points are not pre-weighted."""
+ )
+
+ int[] trimCurve:counts (
+ doc = """Each element specifies how many curves are present in each
+ "loop" of the trimCurve, and the length of the array determines how
+ many loops the trimCurve contains. The sum of all elements is the
+ total nuber of curves in the trim, to which we will refer as
+ \\em nCurves in describing the other trim attributes."""
+ )
+
+ int[] trimCurve:orders (
+ doc = """Flat list of orders for each of the \\em nCurves curves."""
+ )
+
+ int[] trimCurve:vertexCounts (
+ doc = """Flat list of number of vertices for each of the
+ \\em nCurves curves."""
+ )
+
+ double[] trimCurve:knots (
+ doc = """Flat list of parametric values for each of the
+ \\em nCurves curves. There will be as many knots as the sum over
+ all elements of \\em vertexCounts plus the sum over all elements of
+ \\em orders."""
+ )
+
+ double2[] trimCurve:ranges (
+ doc = """Flat list of minimum and maximum parametric values
+ (as defined by \\em knots) for each of the \\em nCurves curves."""
+ )
+
+ double3[] trimCurve:points (
+ doc = """Flat list of homogeneous 2D points (u, v, w) that comprise
+ the \\em nCurves curves. The number of points should be equal to the
+ um over all elements of \\em vertexCounts."""
+ )
+
+}
+
+class "Curves" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+ inherits =
+ doc = """Base class for UsdGeomBasisCurves, UsdGeomNurbsCurves, and
+ UsdGeomHermiteCurves. The BasisCurves schema is designed to be
+ analagous to offline renderers' notion of batched curves (such as
+ the classical RIB definition via Basis and Curves statements),
+ while the NurbsCurve schema is designed to be analgous to the
+ NURBS curves found in packages like Maya and Houdini while
+ retaining their consistency with the RenderMan specification for
+ NURBS Patches. HermiteCurves are useful for the
+ interchange of animation guides and paths.
+
+ It is safe to use the length of the curve vertex count to derive
+ the number of curves and the number and layout of curve vertices,
+ but this schema should NOT be used to derive the number of curve
+ points. While vertex indices are implicit in all shipped
+ descendent types of this schema, one should not assume that all
+ internal or future shipped schemas will follow this pattern. Be
+ sure to key any indexing behavior off the concrete type, not this
+ abstract type.
+ """
+) {
+ # topology attributes
+ int[] curveVertexCounts (
+ doc = """Curves-derived primitives can represent multiple distinct,
+ potentially disconnected curves. The length of 'curveVertexCounts'
+ gives the number of such curves, and each element describes the
+ number of vertices in the corresponding curve"""
+ )
+
+ # shaping attributes
+ float[] widths (
+ doc = """Provides width specification for the curves, whose application
+ will depend on whether the curve is oriented (normals are defined for
+ it), in which case widths are "ribbon width", or unoriented, in which
+ case widths are cylinder width. 'widths' is not a generic Primvar,
+ but the number of elements in this attribute will be determined by
+ its 'interpolation'. See \\ref SetWidthsInterpolation() . If 'widths'
+ and 'primvars:widths' are both specified, the latter has precedence."""
+ )
+}
+
+class BasisCurves "BasisCurves" (
+ inherits =
+ doc = """BasisCurves are a batched curve representation analogous to the
+ classic RIB definition via Basis and Curves statements. BasisCurves are
+ often used to render dense aggregate geometry like hair or grass.
+
+ A 'matrix' and 'vstep' associated with the \\em basis are used to
+ interpolate the vertices of a cubic BasisCurves. (The basis attribute
+ is unused for linear BasisCurves.)
+
+ A single prim may have many curves whose count is determined implicitly by
+ the length of the \\em curveVertexCounts vector. Each individual curve is
+ composed of one or more segments. Each segment is defined by four vertices
+ for cubic curves and two vertices for linear curves. See the next section
+ for more information on how to map curve vertex counts to segment counts.
+
+ \\section UsdGeomBasisCurves_Segment Segment Indexing
+ Interpolating a curve requires knowing how to decompose it into its
+ individual segments.
+
+ The segments of a cubic curve are determined by the vertex count,
+ the \\em wrap (periodicity), and the vstep of the basis. For linear
+ curves, the basis token is ignored and only the vertex count and
+ wrap are needed.
+
+ cubic basis | vstep
+ ------------- | ------
+ bezier | 3
+ catmullRom | 1
+ bspline | 1
+
+ The first segment of a cubic (nonperiodic) curve is always defined by its
+ first four points. The vstep is the increment used to determine what
+ vertex indices define the next segment. For a two segment (nonperiodic)
+ bspline basis curve (vstep = 1), the first segment will be defined by
+ interpolating vertices [0, 1, 2, 3] and the second segment will be defined
+ by [1, 2, 3, 4]. For a two segment bezier basis curve (vstep = 3), the
+ first segment will be defined by interpolating vertices [0, 1, 2, 3] and
+ the second segment will be defined by [3, 4, 5, 6]. If the vstep is not
+ one, then you must take special care to make sure that the number of cvs
+ properly divides by your vstep. (The indices described are relative to
+ the initial vertex index for a batched curve.)
+
+ For periodic curves, at least one of the curve's initial vertices are
+ repeated to close the curve. For cubic curves, the number of vertices
+ repeated is '4 - vstep'. For linear curves, only one vertex is repeated
+ to close the loop.
+
+ Pinned curves are a special case of nonperiodic curves that only affects
+ the behavior of cubic Bspline and Catmull-Rom curves. To evaluate or render
+ pinned curves, a client must effectively add 'phantom points' at the
+ beginning and end of every curve in a batch. These phantom points
+ are injected to ensure that the interpolated curve begins at P[0] and
+ ends at P[n-1].
+
+ For a curve with initial point P[0] and last point P[n-1], the phantom
+ points are defined as.
+ P[-1] = 2 * P[0] - P[1]
+ P[n] = 2 * P[n-1] - P[n-2]
+
+ Pinned cubic curves will (usually) have to be unpacked into the standard
+ nonperiodic representation before rendering. This unpacking can add some
+ additional overhead. However, using pinned curves reduces the amount of
+ data recorded in a scene and (more importantly) better records the
+ authors' intent for interchange.
+
+ \\note The additional phantom points mean that the minimum curve vertex
+ count for cubic bspline and catmullRom curves is 2.
+
+ Linear curve segments are defined by two vertices.
+ A two segment linear curve's first segment would be defined by
+ interpolating vertices [0, 1]. The second segment would be defined by
+ vertices [1, 2]. (Again, for a batched curve, indices are relative to
+ the initial vertex index.)
+
+ When validating curve topology, each renderable entry in the
+ curveVertexCounts vector must pass this check.
+
+ type | wrap | validitity
+ ------- | --------------------------- | ----------------
+ linear | nonperiodic | curveVertexCounts[i] > 2
+ linear | periodic | curveVertexCounts[i] > 3
+ cubic | nonperiodic | (curveVertexCounts[i] - 4) % vstep == 0
+ cubic | periodic | (curveVertexCounts[i]) % vstep == 0
+ cubic | pinned (catmullRom/bspline) | (curveVertexCounts[i] - 2) >= 0
+
+ \\section UsdGeomBasisCurves_BasisMatrix Cubic Vertex Interpolation
+
+ \\image html USDCurveBasisMatrix.png width=750
+
+ \\section UsdGeomBasisCurves_Linear Linear Vertex Interpolation
+
+ Linear interpolation is always used on curves of type linear.
+ 't' with domain [0, 1], the curve is defined by the equation
+ P0 * (1-t) + P1 * t. t at 0 describes the first point and t at 1 describes
+ the end point.
+
+ \\section UsdGeomBasisCurves_PrimvarInterpolation Primvar Interpolation
+
+ For cubic curves, primvar data can be either interpolated cubically between
+ vertices or linearly across segments. The corresponding token
+ for cubic interpolation is 'vertex' and for linear interpolation is
+ 'varying'. Per vertex data should be the same size as the number
+ of vertices in your curve. Segment varying data is dependent on the
+ wrap (periodicity) and number of segments in your curve. For linear curves,
+ varying and vertex data would be interpolated the same way. By convention
+ varying is the preferred interpolation because of the association of
+ varying with linear interpolation.
+
+ \\image html USDCurvePrimvars.png
+
+ To convert an entry in the curveVertexCounts vector into a segment count
+ for an individual curve, apply these rules. Sum up all the results in
+ order to compute how many total segments all curves have.
+
+ The following tables describe the expected segment count for the 'i'th
+ curve in a curve batch as well as the entire batch. Python syntax
+ like '[:]' (to describe all members of an array) and 'len(...)'
+ (to describe the length of an array) are used.
+
+ type | wrap | curve segment count | batch segment count
+ ------- | --------------------------- | -------------------------------------- | --------------------------
+ linear | nonperiodic | curveVertexCounts[i] - 1 | sum(curveVertexCounts[:]) - len(curveVertexCounts)
+ linear | periodic | curveVertexCounts[i] | sum(curveVertexCounts[:])
+ cubic | nonperiodic | (curveVertexCounts[i] - 4) / vstep + 1 | sum(curveVertexCounts[:] - 4) / vstep + len(curveVertexCounts)
+ cubic | periodic | curveVertexCounts[i] / vstep | sum(curveVertexCounts[:]) / vstep
+ cubic | pinned (catmullRom/bspline) | (curveVertexCounts[i] - 2) + 1 | sum(curveVertexCounts[:] - 2) + len(curveVertexCounts)
+
+ The following table descrives the expected size of varying
+ (linearly interpolated) data, derived from the segment counts computed
+ above.
+
+ wrap | curve varying count | batch varying count
+ ------------------- | ---------------------------- | ------------------------------------------------
+ nonperiodic/pinned | segmentCounts[i] + 1 | sum(segmentCounts[:]) + len(curveVertexCounts)
+ periodic | segmentCounts[i] | sum(segmentCounts[:])
+
+ Both curve types additionally define 'constant' interpolation for the
+ entire prim and 'uniform' interpolation as per curve data.
+
+
+ \\note Take care when providing support for linearly interpolated data for
+ cubic curves. Its shape doesn't provide a one to one mapping with either
+ the number of curves (like 'uniform') or the number of vertices (like
+ 'vertex') and so it is often overlooked. This is the only primitive in
+ UsdGeom (as of this writing) where this is true. For meshes, while they
+ use different interpolation methods, 'varying' and 'vertex' are both
+ specified per point. It's common to assume that curves follow a similar
+ pattern and build in structures and language for per primitive, per
+ element, and per point data only to come upon these arrays that don't
+ quite fit into either of those categories. It is
+ also common to conflate 'varying' with being per segment data and use the
+ segmentCount rules table instead of its neighboring varying data table
+ rules. We suspect that this is because for the common case of
+ nonperiodic cubic curves, both the provided segment count and varying data
+ size formula end with '+ 1'. While debugging, users may look at the double
+ '+ 1' as a mistake and try to remove it. We take this time to enumerate
+ these issues because we've fallen into them before and hope that we save
+ others time in their own implementations.
+
+ As an example of deriving per curve segment and varying primvar data counts from
+ the wrap, type, basis, and curveVertexCount, the following table is provided.
+
+ wrap | type | basis | curveVertexCount | curveSegmentCount | varyingDataCount
+ ------------- | ------- | ------- | ----------------- | ------------------ | -------------------------
+ nonperiodic | linear | N/A | [2 3 2 5] | [1 2 1 4] | [2 3 2 5]
+ nonperiodic | cubic | bezier | [4 7 10 4 7] | [1 2 3 1 2] | [2 3 4 2 3]
+ nonperiodic | cubic | bspline | [5 4 6 7] | [2 1 3 4] | [3 2 4 5]
+ periodic | cubic | bezier | [6 9 6] | [2 3 2] | [2 3 2]
+ periodic | linear | N/A | [3 7] | [3 7] | [3 7]
+
+ \\section UsdGeomBasisCurves_TubesAndRibbons Tubes and Ribbons
+
+ The strictest definition of a curve as an infinitely thin wire is not
+ particularly useful for describing production scenes. The additional
+ \\em widths and \\em normals attributes can be used to describe cylindrical
+ tubes and or flat oriented ribbons.
+
+ Curves with only widths defined are imaged as tubes with radius
+ 'width / 2'. Curves with both widths and normals are imaged as ribbons
+ oriented in the direction of the interpolated normal vectors.
+
+ While not technically UsdGeomPrimvars, widths and normals
+ also have interpolation metadata. It's common for authored widths to have
+ constant, varying, or vertex interpolation
+ (see UsdGeomCurves::GetWidthsInterpolation()). It's common for
+ authored normals to have varying interpolation
+ (see UsdGeomPointBased::GetNormalsInterpolation()).
+
+ \\image html USDCurveHydra.png
+
+ The file used to generate these curves can be found in
+ extras/usd/examples/usdGeomExamples/basisCurves.usda. It's provided
+ as a reference on how to properly image both tubes and ribbons. The first
+ row of curves are linear; the second are cubic bezier. (We aim in future
+ releases of HdSt to fix the discontinuity seen with broken tangents to
+ better match offline renderers like RenderMan.) The yellow and violet
+ cubic curves represent cubic vertex width interpolation for which there is
+ no equivalent for linear curves.
+
+ \\note How did this prim type get its name? This prim is a portmanteau of
+ two different statements in the original RenderMan specification:
+ 'Basis' and 'Curves'.
+"""
+) {
+ # interpolation attributes
+ uniform token type = "cubic" (
+ allowedTokens = ["linear", "cubic"]
+ doc = """Linear curves interpolate linearly between two vertices.
+ Cubic curves use a basis matrix with four vertices to interpolate a segment.""")
+
+ uniform token basis = "bezier" (
+ allowedTokens = ["bezier", "bspline", "catmullRom"]
+ doc = """The basis specifies the vstep and matrix used for cubic
+ interpolation. \\note The 'hermite' and 'power' tokens have been
+ removed. We've provided UsdGeomHermiteCurves
+ as an alternative for the 'hermite' basis.""")
+
+ uniform token wrap = "nonperiodic" (
+ allowedTokens = ["nonperiodic", "periodic", "pinned"]
+ doc = """If wrap is set to periodic, the curve when rendered will
+ repeat the initial vertices (dependent on the vstep) to close the
+ curve. If wrap is set to 'pinned', phantom points may be created
+ to ensure that the curve interpolation starts at P[0] and ends at P[n-1].
+ """)
+}
+
+class NurbsCurves "NurbsCurves" (
+ inherits =
+ doc = """This schema is analagous to NURBS Curves in packages like Maya
+ and Houdini, often used for interchange of rigging and modeling curves.
+ Unlike Maya, this curve spec supports batching of multiple curves into a
+ single prim, widths, and normals in the schema. Additionally, we require
+ 'numSegments + 2 * degree + 1' knots (2 more than maya does). This is to
+ be more consistent with RenderMan's NURBS patch specification.
+
+ To express a periodic curve:
+ - knot[0] = knot[1] - (knots[-2] - knots[-3];
+ - knot[-1] = knot[-2] + (knot[2] - knots[1]);
+
+ To express a nonperiodic curve:
+ - knot[0] = knot[1];
+ - knot[-1] = knot[-2];
+
+ In spite of these slight differences in the spec, curves generated in Maya
+ should be preserved when roundtripping.
+
+ \\em order and \\em range, when representing a batched NurbsCurve should be
+ authored one value per curve. \\em knots should be the concatentation of
+ all batched curves."""
+) {
+ # topology attributes
+ int[] order = [] (
+ doc = """Order of the curve. Order must be positive and is
+ equal to the degree of the polynomial basis to be evaluated, plus 1.
+ Its value for the 'i'th curve must be less than or equal to
+ curveVertexCount[i]""")
+
+ # interpolation attributes
+ double[] knots (
+ doc = """Knot vector providing curve parameterization.
+ The length of the slice of the array for the ith curve
+ must be ( curveVertexCount[i] + order[i] ), and its
+ entries must take on monotonically increasing values.""")
+
+ double2[] ranges (
+ doc = """Provides the minimum and maximum parametric values (as defined
+ by knots) over which the curve is actually defined. The minimum must
+ be less than the maximum, and greater than or equal to the value of the
+ knots['i'th curve slice][order[i]-1]. The maxium must be less
+ than or equal to the last element's value in knots['i'th curve slice].
+ Range maps to (vmin, vmax) in the RenderMan spec.""")
+
+ double[] pointWeights (
+ doc = """Optionally provides "w" components for each control point,
+ thus must be the same length as the points attribute. If authored,
+ the curve will be rational. If unauthored, the curve will be
+ polynomial, i.e. weight for all points is 1.0.
+ \\note Some DCC's pre-weight the \\em points, but in this schema,
+ \\em points are not pre-weighted."""
+ )
+}
+
+class Points "Points" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+ inherits =
+ doc = """Points are analogous to the RiPoints spec.
+
+ Points can be an efficient means of storing and rendering particle
+ effects comprised of thousands or millions of small particles. Points
+ generally receive a single shading sample each, which should take
+ \\em normals into account, if present.
+
+ While not technically UsdGeomPrimvars, the widths and normals also
+ have interpolation metadata. It's common for authored widths and normals
+ to have constant or varying interpolation."""
+
+) {
+ # shaping attributes
+ float[] widths (
+ doc = """Widths are defined as the \\em diameter of the points, in
+ object space. 'widths' is not a generic Primvar, but
+ the number of elements in this attribute will be determined by
+ its 'interpolation'. See \\ref SetWidthsInterpolation() . If
+ 'widths' and 'primvars:widths' are both specified, the latter
+ has precedence."""
+ )
+
+ int64[] ids (
+ doc = """Ids are optional; if authored, the ids array should be the same
+ length as the points array, specifying (at each timesample if
+ point identities are changing) the id of each point. The
+ type is signed intentionally, so that clients can encode some
+ binary state on Id'd points without adding a separate
+ primvar."""
+ )
+}
+
+class PointInstancer "PointInstancer" (
+ doc = """Encodes vectorized instancing of multiple, potentially
+ animated, prototypes (object/instance masters), which can be arbitrary
+ prims/subtrees on a UsdStage.
+
+ PointInstancer is a "multi instancer", as it allows multiple prototypes
+ to be scattered among its "points". We use a UsdRelationship
+ \\em prototypes to identify and order all of the possible prototypes, by
+ targeting the root prim of each prototype. The ordering imparted by
+ relationships associates a zero-based integer with each prototype, and
+ it is these integers we use to identify the prototype of each instance,
+ compactly, and allowing prototypes to be swapped out without needing to
+ reauthor all of the per-instance data.
+
+ The PointInstancer schema is designed to scale to billions of instances,
+ which motivates the choice to split the per-instance transformation into
+ position, (quaternion) orientation, and scales, rather than a
+ 4x4 matrix per-instance. In addition to requiring fewer bytes even if
+ all elements are authored (32 bytes vs 64 for a single-precision 4x4
+ matrix), we can also be selective about which attributes need to animate
+ over time, for substantial data reduction in many cases.
+
+ Note that PointInstancer is \\em not a Gprim, since it is not a graphical
+ primitive by any stretch of the imagination. It \\em is, however,
+ Boundable, since we will sometimes want to treat the entire PointInstancer
+ similarly to a procedural, from the perspective of inclusion or framing.
+
+ \\section UsdGeomPointInstancer_varyingTopo Varying Instance Identity over Time
+
+ PointInstancers originating from simulations often have the characteristic
+ that points/instances are "born", move around for some time period, and then
+ die (or leave the area of interest). In such cases, billions of instances
+ may be birthed over time, while at any \\em specific time, only a much
+ smaller number are actually alive. To encode this situation efficiently,
+ the simulator may re-use indices in the instance arrays, when a particle
+ dies, its index will be taken over by a new particle that may be birthed in
+ a much different location. This presents challenges both for
+ identity-tracking, and for motion-blur.
+
+ We facilitate identity tracking by providing an optional, animatable
+ \\em ids attribute, that specifies the 64 bit integer ID of the particle
+ at each index, at each point in time. If the simulator keeps monotonically
+ increasing a particle-count each time a new particle is birthed, it will
+ serve perfectly as particle \\em ids.
+
+ We facilitate motion blur for varying-topology particle streams by
+ optionally allowing per-instance \\em velocities and \\em angularVelocities
+ to be authored. If instance transforms are requested at a time between
+ samples and either of the velocity attributes is authored, then we will
+ not attempt to interpolate samples of \\em positions or \\em orientations.
+ If not authored, and the bracketing samples have the same length, then we
+ will interpolate.
+
+ \\section UsdGeomPointInstancer_transform Computing an Instance Transform
+
+ Each instance's transformation is a combination of the SRT affine transform
+ described by its scale, orientation, and position, applied \\em after
+ (i.e. less locally than) the local to parent transformation computed at
+ the root of the prototype it is instancing.
+
+ If your processing of prototype geometry naturally takes into account the
+ transform of the prototype root, then this term can be omitted from the
+ computation of each instance transform, and this can be controlled when
+ computing instance transformation matrices using the
+ UsdGeomPointInstancer::PrototypeXformInclusion enumeration.
+
+ To understand the computation of the instance transform, in order to put
+ an instance of a PointInstancer into the space of the PointInstancer's
+ parent prim we do the following:
+
+ 1. Apply (most locally) the authored local to parent transformation for
+ prototypes[protoIndices[i]]
+ 2. If *scales* is authored, next apply the scaling matrix from *scales[i]*
+ 3. If *orientations* is authored: **if *angularVelocities* is authored**,
+ first multiply *orientations[i]* by the unit quaternion derived by scaling
+ *angularVelocities[i]* by the \\ref UsdGeom_PITimeScaling "time differential"
+ from the left-bracketing timeSample for *orientation* to the requested
+ evaluation time *t*, storing the result in *R*, **else** assign *R*
+ directly from *orientations[i]*. Apply the rotation matrix derived
+ from *R*.
+ 4. Apply the translation derived from *positions[i]*. If *velocities* is
+ authored, apply the translation deriving from *velocities[i]* scaled by
+ the time differential from the left-bracketing timeSample for *positions*
+ to the requested evaluation time *t*.
+ 5. Least locally, apply the transformation authored on the PointInstancer
+ prim itself (or the UsdGeomImageable::ComputeLocalToWorldTransform() of the
+ PointInstancer to put the instance directly into world space)
+
+ If neither *velocities* nor *angularVelocities* are authored, we fallback to
+ standard position and orientation computation logic (using linear
+ interpolation between timeSamples) as described by
+ \\ref UsdGeom_VelocityInterpolation .
+
+ \\anchor UsdGeom_PITimeScaling
+ Scaling Velocities for Interpolation
+
+ When computing time-differentials by which to apply velocity or
+ angularVelocity to positions or orientations, we must scale by
+ ( 1.0 / UsdStage::GetTimeCodesPerSecond() ), because velocities are recorded
+ in units/second, while we are interpolating in UsdTimeCode ordinates.
+
+ We provide both high and low-level API's for dealing with the
+ transformation as a matrix, both will compute the instance matrices using
+ multiple threads; the low-level API allows the client to cache unvarying
+ inputs so that they need not be read duplicately when computing over
+ time.
+
+ See also \\ref UsdGeom_VelocityInterpolation .
+
+ \\section UsdGeomPointInstancer_primvars Primvars on PointInstancer
+
+ \\ref UsdGeomPrimvar "Primvars" authored on a PointInstancer prim should
+ always be applied to each instance with \\em constant interpolation at
+ the root of the instance. When you are authoring primvars on a
+ PointInstancer, think about it as if you were authoring them on a
+ point-cloud (e.g. a UsdGeomPoints gprim). The same
+ interpolation rules for points apply here, substituting
+ "instance" for "point".
+
+ In other words, the (constant) value extracted for each instance
+ from the authored primvar value depends on the authored \\em interpolation
+ and \\em elementSize of the primvar, as follows:
+ \\li constant or uniform : the entire authored value of the
+ primvar should be applied exactly to each instance.
+ \\li varying, vertex, or faceVarying: the first
+ \\em elementSize elements of the authored primvar array should be assigned to
+ instance zero, the second \\em elementSize elements should be assigned to
+ instance one, and so forth.
+
+
+ \\section UsdGeomPointInstancer_masking Masking Instances: "Deactivating" and Invising
+
+ Often a PointInstancer is created "upstream" in a graphics pipeline, and
+ the needs of "downstream" clients necessitate eliminating some of the
+ instances from further consideration. Accomplishing this pruning by
+ re-authoring all of the per-instance attributes is not very attractive,
+ since it may mean destructively editing a large quantity of data. We
+ therefore provide means of "masking" instances by ID, such that the
+ instance data is unmolested, but per-instance transform and primvar data
+ can be retrieved with the no-longer-desired instances eliminated from the
+ (smaller) arrays. PointInstancer allows two independent means of masking
+ instances by ID, each with different features that meet the needs of
+ various clients in a pipeline. Both pruning features' lists of ID's are
+ combined to produce the mask returned by ComputeMaskAtTime().
+
+ \\note If a PointInstancer has no authored \\em ids attribute, the masking
+ features will still be available, with the integers specifying element
+ position in the \\em protoIndices array rather than ID.
+
+ \\subsection UsdGeomPointInstancer_inactiveIds InactiveIds: List-edited, Unvarying Masking
+
+ The first masking feature encodes a list of IDs in a list-editable metadatum
+ called \\em inactiveIds, which, although it does not have any similar
+ impact to stage population as \\ref UsdPrim::SetActive() "prim activation",
+ it shares with that feature that its application is uniform over all time.
+ Because it is list-editable, we can \\em sparsely add and remove instances
+ from it in many layers.
+
+ This sparse application pattern makes \\em inactiveIds a good choice when
+ further downstream clients may need to reverse masking decisions made
+ upstream, in a manner that is robust to many kinds of future changes to
+ the upstream data.
+
+ See ActivateId(), ActivateIds(), DeactivateId(), DeactivateIds(),
+ ActivateAllIds()
+
+ \\subsection UsdGeomPointInstancer_invisibleIds invisibleIds: Animatable Masking
+
+ The second masking feature encodes a list of IDs in a time-varying
+ Int64Array-valued UsdAttribute called \\em invisibleIds , since it shares
+ with \\ref UsdGeomImageable::GetVisibilityAttr() "Imageable visibility"
+ the ability to animate object visibility.
+
+ Unlike \\em inactiveIds, overriding a set of opinions for \\em invisibleIds
+ is not at all straightforward, because one will, in general need to
+ reauthor (in the overriding layer) **all** timeSamples for the attribute
+ just to change one Id's visibility state, so it cannot be authored
+ sparsely. But it can be a very useful tool for situations like encoding
+ pre-computed camera-frustum culling of geometry when either or both of
+ the instances or the camera is animated.
+
+ See VisId(), VisIds(), InvisId(), InvisIds(), VisAllIds()
+
+ \\section UsdGeomPointInstancer_protoProcessing Processing and Not Processing Prototypes
+
+ Any prim in the scenegraph can be targeted as a prototype by the
+ \\em prototypes relationship. We do not, however, provide a specific
+ mechanism for identifying prototypes as geometry that should not be drawn
+ (or processed) in their own, local spaces in the scenegraph. We
+ encourage organizing all prototypes as children of the PointInstancer
+ prim that consumes them, and pruning "raw" processing and drawing
+ traversals when they encounter a PointInstancer prim; this is what the
+ UsdGeomBBoxCache and UsdImaging engines do.
+
+ There \\em is a pattern one can deploy for organizing the prototypes
+ such that they will automatically be skipped by basic UsdPrim::GetChildren()
+ or UsdPrimRange traversals. Usd prims each have a
+ \\ref Usd_PrimSpecifiers "specifier" of "def", "over", or "class". The
+ default traversals skip over prims that are "pure overs" or classes. So
+ to protect prototypes from all generic traversals and processing, place
+ them under a prim that is just an "over". For example,
+ \\code
+ 01 def PointInstancer "Crowd_Mid"
+ 02 {
+ 03 rel prototypes = [ , ]
+ 04
+ 05 over "Prototypes"
+ 06 {
+ 07 def "MaleThin_Business" (
+ 08 references = [@MaleGroupA/usd/MaleGroupA.usd@]
+ 09 variants = {
+ 10 string modelingVariant = "Thin"
+ 11 string costumeVariant = "BusinessAttire"
+ 12 }
+ 13 )
+ 14 { ... }
+ 15
+ 16 def "MaleThin_Casual"
+ 17 ...
+ 18 }
+ 19 }
+ \\endcode
+ """
+
+ inherits =
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ dictionary schemaTokens = {
+ dictionary inactiveIds = {
+ string doc = """int64listop prim metadata that specifies
+ the PointInstancer ids that should be masked (unrenderable)
+ over all time."""
+ }
+ }
+ }
+) {
+ rel prototypes (
+ doc = """Required property. Orders and targets the prototype root
+ prims, which can be located anywhere in the scenegraph that is convenient,
+ although we promote organizing prototypes as children of the
+ PointInstancer. The position of a prototype in this relationship defines
+ the value an instance would specify in the \\em protoIndices attribute to
+ instance that prototype. Since relationships are uniform, this property
+ cannot be animated."""
+ )
+
+ int[] protoIndices (
+ doc = """Required property. Per-instance index into
+ \\em prototypes relationship that identifies what geometry should be
+ drawn for each instance. Topology attribute - can be animated,
+ but at a potential performance impact for streaming."""
+ )
+
+ int64[] ids (
+ doc = """Ids are optional; if authored, the ids array should be the same
+ length as the \\em protoIndices array, specifying (at each timeSample if
+ instance identities are changing) the id of each instance. The
+ type is signed intentionally, so that clients can encode some
+ binary state on Id'd instances without adding a separate primvar.
+ See also \\ref UsdGeomPointInstancer_varyingTopo"""
+ )
+
+ point3f[] positions (
+ doc = """Required property. Per-instance position. See also
+ \\ref UsdGeomPointInstancer_transform ."""
+ )
+
+ quath[] orientations (
+ doc="""If authored, per-instance orientation of each instance about its
+ prototype's origin, represented as a unit length quaternion, which
+ allows us to encode it with sufficient precision in a compact GfQuath.
+
+ It is client's responsibility to ensure that authored quaternions are
+ unit length; the convenience API below for authoring orientations from
+ rotation matrices will ensure that quaternions are unit length, though
+ it will not make any attempt to select the "better (for interpolation
+ with respect to neighboring samples)" of the two possible quaternions
+ that encode the rotation.
+
+ See also \\ref UsdGeomPointInstancer_transform .""" )
+
+ quatf[] orientationsf (
+ doc="""If authored, per-instance orientation of each instance about its
+ prototype's origin, represented as a unit length quaternion, encoded
+ as a GfQuatf to support higher precision computations.
+
+ It is client's responsibility to ensure that authored quaternions are
+ unit length; the convenience API below for authoring orientations from
+ rotation matrices will ensure that quaternions are unit length, though
+ it will not make any attempt to select the "better (for interpolation
+ with respect to neighboring samples)" of the two possible quaternions
+ that encode the rotation. Note that if the earliest time sample (or
+ default value if there are no time samples) of orientationsf is not empty
+ orientationsf will be preferred over orientations if both are authored.
+
+ See also \\ref UsdGeomPointInstancer_transform .""" )
+
+ float3[] scales (
+ doc="""If authored, per-instance scale to be applied to
+ each instance, before any rotation is applied.
+
+ See also \\ref UsdGeomPointInstancer_transform ."""
+ )
+
+ vector3f[] velocities (
+ doc = """If provided, per-instance 'velocities' will be used to
+ compute positions between samples for the 'positions' attribute,
+ rather than interpolating between neighboring 'positions' samples.
+ Velocities should be considered mandatory if both \\em protoIndices
+ and \\em positions are animated. Velocity is measured in position
+ units per second, as per most simulation software. To convert to
+ position units per UsdTimeCode, divide by
+ UsdStage::GetTimeCodesPerSecond().
+
+ See also \\ref UsdGeomPointInstancer_transform,
+ \\ref UsdGeom_VelocityInterpolation ."""
+ )
+
+ vector3f[] accelerations (
+ doc = """If authored, per-instance 'accelerations' will be used with
+ velocities to compute positions between samples for the 'positions'
+ attribute rather than interpolating between neighboring 'positions'
+ samples. Acceleration is measured in position units per second-squared.
+ To convert to position units per squared UsdTimeCode, divide by the
+ square of UsdStage::GetTimeCodesPerSecond()."""
+ )
+
+ vector3f[] angularVelocities (
+ doc="""If authored, per-instance angular velocity vector to be used for
+ interoplating orientations. Angular velocities should be considered
+ mandatory if both \\em protoIndices and \\em orientations are animated.
+ Angular velocity is measured in degrees per second. To convert
+ to degrees per UsdTimeCode, divide by
+ UsdStage::GetTimeCodesPerSecond().
+
+ See also \\ref UsdGeomPointInstancer_transform ."""
+ )
+
+ int64[] invisibleIds = [] (
+ doc="""A list of id's to make invisible at the evaluation time.
+ See \\ref UsdGeomPointInstancer_invisibleIds ."""
+ )
+}
+
+
+class Camera "Camera" (
+ doc = """Transformable camera.
+
+ Describes optical properties of a camera via a common set of attributes
+ that provide control over the camera's frustum as well as its depth of
+ field. For stereo, the left and right camera are individual prims tagged
+ through the \\ref UsdGeomCamera::GetStereoRoleAttr() "stereoRole attribute".
+
+ There is a corresponding class GfCamera, which can hold the state of a
+ camera (at a particular time). \\ref UsdGeomCamera::GetCamera() and
+ \\ref UsdGeomCamera::SetFromCamera() convert between a USD camera prim and
+ a GfCamera.
+
+ To obtain the camera's location in world space, call the following on a
+ UsdGeomCamera 'camera':
+ \\code
+ GfMatrix4d camXform = camera.ComputeLocalToWorldTransform(time);
+ \\endcode
+ \\note
+ Cameras in USD are always "Y up", regardless of the stage's orientation
+ (i.e. UsdGeomGetStageUpAxis()). This means that the inverse of
+ 'camXform' (the VIEW half of the MODELVIEW transform in OpenGL parlance)
+ will transform the world such that the camera is at the origin, looking
+ down the -Z axis, with +Y as the up axis, and +X pointing to the right.
+ This describes a __right handed coordinate system__.
+
+ \\section UsdGeom_CameraUnits Units of Measure for Camera Properties
+
+ Despite the familiarity of millimeters for specifying some physical
+ camera properties, UsdGeomCamera opts for greater consistency with all
+ other UsdGeom schemas, which measure geometric properties in scene units,
+ as determined by UsdGeomGetStageMetersPerUnit(). We do make a
+ concession, however, in that lens and filmback properties are measured in
+ __tenths of a scene unit__ rather than "raw" scene units. This means
+ that with the fallback value of .01 for _metersPerUnit_ - i.e. scene unit
+ of centimeters - then these "tenth of scene unit" properties are
+ effectively millimeters.
+
+ \\note If one adds a Camera prim to a UsdStage whose scene unit is not
+ centimeters, the fallback values for filmback properties will be
+ incorrect (or at the least, unexpected) in an absolute sense; however,
+ proper imaging through a "default camera" with focusing disabled depends
+ only on ratios of the other properties, so the camera is still usable.
+ However, it follows that if even one property is authored in the correct
+ scene units, then they all must be.
+
+
+ \\sa \\ref UsdGeom_LinAlgBasics
+ """
+ inherits =
+ customData = {
+ string extraIncludes = """
+#include "pxr/base/gf/camera.h" """
+ }
+) {
+ # viewing frustum
+ token projection = "perspective" (
+ allowedTokens = ["perspective", "orthographic"])
+ float horizontalAperture = 20.9550 (
+ doc = """Horizontal aperture in tenths of a scene unit; see
+ \\ref UsdGeom_CameraUnits . Default is the equivalent of
+ the standard 35mm spherical projector aperture.""")
+ float verticalAperture = 15.2908 (
+ doc = """Vertical aperture in tenths of a scene unit; see
+ \\ref UsdGeom_CameraUnits . Default is the equivalent of
+ the standard 35mm spherical projector aperture.""")
+ float horizontalApertureOffset = 0.0 (
+ doc = """Horizontal aperture offset in the same units as
+ horizontalAperture. Defaults to 0.""")
+ float verticalApertureOffset = 0.0 (
+ doc = """Vertical aperture offset in the same units as
+ verticalAperture. Defaults to 0.""")
+ float focalLength = 50.0 (
+ doc = """Perspective focal length in tenths of a scene unit; see
+ \\ref UsdGeom_CameraUnits .""")
+ float2 clippingRange = (1, 1000000) (
+ doc = """Near and far clipping distances in scene units; see
+ \\ref UsdGeom_CameraUnits .""")
+ float4[] clippingPlanes = [] (
+ doc = """Additional, arbitrarily oriented clipping planes.
+ A vector (a,b,c,d) encodes a clipping plane that cuts off
+ (x,y,z) with a * x + b * y + c * z + d * 1 < 0 where (x,y,z)
+ are the coordinates in the camera's space.""")
+
+ # depth of field
+ float fStop = 0.0 (
+ doc = """Lens aperture. Defaults to 0.0, which turns off focusing.""")
+ float focusDistance = 0.0 (
+ doc = """Distance from the camera to the focus plane in scene units; see
+ \\ref UsdGeom_CameraUnits .""")
+
+ # stereoscopic 3D
+ uniform token stereoRole = "mono" (
+ allowedTokens = ["mono", "left", "right"]
+ doc = """If different from mono, the camera is intended to be the left
+ or right camera of a stereo setup.""")
+
+ # Parameters for motion blur
+ double shutter:open = 0.0 (
+ doc = """Frame relative shutter open time in UsdTimeCode units (negative
+ value indicates that the shutter opens before the current
+ frame time). Used for motion blur."""
+ )
+ double shutter:close = 0.0 (
+ doc = """Frame relative shutter close time, analogous comments from
+ shutter:open apply. A value greater or equal to shutter:open
+ should be authored, otherwise there is no exposure and a
+ renderer should produce a black image."""
+ )
+
+ # exposure adjustment
+ float exposure = 0.0 (
+ doc = """Exposure adjustment, as a log base-2 value. The default
+ of 0.0 has no effect. A value of 1.0 will double the
+ image-plane intensities in a rendered image; a value of
+ -1.0 will halve them."""
+ )
+}
+
+class "GeomModelAPI"
+(
+ inherits =
+ customData = {
+ string className = "ModelAPI"
+ string extraIncludes = """
+#include "pxr/usd/usdGeom/bboxCache.h"
+#include "pxr/usd/usdGeom/constraintTarget.h"
+#include "pxr/usd/usdGeom/imageable.h" """
+ dictionary schemaTokens = {
+ dictionary extentsHint = {
+ string doc = """Name of the attribute used to author extents
+ hints at the root of leaf models. Extents hints are stored by purpose
+ as a vector of GfVec3f values. They are ordered based on the order
+ of purpose tokens returned by
+ UsdGeomImageable::GetOrderedPurposeTokens."""
+ }
+ }
+ }
+ doc = """UsdGeomModelAPI extends the generic UsdModelAPI schema with
+ geometry specific concepts such as cached extents for the entire model,
+ constraint targets, and geometry-inspired extensions to the payload
+ lofting process.
+
+ As described in GetExtentsHint() below, it is useful to cache extents
+ at the model level. UsdGeomModelAPI provides schema for computing and
+ storing these cached extents, which can be consumed by UsdGeomBBoxCache to
+ provide fast access to precomputed extents that will be used as the model's
+ bounds ( see UsdGeomBBoxCache::UsdGeomBBoxCache() ).
+
+ \\section UsdGeomModelAPI_drawMode Draw Modes
+
+ Draw modes provide optional alternate imaging behavior for USD subtrees with
+ kind model. \\em model:drawMode (which is inheritable) and
+ \\em model:applyDrawMode (which is not) are resolved into a decision to stop
+ traversing the scene graph at a certain point, and replace a USD subtree
+ with proxy geometry.
+
+ The value of \\em model:drawMode determines the type of proxy geometry:
+ - \\em origin - Draw the model-space basis vectors of the replaced prim.
+ - \\em bounds - Draw the model-space bounding box of the replaced prim.
+ - \\em cards - Draw textured quads as a placeholder for the replaced prim.
+ - \\em default - An explicit opinion to draw the USD subtree as normal.
+ - \\em inherited - Defer to the parent opinion.
+
+ \\em model:drawMode falls back to _inherited_ so that a whole scene,
+ a large group, or all prototypes of a model hierarchy PointInstancer can
+ be assigned a draw mode with a single attribute edit. If no draw mode is
+ explicitly set in a hierarchy, the resolved value is _default_.
+
+ \\em model:applyDrawMode is meant to be written when an asset is authored,
+ and provides flexibility for different asset types. For example,
+ a character assembly (composed of character, clothes, etc) might have
+ \\em model:applyDrawMode set at the top of the subtree so the whole group
+ can be drawn as a single card object. An effects subtree might have
+ \\em model:applyDrawMode set at a lower level so each particle
+ group draws individually.
+
+ Models of kind component are automatically treated as if
+ \\em model:applyDrawMode were true if \\em model:applyDrawMode is not
+ authored on the component prim. A component prim will be drawn drawn with a
+ simplified representation when the prim has kind component,
+ \\em model:applyDrawMode is not authored (or authored to be true), and the
+ resolved (i.e. inherited down namespace) value for \\em model:drawMode is
+ not _default_. If you don't want component prims to use the resolved
+ non-default drawMode, you must apply the UsdGeomModelAPI schema on the prim
+ and explicitly set \\em model:applyDrawMode to false.
+
+ \\section UsdGeomModelAPI_cardGeometry Cards Geometry
+
+ The specific geometry used in cards mode is controlled by the
+ \\em model:cardGeometry attribute:
+ - \\em cross - Generate a quad normal to each basis direction and negative.
+ Locate each quad so that it bisects the model extents.
+ - \\em box - Generate a quad normal to each basis direction and negative.
+ Locate each quad on a face of the model extents, facing out.
+ - \\em fromTexture - Generate a quad for each supplied texture from
+ attributes stored in that texture's metadata.
+
+ For \\em cross and \\em box mode, the extents are calculated for purposes
+ \\em default, \\em proxy, and \\em render, at their earliest authored time.
+ If the model has no textures, all six card faces are rendered using
+ \\em model:drawModeColor. If one or more textures are present, only axes
+ with one or more textures assigned are drawn. For each axis, if both
+ textures (positive and negative) are specified, they'll be used on the
+ corresponding card faces; if only one texture is specified, it will be
+ mapped to the opposite card face after being flipped on the texture's
+ s-axis. Any card faces with invalid asset paths will be drawn with
+ \\em model:drawModeColor.
+
+ Both \\em model:cardGeometry and \\em model:drawModeColor should be
+ authored on the prim where the draw mode takes effect, since these
+ attributes are not inherited.
+
+ For \\em fromTexture mode, only card faces with valid textures assigned
+ are drawn. The geometry is generated by pulling the \\em worldtoscreen
+ attribute out of texture metadata. This is expected to be a 4x4 matrix
+ mapping the model-space position of the card quad to the clip-space quad
+ with corners (-1,-1,0) and (1,1,0). The card vertices are generated by
+ transforming the clip-space corners by the inverse of \\em worldtoscreen.
+ Textures are mapped so that (s) and (t) map to (+x) and (+y) in clip space.
+ If the metadata cannot be read in the right format, or the matrix can't
+ be inverted, the card face is not drawn.
+
+ All card faces are drawn and textured as single-sided.
+
+ \\todo CreatePayload() """
+)
+{
+ uniform token model:drawMode = "inherited" (
+ allowedTokens = ["origin", "bounds", "cards", "default", "inherited"]
+ doc = """Alternate imaging mode; applied to this prim or child prims
+ where \\em model:applyDrawMode is true, or where the prim
+ has kind \\em component and \\em model:applyDrawMode is not
+ authored. See \\ref UsdGeomModelAPI_drawMode
+ for mode descriptions."""
+ )
+ uniform bool model:applyDrawMode = false (
+ doc = """If true, and the resolved value of \\em model:drawMode is
+ non-default, apply an alternate imaging mode to this prim. See
+ \\ref UsdGeomModelAPI_drawMode."""
+ )
+ uniform float3 model:drawModeColor = (0.18, 0.18, 0.18) (
+ doc = """The base color of imaging prims inserted for alternate
+ imaging modes. For \\em origin and \\em bounds modes, this
+ controls line color; for \\em cards mode, this controls the
+ fallback quad color."""
+ )
+ uniform token model:cardGeometry = "cross" (
+ allowedTokens = ["cross", "box", "fromTexture"]
+ doc = """The geometry to generate for imaging prims inserted for \\em
+ cards imaging mode. See \\ref UsdGeomModelAPI_cardGeometry for
+ geometry descriptions."""
+ )
+ asset model:cardTextureXPos (
+ doc = """In \\em cards imaging mode, the texture applied to the X+ quad.
+ The texture axes (s,t) are mapped to model-space axes (-y, -z)."""
+ )
+ asset model:cardTextureYPos (
+ doc = """In \\em cards imaging mode, the texture applied to the Y+ quad.
+ The texture axes (s,t) are mapped to model-space axes (x, -z)."""
+ )
+ asset model:cardTextureZPos (
+ doc = """In \\em cards imaging mode, the texture applied to the Z+ quad.
+ The texture axes (s,t) are mapped to model-space axes (x, -y)."""
+ )
+ asset model:cardTextureXNeg (
+ doc = """In \\em cards imaging mode, the texture applied to the X- quad.
+ The texture axes (s,t) are mapped to model-space axes (y, -z)."""
+ )
+ asset model:cardTextureYNeg (
+ doc = """In \\em cards imaging mode, the texture applied to the Y- quad.
+ The texture axes (s,t) are mapped to model-space axes (-x, -z)."""
+ )
+ asset model:cardTextureZNeg (
+ doc = """In \\em cards imaging mode, the texture applied to the Z- quad.
+ The texture axes (s,t) are mapped to model-space axes (-x, -y)."""
+ )
+}
+
+class "MotionAPI"
+(
+ inherits =
+ doc = """UsdGeomMotionAPI encodes data that can live on any prim that
+ may affect computations involving:
+ - computed motion for motion blur
+ - sampling for motion blur
+
+ The \\ref GetMotionBlurScaleAttr() "motion:blurScale" attribute allows
+ artists to scale the __amount__ of motion blur to be rendered for parts
+ of the scene without changing the recorded animation. See
+ \\ref UsdGeomMotionAPI_blurScale for use and implementation details.
+
+ """
+)
+{
+ float motion:blurScale = 1.0 (
+ doc = """BlurScale is an __inherited__ float attribute that stipulates
+ the rendered motion blur (as typically specified via UsdGeomCamera's
+ _shutter:open_ and _shutter:close_ properties) should be scaled for
+ __all objects__ at and beneath the prim in namespace on which the
+ _motion:blurScale_ value is specified.
+
+ Without changing any other data in the scene, _blurScale_ allows artists to
+ "dial in" the amount of blur on a per-object basis. A _blurScale_
+ value of zero removes all blur, a value of 0.5 reduces blur by half,
+ and a value of 2.0 doubles the blur. The legal range for _blurScale_
+ is [0, inf), although very high values may result in extremely expensive
+ renders, and may exceed the capabilities of some renderers.
+
+ Although renderers are free to implement this feature however they see
+ fit, see \\ref UsdGeomMotionAPI_blurScale for our guidance on implementing
+ the feature universally and efficiently.
+
+ \\sa ComputeMotionBlurScale()
+ """
+ )
+
+ float motion:velocityScale = 1.0 (
+ customData = {
+ string apiName = "velocityScale"
+ }
+ doc = """\\deprecated
+
+ VelocityScale is an **inherited** float attribute that
+ velocity-based schemas (e.g. PointBased, PointInstancer) can consume
+ to compute interpolated positions and orientations by applying
+ velocity and angularVelocity, which is required for interpolating
+ between samples when topology is varying over time. Although these
+ quantities are generally physically computed by a simulator, sometimes
+ we require more or less motion-blur to achieve the desired look.
+ VelocityScale allows artists to dial-in, as a post-sim correction,
+ a scale factor to be applied to the velocity prior to computing
+ interpolated positions from it."""
+ )
+
+ int motion:nonlinearSampleCount = 3 (
+ customData = {
+ string apiName = "nonlinearSampleCount"
+ }
+ doc = """Determines the number of position or transformation samples
+ created when motion is described by attributes contributing non-linear
+ terms.
+
+ To give an example, imagine an application (such as a
+ renderer) consuming 'points' and the USD document also
+ contains 'accelerations' for the same prim. Unless the
+ application can consume these 'accelerations' itself, an
+ intermediate layer has to compute samples within the sampling
+ interval for the point positions based on the value of
+ 'points', 'velocities' and 'accelerations'. The number of these
+ samples is given by 'nonlinearSampleCount'. The samples are
+ equally spaced within the sampling interval.
+
+ Another example involves the PointInstancer where
+ 'nonlinearSampleCount' is relevant when 'angularVelocities'
+ or 'accelerations' are authored.
+
+ 'nonlinearSampleCount' is an **inherited** attribute, also
+ see ComputeNonlinearSampleCount()"""
+ )
+}
+
+class "XformCommonAPI"
+(
+ inherits =
+ doc = """This class provides API for authoring and retrieving a standard set
+ of component transformations which include a scale, a rotation, a
+ scale-rotate pivot and a translation. The goal of the API is to enhance
+ component-wise interchange. It achieves this by limiting the set of allowed
+ basic ops and by specifying the order in which they are applied. In addition
+ to the basic set of ops, the 'resetXformStack' bit can also be set to
+ indicate whether the underlying xformable resets the parent transformation
+ (i.e. does not inherit it's parent's transformation).
+
+ \\sa UsdGeomXformCommonAPI::GetResetXformStack()
+ \\sa UsdGeomXformCommonAPI::SetResetXformStack()
+
+ The operator-bool for the class will inform you whether an existing
+ xformable is compatible with this API.
+
+ The scale-rotate pivot is represented by a pair of (translate,
+ inverse-translate) xformOps around the scale and rotate operations.
+ The rotation operation can be any of the six allowed Euler angle sets.
+ \\sa UsdGeomXformOp::Type.
+
+ The xformOpOrder of an xformable that has all of the supported basic ops
+ is as follows:
+ ["xformOp:translate", "xformOp:translate:pivot", "xformOp:rotateXYZ",
+ "xformOp:scale", "!invert!xformOp:translate:pivot"].
+
+ It is worth noting that all of the ops are optional. For example, an
+ xformable may have only a translate or a rotate. It would still be
+ considered as compatible with this API. Individual SetTranslate(),
+ SetRotate(), SetScale() and SetPivot() methods are provided by this API
+ to allow such sparse authoring."""
+ customData = {
+ string apiSchemaType = "nonApplied"
+ string extraIncludes = """
+#include "pxr/usd/usdGeom/xformable.h"
+#include "pxr/usd/usdGeom/xformOp.h" """
+ dictionary schemaTokens = {
+ dictionary pivot = {
+ string doc = """Op suffix for the standard scale-rotate pivot
+ on a UsdGeomXformCommonAPI-compatible prim.
+ """
+ }
+ }
+ }
+)
+{
+}
+
+class HermiteCurves "HermiteCurves" (
+ inherits =
+ doc = """This schema specifies a cubic hermite interpolated curve batch as
+ sometimes used for defining guides for animation. While hermite curves can
+ be useful because they interpolate through their control points, they are
+ not well supported by high-end renderers for imaging. Therefore, while we
+ include this schema for interchange, we strongly recommend the use of
+ UsdGeomBasisCurves as the representation of curves intended to be rendered
+ (ie. hair or grass). Hermite curves can be converted to a Bezier
+ representation (though not from Bezier back to Hermite in general).
+
+ \\section UsdGeomHermiteCurves_Interpolation Point Interpolation
+
+ The initial cubic curve segment is defined by the first two points and
+ first two tangents. Additional segments are defined by additional
+ point / tangent pairs. The number of segments for each non-batched hermite
+ curve would be len(curve.points) - 1. The total number of segments
+ for the batched UsdGeomHermiteCurves representation is
+ len(points) - len(curveVertexCounts).
+
+ \\section UsdGeomHermiteCurves_Primvars Primvar, Width, and Normal Interpolation
+
+ Primvar interpolation is not well specified for this type as it is not
+ intended as a rendering representation. We suggest that per point
+ primvars would be linearly interpolated across each segment and should
+ be tagged as 'varying'.
+
+ It is not immediately clear how to specify cubic or 'vertex' interpolation
+ for this type, as we lack a specification for primvar tangents. This
+ also means that width and normal interpolation should be restricted to
+ varying (linear), uniform (per curve element), or constant (per prim).
+ """
+) {
+ vector3f[] tangents = [] (
+ doc = """Defines the outgoing trajectory tangent for each point.
+ Tangents should be the same size as the points attribute.""")
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class "HydraGenerativeProceduralAPI" (
+ doc = """
+ This API extends and configures the core UsdProcGenerativeProcedural schema
+ defined within usdProc for use with hydra generative procedurals as defined
+ within hdGp.
+ """
+)
+{
+ token primvars:hdGp:proceduralType (
+ doc = """The registered name of a HdGpGenerativeProceduralPlugin to
+ be executed."""
+ )
+ token proceduralSystem = "hydraGenerativeProcedural" (
+ doc = '''
+ This value should correspond to a configured instance of
+ HdGpGenerativeProceduralResolvingSceneIndex which will evaluate the
+ procedural. The default value of "hydraGenerativeProcedural" matches
+ the equivalent default of HdGpGenerativeProceduralResolvingSceneIndex.
+ Multiple instances of the scene index can be used to determine where
+ within a scene index chain a given procedural will be evaluated.
+ '''
+ )
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "UsdHydraDiscoveryPlugin": {
+ "bases": [
+ "NdrDiscoveryPlugin"
+ ],
+ "displayName": "Discovery plugin for deprecated hydra shaders."
+ },
+ "UsdHydraGenerativeProceduralAPI": {
+ "alias": {
+ "UsdSchemaBase": "HydraGenerativeProceduralAPI"
+ },
+ "apiSchemaCanOnlyApplyTo": [
+ "GenerativeProcedural"
+ ],
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdHydra",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+
+-- configuration
+{
+ "techniques": {
+ "default": {
+ }
+ }
+}
+
+-- This file is intentionally empty.
+#usda 1.0
+
+def Shader "HwPtexTexture_1" (
+ sdrMetadata = {
+ token role = "texture"
+ token isPtex = "1"
+ }
+)
+{
+ uniform token info:id = "HwPtexTexture_1"
+ uniform token info:implementationSource = "sourceAsset"
+
+ # Add a dummy sourceAsset attribute with sourceType="glslfx", so that
+ # an entry gets created for this deprecated shader in the registry.
+ uniform asset info:glslfx:sourceAsset = @./empty.glslfx@
+
+ token inputs:faceIndexPrimvar = "ptexFaceIndex" (
+ sdrMetadata = {
+ token primvarProperty = "1"
+ }
+ )
+
+ token inputs:faceOffsetPrimvar = "ptexFaceOffset" (
+ sdrMetadata = {
+ token primvarProperty = "1"
+ }
+ )
+
+ asset inputs:file = @@ (
+ doc = "Asset path to the file containg the image data."
+ )
+
+ float inputs:frame (
+ doc = "The frame offset for animated textures."
+ )
+
+ float inputs:textureMemory (
+ doc = """Amount of memory used to store the texture (in Mb). A value of
+ zero specifies the native resolution."""
+ )
+
+ int inputs:faceIndex (
+ doc = """The Ptex face index from which to sample. By default, this
+ parameter will be bound to the ptexFaceIndex primvar."""
+ )
+
+ int inputs:faceOffset (
+ doc = """The Ptex face offset to be applied to the face index. By
+ default, this parameter will be bound to the ptexFaceOffset primvar."""
+ )
+
+ float outputs:r (
+ doc = "Outputs the red channel."
+ sdrMetadata = {
+ token swizzle = "x"
+ }
+ )
+
+ float outputs:g (
+ doc = "Outputs the green channel."
+ sdrMetadata = {
+ token swizzle = "y"
+ }
+ )
+
+ float outputs:b (
+ doc = "Outputs the blue channnel."
+ sdrMetadata = {
+ token swizzle = "z"
+ }
+ )
+
+ float outputs:a (
+ doc = "Outputs the alpha channnel."
+ sdrMetadata = {
+ token swizzle = "w"
+ }
+ )
+
+ float3 outputs:rgb (
+ doc = "Outputs the red, green and blue channels."
+ sdrMetadata = {
+ token swizzle = "xyz"
+ }
+ )
+
+ float4 outputs:rgba (
+ doc = "Outputs all 4 channels (red, green, blue and alpha)."
+ sdrMetadata = {
+ token swizzle = "xyzw"
+ }
+ )
+}
+
+def Shader "HwUvTexture_1" (
+ sdrMetadata = {
+ token role = "texture"
+ token primvars = "uv"
+ }
+)
+{
+ uniform token info:id = "HwUvTexture_1"
+ uniform token info:implementationSource = "sourceAsset"
+
+ # Add a dummy sourceAsset attribute with sourceType="glslfx", so that
+ # an entry gets created for this deprecated shader in the registry.
+ uniform asset info:glslfx:sourceAsset = @./empty.glslfx@
+
+ asset inputs:file = @@ (
+ doc = "Asset path to the file containg the image data."
+ )
+
+ float inputs:frame (
+ doc = "The frame offset for animated textures."
+ )
+
+ float inputs:textureMemory (
+ doc = """Amount of memory used to store the texture (in Mb). A value of
+ zero specifies the native resolution."""
+ )
+
+ float2 inputs:uv (
+ doc = "The uv coordinates at which to sample the texture."
+ )
+
+ token inputs:wrapS (
+ allowedTokens = ["clamp", "repeat", "mirror", "black"]
+ doc = "Specifies the wrap mode for this texture."
+ )
+
+ token inputs:wrapT (
+ allowedTokens = ["clamp", "repeat", "mirror", "black"]
+ doc = "Specifies the wrap mode for this texture."
+ )
+
+ token inputs:minFilter (
+ allowedTokens = ["nearest", "linear",
+ "linearMipmapLinear", "linearMipmapNearest",
+ "nearestMipmapLinear", "nearestMipmapNearest" ]
+ doc = "Specifies the minification filter mode for this texture."
+ )
+
+ token inputs:magFilter (
+ allowedTokens = ["nearest", "linear"]
+ doc = "Specifies the magnification filter mode for this texture."
+ )
+
+ float4 inputs:fallback = (0.0, 0.0, 0.0, 1.0) (
+ doc = """Fallback value to be used when no texture is connected."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+}
+
+def Shader "HwFieldReader_1" (
+ sdrMetadata = {
+ token role = "field"
+ }
+ doc = """Samples from a usdVol FieldAsset."""
+)
+{
+ uniform asset info:glslfx:sourceAsset = @./empty.glslfx@
+ uniform token info:implementationSource = "sourceAsset"
+ token inputs:fieldname = "" (
+ connectability = "interfaceOnly"
+ doc = """Name of the field to be fetched from volume
+ (e.g., FOO if the relationship from the volume to field is called field::FOO)."""
+ sdrMetadata = {
+ token fieldProperty = "1"
+ }
+ )
+}
+
+def Shader "HwFieldReader_float" (
+ inherits =
+)
+{
+ uniform token info:id = "HwFieldReader_float"
+ float inputs:fallback = 0 (
+ doc = "Fallback value to be returned when fetch failed."
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+ float outputs:result (
+ sdrMetadata = {
+ token swizzle = "x"
+ }
+ )
+}
+
+def Shader "HwFieldReader_float2" (
+ inherits =
+)
+{
+ uniform token info:id = "HwFieldReader_float2"
+ float2 inputs:fallback = (0, 0) (
+ doc = "Fallback value to be returned when fetch failed."
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+ float2 outputs:result (
+ sdrMetadata = {
+ token swizzle = "xy"
+ }
+ )
+}
+
+def Shader "HwFieldReader_float3" (
+ inherits =
+)
+{
+ uniform token info:id = "HwFieldReader_float3"
+ float3 inputs:fallback = (0, 0, 0) (
+ doc = "Fallback value to be returned when fetch failed."
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+ float3 outputs:result (
+ sdrMetadata = {
+ token swizzle = "xyz"
+ }
+ )
+}
+
+def Shader "HwPrimvar_1" (
+ sdrMetadata = {
+ token role = "primvar"
+ }
+)
+{
+ uniform token info:id = "HwPrimvar_1"
+ uniform token info:implementationSource = "sourceAsset"
+
+ # Add a dummy sourceAsset attribute with sourceType="glslfx", so that
+ # an entry gets created for this deprecated shader in the registry.
+ uniform asset info:glslfx:sourceAsset = @./empty.glslfx@
+
+ token inputs:varname = "" (
+ sdrMetadata = {
+ bool primvarProperty = 1
+ }
+ doc = """The name of the primvar. Note that on the gprim, this primvar
+ must follow the standard UsdGeom primvar declaration.
+ Further note that this name should not contain the UsdGeom primvar
+ namespace prefix.
+ """
+ )
+}
+#usda 1.0
+(
+ "This file describes the Pixar-specific USD Geometric schemata for code generation."
+ subLayers = [
+ @usd/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdHydra"
+ string libraryPath = "pxr/usd/usdHydra"
+ dictionary libraryTokens = {
+
+ dictionary HwPrimvar_1 = {
+ string doc = """The id value of a Primvar shader."""
+ }
+
+ dictionary HwPtexTexture_1 = {
+ string doc = """The id value of a PtexTexture shader."""
+ }
+
+ dictionary HwUvTexture_1 = {
+ string doc = """The id value of a UvTexture shader."""
+ }
+
+ dictionary displayLookBxdf = {
+ string value = "displayLook:bxdf"
+ string doc = """\deprecated This has been deprecated in favor of
+ the glslfx:surface output.
+
+ Relationship on a material that targets the "bxdf" or the
+ surface shader prim."""
+ }
+
+ dictionary infoFilename = {
+ string value = "inputs:file"
+ string doc = """ The special "info:filename" property of a hydra
+ Texture shader, which points to a resolvable texture asset."""
+ }
+
+
+ dictionary infoVarname = {
+ string value = "inputs:varname"
+ string doc = """
+ """
+ }
+
+ dictionary textureMemory = {
+ string doc = """A shader input on a hydra Texture shader."""
+ }
+
+ dictionary frame = {
+ string doc = """A shader input on a "Texture" shader."""
+ }
+
+ dictionary uv = {
+ string doc = """A shader input on a hydra UvTexture shader."""
+ }
+
+ dictionary wrapS = {
+ string doc = """A shader input on a hydra UvTexture shader which
+ defines the behavior of texture coordinates that are outside the
+ bounds of the texture."""
+ }
+
+
+ dictionary wrapT = {
+ string doc = """A shader input on a hydra UvTexture shader which
+ defines the behavior of texture coordinates that are outside the
+ bounds of the texture."""
+ }
+
+ dictionary black = {
+ string doc = """Possible value for "wrapT" and "wrapS" inputs on
+ a "UvTexture" shader prim.
+ Causes black to be returned when sampling outside the bounds of
+ the texture."""
+ }
+
+ dictionary clamp = {
+ string doc = """Possible value for "wrapT" and "wrapS" inputs on
+ a "UvTexture" shader prim.
+ Causes the the texture coordinate to be clamped to [0,1]."""
+ }
+
+ dictionary mirror = {
+ string doc = """Possible value for "wrapT" and "wrapS" inputs on
+ a "UvTexture" shader prim.
+ Causes the texture coordinate to wrap around like a mirror. -0.2
+ becomes 0.2, -1.2 becomes 0.8, etc. ,"""
+ }
+
+ dictionary repeat = {
+ string doc = """Possible value for "wrapT" and "wrapS" inputs on
+ a "UvTexture" shader prim.
+ Causes the texture coordinate to wrap around the texture. So a
+ texture coordinate of -0.2 becomes the equivalent of 0.8."""
+ }
+
+ dictionary useMetadata = {
+ string doc = """Possible value for "wrapT" and "wrapS" inputs on
+ a "UvTexture" shader prim.
+ Causes the wrap value to be loaded from the texture file instead
+ of being specified in the prim. If the texture file doesn't
+ support metadata or the metadata doesn't contain a wrap mode,
+ the "black" wrap mode is used."""
+ }
+
+ dictionary magFilter = {
+ string doc = """An input on a UvTexture shader."""
+ }
+
+ dictionary minFilter = {
+ string doc = """An input on a UvTexture shader."""
+ }
+
+ dictionary linearMipmapLinear = {
+ string doc = """See https://www.opengl.org/wiki/Sampler_Object ,
+ Possible value for the "minFilter" input on a UvTexture shader.
+ """
+ }
+
+ dictionary linearMipmapNearest = {
+ string doc = """See https://www.opengl.org/wiki/Sampler_Object
+ Possible value for the "minFilter" input on a UvTexture shader.
+ """
+ }
+
+ dictionary nearestMipmapNearest = {
+ string doc = """See https://www.opengl.org/wiki/Sampler_Object
+ Possible value for the "minFilter" input on a UvTexture shader.
+ """
+ }
+
+ dictionary linear = {
+ string doc = """A weighted linear blend of nearest adjacent
+ samples.
+ Possible value for "minFilter" and "magFilter" inputs on a
+ UvTextureshader."""
+ }
+
+ dictionary nearest = {
+ string doc = """Selects the nearest sample for the given
+ coordinate
+ Possible value for "minFilter" and "magFilter" inputs on a
+ UvTexture shader."""
+ }
+
+ dictionary nearestMipmapLinear = {
+ string doc = """See https://www.opengl.org/wiki/Sampler_Object
+ Possible value for "minFilter" and "magFilter" inputs on a
+ UvTexture shader."""
+ }
+
+ dictionary faceIndex = {
+ string doc = """The "faceIndex" shader input on a hydra
+ "PtexTexture" shader."""
+ }
+
+ dictionary faceOffset = {
+ string doc = """The "faceOffset" shader input on a hydra
+ "PtexTexture" shader."""
+ }
+ }
+ }
+){
+}
+
+class "HydraGenerativeProceduralAPI" (
+ inherits =
+ doc = """
+ This API extends and configures the core UsdProcGenerativeProcedural schema
+ defined within usdProc for use with hydra generative procedurals as defined
+ within hdGp.
+ """
+ customData = {
+ string className = "GenerativeProceduralAPI"
+ token[] apiSchemaCanOnlyApplyTo = ["GenerativeProcedural"]
+ }
+){
+ token primvars:hdGp:proceduralType (
+ doc = """The registered name of a HdGpGenerativeProceduralPlugin to
+ be executed."""
+
+ customData = {
+ string apiName = "proceduralType"
+ }
+ )
+
+ token proceduralSystem = "hydraGenerativeProcedural" (
+ doc = """
+ This value should correspond to a configured instance of
+ HdGpGenerativeProceduralResolvingSceneIndex which will evaluate the
+ procedural. The default value of "hydraGenerativeProcedural" matches
+ the equivalent default of HdGpGenerativeProceduralResolvingSceneIndex.
+ Multiple instances of the scene index can be used to determine where
+ within a scene index chain a given procedural will be evaluated.
+ """
+ )
+}
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "faceIndexPrimvar": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": "ptexFaceIndex",
+ "documentation": "Specifies an array of face indices used for ptex mapping",
+ "type": "token"
+ },
+ "faceOffsetPrimvar": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": "ptexFaceOffset",
+ "documentation": "Specifies the ptex face index offset for aggregated ptex files",
+ "type": "token"
+ },
+ "uvPrimvar": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": "",
+ "documentation": "Specifies the UV primvar for texture mapping",
+ "type": "token"
+ }
+ },
+ "Types": {
+ "UsdImagingBasisCurvesAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "BasisCurves"
+ },
+ "UsdImagingCameraAdapter": {
+ "bases": [
+ "UsdImagingPrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Camera"
+ },
+ "UsdImagingCapsuleAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "includeSchemaFamily": true,
+ "primTypeName": "Capsule"
+ },
+ "UsdImagingCollectionAPIAdapter" : {
+ "bases": ["UsdImagingAPISchemaAdapter"],
+ "isInternal": true,
+ "apiSchemaName": "CollectionAPI"
+ },
+ "UsdImagingConeAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Cone"
+ },
+ "UsdImagingCoordSysAdapter": {
+ "bases": [
+ "UsdImagingPrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "coordSys"
+ },
+ "UsdImagingCoordSysAPIAdapter" : {
+ "bases": ["UsdImagingAPISchemaAdapter"],
+ "isInternal": true,
+ "apiSchemaName": "CoordSysAPI"
+ },
+ "UsdImagingCubeAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Cube"
+ },
+ "UsdImagingCylinderAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "includeSchemaFamily": true,
+ "primTypeName": "Cylinder"
+ },
+ "UsdImagingDrawModeAdapter" : {
+ "bases": ["UsdImagingInstanceablePrimAdapter"],
+ "isInternal": true,
+ "primTypeName": "__drawModeAdapter"
+ },
+ "UsdImagingGeomSubsetAdapter" : {
+ "bases": ["UsdImagingPrimAdapter"],
+ "isInternal": true,
+ "primTypeName": "GeomSubset"
+ },
+ "UsdImagingHermiteCurvesAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "HermiteCurves"
+ },
+ "UsdImagingMaterialAdapter" : {
+ "bases": ["UsdImagingPrimAdapter"],
+ "isInternal": true,
+ "primTypeName": "Material"
+ },
+
+ "UsdImagingShaderAdapter" : {
+ "bases": ["UsdImagingRepresentedByAncestorPrimAdapter"],
+ "isInternal": true,
+ "primTypeName": "Shader"
+ },
+
+ "UsdImagingNodeGraphAdapter" : {
+ "bases": ["UsdImagingRepresentedByAncestorPrimAdapter"],
+ "isInternal": true,
+ "primTypeName": "NodeGraph"
+ },
+
+ "UsdImagingMaterialBindingAPIAdapter" : {
+ "bases": ["UsdImagingAPISchemaAdapter"],
+ "isInternal": true,
+ "apiSchemaName": "MaterialBindingAPI"
+ },
+ "UsdImagingMeshAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Mesh"
+ },
+ "UsdImagingTetMeshAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "TetMesh"
+ },
+ "UsdImagingNurbsCurvesAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "NurbsCurves"
+ },
+ "UsdImagingNurbsPatchAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "NurbsPatch"
+ },
+ "UsdImagingPlaneAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Plane"
+ },
+ "UsdImagingPointsAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Points"
+ },
+ "UsdImagingPointInstancerAdapter": {
+ "bases": [
+ "UsdImagingInstanceablePrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "PointInstancer"
+ },
+ "UsdImagingSphereAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Sphere"
+ },
+ "UsdImagingRenderSettingsAdapter": {
+ "bases": [
+ "UsdImagingPrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "RenderSettings"
+ },
+ "UsdImagingRenderProductAdapter": {
+ "bases": [
+ "UsdImagingPrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "RenderProduct"
+ },
+ "UsdImagingRenderVarAdapter": {
+ "bases": [
+ "UsdImagingPrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "RenderVar"
+ },
+ "UsdImagingVolumeAdapter": {
+ "bases": [
+ "UsdImagingGprimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "Volume"
+ },
+ "UsdImagingLightAdapter": {
+ "bases": [
+ "UsdImagingInstanceablePrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "LightAPI",
+ "includeDerivedPrimTypes" : true
+ },
+ "UsdImagingLightAPIAdapter": {
+ "bases": [
+ "UsdImagingAPISchemaAdapter"
+ ],
+ "isInternal": true,
+ "apiSchemaName": "LightAPI"
+ },
+ "UsdImagingLightFilterAdapter": {
+ "bases": [
+ "UsdImagingPrimAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "LightFilter",
+ "includeDerivedPrimTypes" : true
+ },
+ "UsdImagingDomeLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "DomeLight"
+ },
+ "UsdImagingDomeLight_1Adapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "DomeLight_1"
+ },
+ "UsdImagingRectLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "RectLight"
+ },
+ "UsdImagingSphereLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "SphereLight"
+ },
+ "UsdImagingCylinderLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "CylinderLight"
+ },
+ "UsdImagingDiskLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "DiskLight"
+ },
+ "UsdImagingDistantLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "DistantLight"
+ },
+ "UsdImagingPluginLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "PluginLight"
+ },
+ "UsdImagingGeometryLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "GeometryLight"
+ },
+ "UsdImagingPortalLightAdapter": {
+ "bases": [
+ "UsdImagingLightAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "PortalLight"
+ },
+ "UsdImagingPluginLightFilterAdapter": {
+ "bases": [
+ "UsdImagingLightFilterAdapter"
+ ],
+ "isInternal": true,
+ "primTypeName": "PluginLightFilter"
+ },
+ "UsdImagingGeomModelAPIAdapter": {
+ "bases": [
+ "UsdImagingAPISchemaAdapter"
+ ],
+ "isInternal": true,
+ "apiSchemaName": "GeomModelAPI"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdImaging",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class "LightAPI" (
+ apiSchemas = ["CollectionAPI:lightLink", "CollectionAPI:shadowLink"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["collection:lightLink:includeRoot", "collection:shadowLink:includeRoot"]
+ }
+ doc = """API schema that imparts the quality of being a light onto a prim.
+
+ A light is any prim that has this schema applied to it. This is true
+ regardless of whether LightAPI is included as a built-in API of the prim
+ type (e.g. RectLight or DistantLight) or is applied directly to a Gprim
+ that should be treated as a light.
+
+ Linking
+
+ Lights can be linked to geometry. Linking controls which geometry
+ a light illuminates, and which geometry casts shadows from the light.
+
+ Linking is specified as collections (UsdCollectionAPI) which can
+ be accessed via GetLightLinkCollection() and GetShadowLinkCollection().
+ Note that these collections have their includeRoot set to true,
+ so that lights will illuminate and cast shadows from all objects
+ by default. To illuminate only a specific set of objects, there
+ are two options. One option is to modify the collection paths
+ to explicitly exclude everything else, assuming it is known;
+ the other option is to set includeRoot to false and explicitly
+ include the desired objects. These are complementary approaches
+ that may each be preferable depending on the scenario and how
+ to best express the intent of the light setup.
+ """
+)
+{
+ uniform bool collection:lightLink:includeRoot = 1
+ uniform bool collection:shadowLink:includeRoot = 1
+ color3f inputs:color = (1, 1, 1) (
+ displayGroup = "Basic"
+ displayName = "Color"
+ doc = "The color of emitted light, in energy-linear terms."
+ )
+ float inputs:colorTemperature = 6500 (
+ displayGroup = "Basic"
+ displayName = "Color Temperature"
+ doc = """Color temperature, in degrees Kelvin, representing the
+ white point. The default is a common white point, D65. Lower
+ values are warmer and higher values are cooler. The valid range
+ is from 1000 to 10000. Only takes effect when
+ enableColorTemperature is set to true. When active, the
+ computed result multiplies against the color attribute.
+ See UsdLuxBlackbodyTemperatureAsRgb()."""
+ )
+ float inputs:diffuse = 1 (
+ displayGroup = "Refine"
+ displayName = "Diffuse Multiplier"
+ doc = """A multiplier for the effect of this light on the diffuse
+ response of materials. This is a non-physical control."""
+ )
+ bool inputs:enableColorTemperature = 0 (
+ displayGroup = "Basic"
+ displayName = "Enable Color Temperature"
+ doc = "Enables using colorTemperature."
+ )
+ float inputs:exposure = 0 (
+ displayGroup = "Basic"
+ displayName = "Exposure"
+ doc = """Scales the power of the light exponentially as a power
+ of 2 (similar to an F-stop control over exposure). The result
+ is multiplied against the intensity."""
+ )
+ float inputs:intensity = 1 (
+ displayGroup = "Basic"
+ displayName = "Intensity"
+ doc = "Scales the power of the light linearly."
+ )
+ bool inputs:normalize = 0 (
+ displayGroup = "Advanced"
+ displayName = "Normalize Power"
+ doc = """Normalizes power by the surface area of the light.
+ This makes it easier to independently adjust the power and shape
+ of the light, by causing the power to not vary with the area or
+ angular size of the light."""
+ )
+ float inputs:specular = 1 (
+ displayGroup = "Refine"
+ displayName = "Specular Multiplier"
+ doc = """A multiplier for the effect of this light on the specular
+ response of materials. This is a non-physical control."""
+ )
+ rel light:filters (
+ doc = "Relationship to the light filters that apply to this light."
+ )
+ uniform token light:materialSyncMode = "noMaterialResponse" (
+ allowedTokens = ["materialGlowTintsLight", "independent", "noMaterialResponse"]
+ displayGroup = "Geometry"
+ displayName = "Material Sync Mode"
+ doc = """For a LightAPI applied to geometry that has a bound Material,
+ which is entirely or partly emissive, this specifies the relationship
+ of the Material response to the lighting response.
+ Valid values are:
+ - materialGlowTintsLight: All primary and secondary rays see the
+ emissive/glow response as dictated by the bound Material while the
+ base color seen by light rays (which is then modulated by all of the
+ other LightAPI controls) is the multiplication of the color feeding
+ the emission/glow input of the Material (i.e. its surface or volume
+ shader) with the scalar or pattern input to *inputs:color*.
+ This allows the light's color to tint the geometry's glow color while
+ preserving access to intensity and other light controls as ways to
+ further modulate the illumination.
+ - independent: All primary and secondary rays see the emissive/glow
+ response as dictated by the bound Material, while the base color seen
+ by light rays is determined solely by *inputs:color*. Note that for
+ partially emissive geometry (in which some parts are reflective
+ rather than emissive), a suitable pattern must be connected to the
+ light's color input, or else the light will radiate uniformly from
+ the geometry.
+ - noMaterialResponse: The geometry behaves as if there is no Material
+ bound at all, i.e. there is no diffuse, specular, or transmissive
+ response. The base color of light rays is entirely controlled by the
+ *inputs:color*. This is the standard mode for \"canonical\" lights in
+ UsdLux and indicates to renderers that a Material will either never
+ be bound or can always be ignored.
+ """
+ )
+ uniform token light:shaderId = "" (
+ displayGroup = "Internal"
+ doc = """Default ID for the light's shader.
+ This defines the shader ID for this light when a render context specific
+ shader ID is not available.
+
+ The default shaderId for the intrinsic UsdLux lights (RectLight,
+ DistantLight, etc.) are set to default to the light's type name. For
+ each intrinsic UsdLux light, we will always register an SdrShaderNode in
+ the SdrRegistry, with the identifier matching the type name and the
+ source type \"USD\", that corresponds to the light's inputs.
+ \\see GetShaderId
+ \\see GetShaderIdAttrForRenderContext
+ \\see SdrRegistry::GetShaderNodeByIdentifier
+ \\see SdrRegistry::GetShaderNodeByIdentifierAndType
+ """
+ )
+}
+
+class "MeshLightAPI" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:materialSyncMode", "light:shaderId"]
+ }
+ doc = '''This is the preferred API schema to apply to
+ "Mesh" type prims when adding light behaviors to a mesh.
+ At its base, this API schema has the built-in behavior of applying LightAPI
+ to the mesh and overriding the default materialSyncMode to allow the
+ emission/glow of the bound material to affect the color of the light.
+ But, it additionally serves as a hook for plugins to attach additional
+ properties to "mesh lights" through the creation of API schemas which are
+ authored to auto-apply to MeshLightAPI.
+ \\see \\ref Usd_AutoAppliedAPISchemas
+ '''
+)
+{
+ uniform token light:materialSyncMode = "materialGlowTintsLight"
+ uniform token light:shaderId = "MeshLight"
+}
+
+class "VolumeLightAPI" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:materialSyncMode", "light:shaderId"]
+ }
+ doc = '''This is the preferred API schema to apply to
+ "Volume" type prims when adding light behaviors to a
+ volume. At its base, this API schema has the built-in behavior of applying
+ LightAPI to the volume and overriding the default materialSyncMode to allow
+ the emission/glow of the bound material to affect the color of the light.
+ But, it additionally serves as a hook for plugins to attach additional
+ properties to "volume lights" through the creation of API schemas which are
+ authored to auto-apply to VolumeLightAPI.
+ \\see \\ref Usd_AutoAppliedAPISchemas
+ '''
+)
+{
+ uniform token light:materialSyncMode = "materialGlowTintsLight"
+ uniform token light:shaderId = "VolumeLight"
+}
+
+class "LightListAPI" (
+ doc = '''API schema to support discovery and publishing of lights in a scene.
+
+ Discovering Lights via Traversal
+
+ To motivate this API, consider what is required to discover all
+ lights in a scene. We must load all payloads and traverse all prims:
+
+ \\code
+ 01 // Load everything on the stage so we can find all lights,
+ 02 // including those inside payloads
+ 03 stage->Load();
+ 04
+ 05 // Traverse all prims, checking if they have an applied UsdLuxLightAPI
+ 06 // (Note: ignoring instancing and a few other things for simplicity)
+ 07 SdfPathVector lights;
+ 08 for (UsdPrim prim: stage->Traverse()) {
+ 09 if (prim.HasAPI()) {
+ 10 lights.push_back(i->GetPath());
+ 11 }
+ 12 }
+ \\endcode
+
+ This traversal -- suitably elaborated to handle certain details --
+ is the first and simplest thing UsdLuxLightListAPI provides.
+ UsdLuxLightListAPI::ComputeLightList() performs this traversal and returns
+ all lights in the scene:
+
+ \\code
+ 01 UsdLuxLightListAPI listAPI(stage->GetPseudoRoot());
+ 02 SdfPathVector lights = listAPI.ComputeLightList();
+ \\endcode
+
+ Publishing a Cached Light List
+
+ Consider a USD client that needs to quickly discover lights but
+ wants to defer loading payloads and traversing the entire scene
+ where possible, and is willing to do up-front computation and
+ caching to achieve that.
+
+ UsdLuxLightListAPI provides a way to cache the computed light list,
+ by publishing the list of lights onto prims in the model
+ hierarchy. Consider a big set that contains lights:
+
+ \\code
+ 01 def Xform "BigSetWithLights" (
+ 02 kind = "assembly"
+ 03 payload = @BigSetWithLights.usd@ // Heavy payload
+ 04 ) {
+ 05 // Pre-computed, cached list of lights inside payload
+ 06 rel lightList = [
+ 07 <./Lights/light_1>,
+ 08 <./Lights/light_2>,
+ 09 ...
+ 10 ]
+ 11 token lightList:cacheBehavior = "consumeAndContinue";
+ 12 }
+ \\endcode
+
+ The lightList relationship encodes a set of lights, and the
+ lightList:cacheBehavior property provides fine-grained
+ control over how to use that cache. (See details below.)
+
+ The cache can be created by first invoking
+ ComputeLightList(ComputeModeIgnoreCache) to pre-compute the list
+ and then storing the result with UsdLuxLightListAPI::StoreLightList().
+
+ To enable efficient retrieval of the cache, it should be stored
+ on a model hierarchy prim. Furthermore, note that while you can
+ use a UsdLuxLightListAPI bound to the pseudo-root prim to query the
+ lights (as in the example above) because it will perform a
+ traversal over descendants, you cannot store the cache back to the
+ pseduo-root prim.
+
+ To consult the cached list, we invoke
+ ComputeLightList(ComputeModeConsultModelHierarchyCache):
+
+ \\code
+ 01 // Find and load all lights, using lightList cache where available
+ 02 UsdLuxLightListAPI list(stage->GetPseudoRoot());
+ 03 SdfPathSet lights = list.ComputeLightList(
+ 04 UsdLuxLightListAPI::ComputeModeConsultModelHierarchyCache);
+ 05 stage.LoadAndUnload(lights, SdfPathSet());
+ \\endcode
+
+ In this mode, ComputeLightList() will traverse the model
+ hierarchy, accumulating cached light lists.
+
+ Controlling Cache Behavior
+
+ The lightList:cacheBehavior property gives additional fine-grained
+ control over cache behavior:
+
+ - The fallback value, "ignore", indicates that the lightList should
+ be disregarded. This provides a way to invalidate cache entries.
+ Note that unless "ignore" is specified, a lightList with an empty
+ list of targets is considered a cache indicating that no lights
+ are present.
+
+ - The value "consumeAndContinue" indicates that the cache should
+ be consulted to contribute lights to the scene, and that recursion
+ should continue down the model hierarchy in case additional lights
+ are added as descedants. This is the default value established when
+ StoreLightList() is invoked. This behavior allows the lights within
+ a large model, such as the BigSetWithLights example above, to be
+ published outside the payload, while also allowing referencing and
+ layering to add additional lights over that set.
+
+ - The value "consumeAndHalt" provides a way to terminate recursive
+ traversal of the scene for light discovery. The cache will be
+ consulted but no descendant prims will be examined.
+
+ Instancing
+
+ Where instances are present, UsdLuxLightListAPI::ComputeLightList() will
+ return the instance-unique paths to any lights discovered within
+ those instances. Lights within a UsdGeomPointInstancer will
+ not be returned, however, since they cannot be referred to
+ solely via paths.
+'''
+)
+{
+ rel lightList (
+ doc = "Relationship to lights in the scene."
+ )
+ token lightList:cacheBehavior (
+ allowedTokens = ["consumeAndHalt", "consumeAndContinue", "ignore"]
+ doc = """Controls how the lightList should be interpreted.
+ Valid values are:
+ - consumeAndHalt: The lightList should be consulted,
+ and if it exists, treated as a final authoritative statement
+ of any lights that exist at or below this prim, halting
+ recursive discovery of lights.
+ - consumeAndContinue: The lightList should be consulted,
+ but recursive traversal over nameChildren should continue
+ in case additional lights are added by descendants.
+ - ignore: The lightList should be entirely ignored. This
+ provides a simple way to temporarily invalidate an existing
+ cache. This is the fallback behavior.
+ """
+ )
+}
+
+class "ListAPI" (
+ doc = """
+ \\deprecated
+ Use LightListAPI instead
+"""
+)
+{
+ rel lightList (
+ doc = "Relationship to lights in the scene."
+ )
+ token lightList:cacheBehavior (
+ allowedTokens = ["consumeAndHalt", "consumeAndContinue", "ignore"]
+ doc = """Controls how the lightList should be interpreted.
+ Valid values are:
+ - consumeAndHalt: The lightList should be consulted,
+ and if it exists, treated as a final authoritative statement
+ of any lights that exist at or below this prim, halting
+ recursive discovery of lights.
+ - consumeAndContinue: The lightList should be consulted,
+ but recursive traversal over nameChildren should continue
+ in case additional lights are added by descendants.
+ - ignore: The lightList should be entirely ignored. This
+ provides a simple way to temporarily invalidate an existing
+ cache. This is the fallback behavior.
+ """
+ )
+}
+
+class "ShapingAPI" (
+ doc = "Controls for shaping a light's emission."
+)
+{
+ float inputs:shaping:cone:angle = 90 (
+ displayGroup = "Shaping"
+ displayName = "Cone Angle"
+ doc = """Angular limit off the primary axis to restrict the
+ light spread."""
+ )
+ float inputs:shaping:cone:softness = 0 (
+ displayGroup = "Shaping"
+ displayName = "Cone Softness"
+ doc = """Controls the cutoff softness for cone angle.
+ TODO: clarify semantics"""
+ )
+ float inputs:shaping:focus = 0 (
+ displayGroup = "Shaping"
+ displayName = "Emission Focus"
+ doc = """A control to shape the spread of light. Higher focus
+ values pull light towards the center and narrow the spread.
+ Implemented as an off-axis cosine power exponent.
+ TODO: clarify semantics"""
+ )
+ color3f inputs:shaping:focusTint = (0, 0, 0) (
+ displayGroup = "Shaping"
+ displayName = "Emission Focus Tint"
+ doc = """Off-axis color tint. This tints the emission in the
+ falloff region. The default tint is black.
+ TODO: clarify semantics"""
+ )
+ float inputs:shaping:ies:angleScale = 0 (
+ displayGroup = "Shaping"
+ displayName = "Profile Scale"
+ doc = """Rescales the angular distribution of the IES profile.
+ TODO: clarify semantics"""
+ )
+ asset inputs:shaping:ies:file (
+ displayGroup = "Shaping"
+ displayName = "IES Profile"
+ doc = """An IES (Illumination Engineering Society) light
+ profile describing the angular distribution of light."""
+ )
+ bool inputs:shaping:ies:normalize = 0 (
+ displayGroup = "Shaping"
+ displayName = "Profile Normalization"
+ doc = """Normalizes the IES profile so that it affects the shaping
+ of the light while preserving the overall energy output."""
+ )
+}
+
+class "ShadowAPI" (
+ doc = """Controls to refine a light's shadow behavior. These are
+ non-physical controls that are valuable for visual lighting work."""
+)
+{
+ color3f inputs:shadow:color = (0, 0, 0) (
+ displayGroup = "Shadows"
+ displayName = "Shadow Color"
+ doc = """The color of shadows cast by the light. This is a
+ non-physical control. The default is to cast black shadows."""
+ )
+ float inputs:shadow:distance = -1 (
+ displayGroup = "Shadows"
+ displayName = "Shadow Max Distance"
+ doc = """The maximum distance shadows are cast. The distance is
+ measured as the distance between the point on the surface and the
+ occluder.
+ The default value (-1) indicates no limit.
+ """
+ )
+ bool inputs:shadow:enable = 1 (
+ displayGroup = "Shadows"
+ displayName = "Enable Shadows"
+ doc = "Enables shadows to be cast by this light."
+ )
+ float inputs:shadow:falloff = -1 (
+ displayGroup = "Shadows"
+ displayName = "Shadow Falloff"
+ doc = """The size of the shadow falloff zone within the shadow max
+ distance, which can be used to hide the hard cut-off for shadows seen
+ stretching past the max distance. The falloff zone is the area that
+ fades from full shadowing at the beginning of the falloff zone to no
+ shadowing at the max distance from the occluder. The falloff zone
+ distance cannot exceed the shadow max distance. A falloff value equal
+ to or less than zero (with -1 as the default) indicates no falloff.
+ """
+ )
+ float inputs:shadow:falloffGamma = 1 (
+ displayGroup = "Shadows"
+ displayName = "Shadow Falloff Gamma"
+ doc = """A gamma (i.e., exponential) control over shadow strength
+ with linear distance within the falloff zone. This controls the rate
+ of the falloff.
+ This requires the use of shadowDistance and shadowFalloff."""
+ )
+}
+
+class LightFilter "LightFilter" (
+ apiSchemas = ["CollectionAPI:filterLink"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["collection:filterLink:includeRoot"]
+ }
+ doc = """A light filter modifies the effect of a light.
+ Lights refer to filters via relationships so that filters may be
+ shared.
+
+ Linking
+
+ Filters can be linked to geometry. Linking controls which geometry
+ a light-filter affects, when considering the light filters attached
+ to a light illuminating the geometry.
+
+ Linking is specified as a collection (UsdCollectionAPI) which can
+ be accessed via GetFilterLinkCollection().
+ """
+)
+{
+ uniform bool collection:filterLink:includeRoot = 1
+ uniform token lightFilter:shaderId = "" (
+ displayGroup = "Internal"
+ doc = """Default ID for the light filter's shader.
+ This defines the shader ID for this light filter when a render context
+ specific shader ID is not available.
+
+ \\see GetShaderId
+ \\see GetShaderIdAttrForRenderContext
+ \\see SdrRegistry::GetShaderNodeByIdentifier
+ \\see SdrRegistry::GetShaderNodeByIdentifierAndType
+ """
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "BoundableLightBase" (
+ apiSchemas = ["LightAPI"]
+ doc = """Base class for intrinsic lights that are boundable.
+
+ The primary purpose of this class is to provide a direct API to the
+ functions provided by LightAPI for concrete derived light types.
+ """
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "NonboundableLightBase" (
+ apiSchemas = ["LightAPI"]
+ doc = """Base class for intrinsic lights that are not boundable.
+
+ The primary purpose of this class is to provide a direct API to the
+ functions provided by LightAPI for concrete derived light types.
+ """
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class DistantLight "DistantLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["inputs:intensity", "light:shaderId"]
+ }
+ doc = """Light emitted from a distant source along the -Z axis.
+ Also known as a directional light."""
+)
+{
+ float inputs:angle = 0.53 (
+ displayGroup = "Basic"
+ displayName = "Angle Extent"
+ doc = """Angular size of the light in degrees.
+ As an example, the Sun is approximately 0.53 degrees as seen from Earth.
+ Higher values broaden the light and therefore soften shadow edges.
+ """
+ )
+ float inputs:intensity = 50000 (
+ doc = """Scales the emission of the light linearly.
+ The DistantLight has a high default intensity to approximate the Sun."""
+ )
+ uniform token light:shaderId = "DistantLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class DiskLight "DiskLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """Light emitted from one side of a circular disk.
+ The disk is centered in the XY plane and emits light along the -Z axis."""
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ float inputs:radius = 0.5 (
+ displayGroup = "Geometry"
+ displayName = "Radius"
+ doc = "Radius of the disk."
+ )
+ uniform token light:shaderId = "DiskLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class RectLight "RectLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """Light emitted from one side of a rectangle.
+ The rectangle is centered in the XY plane and emits light along the -Z axis.
+ The rectangle is 1 unit in length in the X and Y axis. In the default
+ position, a texture file's min coordinates should be at (+X, +Y) and
+ max coordinates at (-X, -Y)."""
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ float inputs:height = 1 (
+ displayGroup = "Geometry"
+ displayName = "Height"
+ doc = "Height of the rectangle, in the local Y axis."
+ )
+ asset inputs:texture:file (
+ displayGroup = "Basic"
+ displayName = "Color Map"
+ doc = "A color texture to use on the rectangle."
+ )
+ float inputs:width = 1 (
+ displayGroup = "Geometry"
+ displayName = "Width"
+ doc = "Width of the rectangle, in the local X axis."
+ )
+ uniform token light:shaderId = "RectLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class SphereLight "SphereLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = "Light emitted outward from a sphere."
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ float inputs:radius = 0.5 (
+ displayGroup = "Geometry"
+ displayName = "Radius"
+ doc = "Radius of the sphere."
+ )
+ uniform token light:shaderId = "SphereLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ bool treatAsPoint = 0 (
+ displayGroup = "Advanced"
+ displayName = "Treat As Point"
+ doc = """A hint that this light can be treated as a 'point'
+ light (effectively, a zero-radius sphere) by renderers that
+ benefit from non-area lighting. Renderers that only support
+ area lights can disregard this."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class CylinderLight "CylinderLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """Light emitted outward from a cylinder.
+ The cylinder is centered at the origin and has its major axis on the X axis.
+ The cylinder does not emit light from the flat end-caps.
+ """
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ float inputs:length = 1 (
+ displayGroup = "Geometry"
+ displayName = "Length"
+ doc = "Length of the cylinder, in the local X axis."
+ )
+ float inputs:radius = 0.5 (
+ displayGroup = "Geometry"
+ displayName = "Radius"
+ doc = "Radius of the cylinder."
+ )
+ uniform token light:shaderId = "CylinderLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ bool treatAsLine = 0 (
+ displayGroup = "Advanced"
+ displayName = "Treat As Line"
+ doc = """A hint that this light can be treated as a 'line'
+ light (effectively, a zero-radius cylinder) by renderers that
+ benefit from non-area lighting. Renderers that only support
+ area lights can disregard this."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class GeometryLight "GeometryLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """\\deprecated
+ Light emitted outward from a geometric prim (UsdGeomGprim),
+ which is typically a mesh."""
+)
+{
+ rel geometry (
+ doc = "Relationship to the geometry to use as the light source."
+ )
+ uniform token light:shaderId = "GeometryLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class DomeLight "DomeLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """Light emitted inward from a distant external environment,
+ such as a sky or IBL light probe.
+
+ In this version of the dome light, the dome's default orientation is such
+ that its top pole is aligned with the world's +Y axis. This adheres to the
+ OpenEXR specification for latlong environment maps. From the OpenEXR
+ documentation:
+
+ -------------------------------------------------------------------------
+ Latitude-Longitude Map:
+
+ The environment is projected onto the image using polar coordinates
+ (latitude and longitude). A pixel's x coordinate corresponds to
+ its longitude, and the y coordinate corresponds to its latitude.
+ Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and
+ longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has
+ latitude -pi/2 and longitude -pi.
+
+ In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
+ positive y direction. Latitude 0, longitude 0 points into positive
+ z direction; and latitude 0, longitude pi/2 points into positive x
+ direction.
+
+ The size of the data window should be 2*N by N pixels (width by height),
+ where N can be any integer greater than 0.
+ -------------------------------------------------------------------------
+"""
+)
+{
+ float guideRadius = 100000 (
+ displayGroup = "Guides"
+ displayName = "Radius"
+ doc = "The radius of guide geometry to use to visualize the dome light. The default is 1 km for scenes whose metersPerUnit is the USD default of 0.01 (i.e., 1 world unit is 1 cm)."
+ )
+ asset inputs:texture:file (
+ displayGroup = "Basic"
+ displayName = "Color Map"
+ doc = """A color texture to use on the dome, such as an HDR (high
+ dynamic range) texture intended for IBL (image based lighting)."""
+ )
+ token inputs:texture:format = "automatic" (
+ allowedTokens = ["automatic", "latlong", "mirroredBall", "angular", "cubeMapVerticalCross"]
+ displayGroup = "Basic"
+ displayName = "Color Map Format"
+ doc = """Specifies the parameterization of the color map file.
+ Valid values are:
+ - automatic: Tries to determine the layout from the file itself.
+ For example, Renderman texture files embed an explicit
+ parameterization.
+ - latlong: Latitude as X, longitude as Y.
+ - mirroredBall: An image of the environment reflected in a
+ sphere, using an implicitly orthogonal projection.
+ - angular: Similar to mirroredBall but the radial dimension
+ is mapped linearly to the angle, providing better sampling
+ at the edges.
+ - cubeMapVerticalCross: A cube map with faces laid out as a
+ vertical cross.
+ """
+ )
+ uniform token light:shaderId = "DomeLight"
+ rel portals (
+ doc = "Optional portals to guide light sampling."
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class DomeLight_1 "DomeLight_1" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """Light emitted inward from a distant external environment,
+ such as a sky or IBL light probe.
+
+ In this version of the dome light, the dome's default orientation is
+ determined by its *poleAxis* property. The fallback value, \"scene\", means
+ that the dome starts with its top pole aligned with the stage's up axis.
+
+ Note that the rotation necessary to align the dome light with its *poleAxis*
+ is intended to be applied by a renderer to only the dome itself, and *not*
+ to inherit down to any USD namespace children of the dome light prim.
+
+ If *poleAxis* is set to \"Y\" or \"scene\" and the stage's up axis is \"Y\", the
+ dome's default orientation will adhere to the OpenEXR specification for
+ latlong environment maps. From the OpenEXR documentation:
+
+ -------------------------------------------------------------------------
+ Latitude-Longitude Map:
+
+ The environment is projected onto the image using polar coordinates
+ (latitude and longitude). A pixel's x coordinate corresponds to
+ its longitude, and the y coordinate corresponds to its latitude.
+ Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and
+ longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has
+ latitude -pi/2 and longitude -pi.
+
+ In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
+ positive y direction. Latitude 0, longitude 0 points into positive
+ z direction; and latitude 0, longitude pi/2 points into positive x
+ direction.
+
+ The size of the data window should be 2*N by N pixels (width by height),
+ where N can be any integer greater than 0.
+ -------------------------------------------------------------------------
+
+ If *poleAxis* is set to \"Z\" or \"scene\" and the stage's up axis is \"Z\",
+ latitudes -pi/2 and +pi/2 will instead correspond to the negative and
+ positive Z direction, and latitude 0, longitude 0 will instead point into
+ the negative Y direction in 3D space.
+"""
+)
+{
+ float guideRadius = 100000 (
+ displayGroup = "Guides"
+ displayName = "Radius"
+ doc = "The radius of guide geometry to use to visualize the dome light. The default is 1 km for scenes whose metersPerUnit is the USD default of 0.01 (i.e., 1 world unit is 1 cm)."
+ )
+ asset inputs:texture:file (
+ displayGroup = "Basic"
+ displayName = "Color Map"
+ doc = """A color texture to use on the dome, such as an HDR (high
+ dynamic range) texture intended for IBL (image based lighting)."""
+ )
+ token inputs:texture:format = "automatic" (
+ allowedTokens = ["automatic", "latlong", "mirroredBall", "angular", "cubeMapVerticalCross"]
+ displayGroup = "Basic"
+ displayName = "Color Map Format"
+ doc = """Specifies the parameterization of the color map file.
+ Valid values are:
+ - automatic: Tries to determine the layout from the file itself.
+ For example, Renderman texture files embed an explicit
+ parameterization.
+ - latlong: Latitude as X, longitude as Y.
+ - mirroredBall: An image of the environment reflected in a
+ sphere, using an implicitly orthogonal projection.
+ - angular: Similar to mirroredBall but the radial dimension
+ is mapped linearly to the angle, providing better sampling
+ at the edges.
+ - cubeMapVerticalCross: A cube map with faces laid out as a
+ vertical cross.
+ """
+ )
+ uniform token light:shaderId = "DomeLight"
+ uniform token poleAxis = "scene" (
+ allowedTokens = ["scene", "Y", "Z"]
+ displayGroup = "Advanced"
+ displayName = "Pole Axis"
+ doc = """A token which indicates the starting alignment of the dome
+ light's top pole. This alignment is for the dome itself and is *not*
+ inherited by the namespace children of the dome.
+ Valid values are:
+ - scene: The dome light's top pole is aligned with the stage's up axis.
+ - Y: The dome light's top pole is aligned with the +Y axis.
+ - Z: The dome light's top pole is aligned with the +Z axis.
+ """
+ )
+ rel portals (
+ doc = "Optional portals to guide light sampling."
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class PortalLight "PortalLight" (
+ apiSchemas = ["LightAPI"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["light:shaderId"]
+ }
+ doc = """A rectangular portal in the local XY plane that guides sampling
+ of a dome light. Transmits light in the -Z direction.
+ The rectangle is 1 unit in length."""
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ float inputs:height = 1 (
+ displayGroup = "Geometry"
+ displayName = "Height"
+ doc = "Height of the portal rectangle in the local Y axis."
+ )
+ float inputs:width = 1 (
+ displayGroup = "Geometry"
+ displayName = "Width"
+ doc = "Width of the portal rectangle in the local X axis."
+ )
+ uniform token light:shaderId = "PortalLight"
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class PluginLight "PluginLight" (
+ apiSchemas = ["NodeDefAPI", "LightAPI"]
+ doc = """Light that provides properties that allow it to identify an
+ external SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be
+ provided to render delegates without the need to provide a schema
+ definition for the light's type.
+
+ \\see \\ref usdLux_PluginSchemas
+"""
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class PluginLightFilter "PluginLightFilter" (
+ apiSchemas = ["NodeDefAPI", "CollectionAPI:filterLink"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["collection:filterLink:includeRoot"]
+ }
+ doc = """Light filter that provides properties that allow it to identify an
+ external SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be
+ provided to render delegates without the need to provide a schema
+ definition for the light filter's type.
+
+ \\see \\ref usdLux_PluginSchemas
+"""
+)
+{
+ uniform bool collection:filterLink:includeRoot = 1
+ uniform token lightFilter:shaderId = "" (
+ displayGroup = "Internal"
+ doc = """Default ID for the light filter's shader.
+ This defines the shader ID for this light filter when a render context
+ specific shader ID is not available.
+
+ \\see GetShaderId
+ \\see GetShaderIdAttrForRenderContext
+ \\see SdrRegistry::GetShaderNodeByIdentifier
+ \\see SdrRegistry::GetShaderNodeByIdentifierAndType
+ """
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "UsdLuxBoundableLightBase": {
+ "alias": {
+ "UsdSchemaBase": "BoundableLightBase"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomBoundable"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdLuxCylinderLight": {
+ "alias": {
+ "UsdSchemaBase": "CylinderLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxBoundableLightBase"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxDiskLight": {
+ "alias": {
+ "UsdSchemaBase": "DiskLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxBoundableLightBase"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxDistantLight": {
+ "alias": {
+ "UsdSchemaBase": "DistantLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxNonboundableLightBase"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxDomeLight": {
+ "alias": {
+ "UsdSchemaBase": "DomeLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxNonboundableLightBase"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxDomeLight_1": {
+ "alias": {
+ "UsdSchemaBase": "DomeLight_1"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxNonboundableLightBase"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxGeometryLight": {
+ "alias": {
+ "UsdSchemaBase": "GeometryLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxNonboundableLightBase"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxLightAPI": {
+ "alias": {
+ "UsdSchemaBase": "LightAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "providesUsdShadeConnectableAPIBehavior": true,
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLuxLightFilter": {
+ "alias": {
+ "UsdSchemaBase": "LightFilter"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "providesUsdShadeConnectableAPIBehavior": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxLightListAPI": {
+ "alias": {
+ "UsdSchemaBase": "LightListAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLuxListAPI": {
+ "alias": {
+ "UsdSchemaBase": "ListAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLuxMeshLightAPI": {
+ "alias": {
+ "UsdSchemaBase": "MeshLightAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLuxNonboundableLightBase": {
+ "alias": {
+ "UsdSchemaBase": "NonboundableLightBase"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdLuxPluginLight": {
+ "alias": {
+ "UsdSchemaBase": "PluginLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxPluginLightFilter": {
+ "alias": {
+ "UsdSchemaBase": "PluginLightFilter"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxLightFilter"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxPortalLight": {
+ "alias": {
+ "UsdSchemaBase": "PortalLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxBoundableLightBase"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxRectLight": {
+ "alias": {
+ "UsdSchemaBase": "RectLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxBoundableLightBase"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxShadowAPI": {
+ "alias": {
+ "UsdSchemaBase": "ShadowAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLuxShapingAPI": {
+ "alias": {
+ "UsdSchemaBase": "ShapingAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLuxSphereLight": {
+ "alias": {
+ "UsdSchemaBase": "SphereLight"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdLuxBoundableLightBase"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdLuxVolumeLightAPI": {
+ "alias": {
+ "UsdSchemaBase": "VolumeLightAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdLux_DiscoveryPlugin": {
+ "bases": [
+ "NdrDiscoveryPlugin"
+ ]
+ },
+ "UsdLux_LightDefParserPlugin": {
+ "bases": [
+ "NdrParserPlugin"
+ ]
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdLux",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ "This file describes the USD Lux light schemata for code generation."
+ subLayers = [
+ @usdGeom/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdLux"
+ string libraryPath = "pxr/usd/usdLux"
+ dictionary libraryTokens = {
+ dictionary lightLink = {
+ string doc = """
+ This token represents the collection name to use
+ with UsdCollectionAPI to represent light-linking
+ of a prim with an applied UsdLuxLightAPI.
+ """
+ }
+ dictionary shadowLink = {
+ string doc = """
+ This token represents the collection name to use
+ with UsdCollectionAPI to represent shadow-linking
+ of a prim with an applied UsdLuxLightAPI.
+ """
+ }
+ dictionary filterLink = {
+ string doc = """
+ This token represents the collection name to use
+ with UsdCollectionAPI to represent filter-linking
+ of a UsdLuxLightFilter prim.
+ """
+ }
+ dictionary orientToStageUpAxis = {
+ string doc = """
+ This token represents the suffix for a UsdGeomXformOp
+ used to orient a light with the stage's up axis.
+ """
+ }
+ }
+ }
+)
+{
+}
+
+class "LightAPI" (
+ inherits =
+ doc = """API schema that imparts the quality of being a light onto a prim.
+
+ A light is any prim that has this schema applied to it. This is true
+ regardless of whether LightAPI is included as a built-in API of the prim
+ type (e.g. RectLight or DistantLight) or is applied directly to a Gprim
+ that should be treated as a light.
+
+ Linking
+
+ Lights can be linked to geometry. Linking controls which geometry
+ a light illuminates, and which geometry casts shadows from the light.
+
+ Linking is specified as collections (UsdCollectionAPI) which can
+ be accessed via GetLightLinkCollection() and GetShadowLinkCollection().
+ Note that these collections have their includeRoot set to true,
+ so that lights will illuminate and cast shadows from all objects
+ by default. To illuminate only a specific set of objects, there
+ are two options. One option is to modify the collection paths
+ to explicitly exclude everything else, assuming it is known;
+ the other option is to set includeRoot to false and explicitly
+ include the desired objects. These are complementary approaches
+ that may each be preferable depending on the scenario and how
+ to best express the intent of the light setup.
+ """
+ customData = {
+ dictionary extraPlugInfo = {
+ bool providesUsdShadeConnectableAPIBehavior = 1
+ }
+ string extraIncludes = """
+#include "pxr/usd/usd/collectionAPI.h"
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h" """
+ }
+ prepend apiSchemas = ["CollectionAPI:lightLink", "CollectionAPI:shadowLink"]
+) {
+ uniform bool collection:lightLink:includeRoot = 1 (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ uniform bool collection:shadowLink:includeRoot = 1 (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ uniform token light:shaderId = "" (
+ displayGroup = "Internal"
+ doc = """Default ID for the light's shader.
+ This defines the shader ID for this light when a render context specific
+ shader ID is not available.
+
+ The default shaderId for the intrinsic UsdLux lights (RectLight,
+ DistantLight, etc.) are set to default to the light's type name. For
+ each intrinsic UsdLux light, we will always register an SdrShaderNode in
+ the SdrRegistry, with the identifier matching the type name and the
+ source type "USD", that corresponds to the light's inputs.
+ \\see GetShaderId
+ \\see GetShaderIdAttrForRenderContext
+ \\see SdrRegistry::GetShaderNodeByIdentifier
+ \\see SdrRegistry::GetShaderNodeByIdentifierAndType
+ """
+ customData = {
+ token apiName = "shaderId"
+ }
+ )
+ uniform token light:materialSyncMode = "noMaterialResponse" (
+ displayGroup = "Geometry"
+ displayName = "Material Sync Mode"
+ doc = """For a LightAPI applied to geometry that has a bound Material,
+ which is entirely or partly emissive, this specifies the relationship
+ of the Material response to the lighting response.
+ Valid values are:
+ - materialGlowTintsLight: All primary and secondary rays see the
+ emissive/glow response as dictated by the bound Material while the
+ base color seen by light rays (which is then modulated by all of the
+ other LightAPI controls) is the multiplication of the color feeding
+ the emission/glow input of the Material (i.e. its surface or volume
+ shader) with the scalar or pattern input to *inputs:color*.
+ This allows the light's color to tint the geometry's glow color while
+ preserving access to intensity and other light controls as ways to
+ further modulate the illumination.
+ - independent: All primary and secondary rays see the emissive/glow
+ response as dictated by the bound Material, while the base color seen
+ by light rays is determined solely by *inputs:color*. Note that for
+ partially emissive geometry (in which some parts are reflective
+ rather than emissive), a suitable pattern must be connected to the
+ light's color input, or else the light will radiate uniformly from
+ the geometry.
+ - noMaterialResponse: The geometry behaves as if there is no Material
+ bound at all, i.e. there is no diffuse, specular, or transmissive
+ response. The base color of light rays is entirely controlled by the
+ *inputs:color*. This is the standard mode for "canonical" lights in
+ UsdLux and indicates to renderers that a Material will either never
+ be bound or can always be ignored.
+ """
+ allowedTokens = ["materialGlowTintsLight",
+ "independent",
+ "noMaterialResponse"]
+ customData = {
+ token apiName = "materialSyncMode"
+ }
+ )
+ float inputs:intensity = 1 (
+ displayGroup = "Basic"
+ displayName = "Intensity"
+ doc = """Scales the power of the light linearly."""
+ customData = {
+ token apiName = "intensity"
+ }
+ )
+ float inputs:exposure = 0 (
+ displayGroup = "Basic"
+ displayName = "Exposure"
+ doc = """Scales the power of the light exponentially as a power
+ of 2 (similar to an F-stop control over exposure). The result
+ is multiplied against the intensity."""
+ customData = {
+ token apiName = "exposure"
+ }
+ )
+ float inputs:diffuse = 1.0 (
+ displayGroup = "Refine"
+ displayName = "Diffuse Multiplier"
+ doc = """A multiplier for the effect of this light on the diffuse
+ response of materials. This is a non-physical control."""
+ customData = {
+ token apiName = "diffuse"
+ }
+ )
+ float inputs:specular = 1.0 (
+ displayGroup = "Refine"
+ displayName = "Specular Multiplier"
+ doc = """A multiplier for the effect of this light on the specular
+ response of materials. This is a non-physical control."""
+ customData = {
+ token apiName = "specular"
+ }
+ )
+ bool inputs:normalize = false (
+ displayGroup = "Advanced"
+ displayName = "Normalize Power"
+ doc = """Normalizes power by the surface area of the light.
+ This makes it easier to independently adjust the power and shape
+ of the light, by causing the power to not vary with the area or
+ angular size of the light."""
+ customData = {
+ token apiName = "normalize"
+ }
+ )
+ color3f inputs:color = (1, 1, 1) (
+ displayGroup = "Basic"
+ displayName = "Color"
+ doc = """The color of emitted light, in energy-linear terms."""
+ customData = {
+ token apiName = "color"
+ }
+ )
+ bool inputs:enableColorTemperature = false (
+ displayGroup = "Basic"
+ displayName = "Enable Color Temperature"
+ doc = """Enables using colorTemperature."""
+ customData = {
+ token apiName = "enableColorTemperature"
+ }
+ )
+ float inputs:colorTemperature = 6500 (
+ displayGroup = "Basic"
+ displayName = "Color Temperature"
+ doc = """Color temperature, in degrees Kelvin, representing the
+ white point. The default is a common white point, D65. Lower
+ values are warmer and higher values are cooler. The valid range
+ is from 1000 to 10000. Only takes effect when
+ enableColorTemperature is set to true. When active, the
+ computed result multiplies against the color attribute.
+ See UsdLuxBlackbodyTemperatureAsRgb()."""
+ customData = {
+ token apiName = "colorTemperature"
+ }
+ )
+ rel light:filters (
+ doc = """Relationship to the light filters that apply to this light."""
+ customData = {
+ token apiName = "filters"
+ }
+ )
+}
+
+class "MeshLightAPI" (
+ inherits =
+ doc = """This is the preferred API schema to apply to
+ \\ref UsdGeomMesh "Mesh" type prims when adding light behaviors to a mesh.
+ At its base, this API schema has the built-in behavior of applying LightAPI
+ to the mesh and overriding the default materialSyncMode to allow the
+ emission/glow of the bound material to affect the color of the light.
+ But, it additionally serves as a hook for plugins to attach additional
+ properties to "mesh lights" through the creation of API schemas which are
+ authored to auto-apply to MeshLightAPI.
+ \\see \\ref Usd_AutoAppliedAPISchemas
+ """
+ prepend apiSchemas = ["LightAPI"]
+) {
+ uniform token light:shaderId = "MeshLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ uniform token light:materialSyncMode = "materialGlowTintsLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+}
+
+class "VolumeLightAPI" (
+ inherits =
+ doc = """This is the preferred API schema to apply to
+ \\ref UsdVolVolume "Volume" type prims when adding light behaviors to a
+ volume. At its base, this API schema has the built-in behavior of applying
+ LightAPI to the volume and overriding the default materialSyncMode to allow
+ the emission/glow of the bound material to affect the color of the light.
+ But, it additionally serves as a hook for plugins to attach additional
+ properties to "volume lights" through the creation of API schemas which are
+ authored to auto-apply to VolumeLightAPI.
+ \\see \\ref Usd_AutoAppliedAPISchemas
+ """
+ prepend apiSchemas = ["LightAPI"]
+) {
+ uniform token light:shaderId = "VolumeLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ uniform token light:materialSyncMode = "materialGlowTintsLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+}
+
+class "LightListAPI" (
+ inherits =
+ doc = """API schema to support discovery and publishing of lights in a scene.
+
+ \\section UsdLuxLightListAPI_Discovery Discovering Lights via Traversal
+
+ To motivate this API, consider what is required to discover all
+ lights in a scene. We must load all payloads and traverse all prims:
+
+ \\code
+ 01 // Load everything on the stage so we can find all lights,
+ 02 // including those inside payloads
+ 03 stage->Load();
+ 04
+ 05 // Traverse all prims, checking if they have an applied UsdLuxLightAPI
+ 06 // (Note: ignoring instancing and a few other things for simplicity)
+ 07 SdfPathVector lights;
+ 08 for (UsdPrim prim: stage->Traverse()) {
+ 09 if (prim.HasAPI()) {
+ 10 lights.push_back(i->GetPath());
+ 11 }
+ 12 }
+ \\endcode
+
+ This traversal -- suitably elaborated to handle certain details --
+ is the first and simplest thing UsdLuxLightListAPI provides.
+ UsdLuxLightListAPI::ComputeLightList() performs this traversal and returns
+ all lights in the scene:
+
+ \\code
+ 01 UsdLuxLightListAPI listAPI(stage->GetPseudoRoot());
+ 02 SdfPathVector lights = listAPI.ComputeLightList();
+ \\endcode
+
+ \\section UsdLuxLightListAPI_LightList Publishing a Cached Light List
+
+ Consider a USD client that needs to quickly discover lights but
+ wants to defer loading payloads and traversing the entire scene
+ where possible, and is willing to do up-front computation and
+ caching to achieve that.
+
+ UsdLuxLightListAPI provides a way to cache the computed light list,
+ by publishing the list of lights onto prims in the model
+ hierarchy. Consider a big set that contains lights:
+
+ \\code
+ 01 def Xform "BigSetWithLights" (
+ 02 kind = "assembly"
+ 03 payload = @BigSetWithLights.usd@ // Heavy payload
+ 04 ) {
+ 05 // Pre-computed, cached list of lights inside payload
+ 06 rel lightList = [
+ 07 <./Lights/light_1>,
+ 08 <./Lights/light_2>,
+ 09 ...
+ 10 ]
+ 11 token lightList:cacheBehavior = "consumeAndContinue";
+ 12 }
+ \\endcode
+
+ The lightList relationship encodes a set of lights, and the
+ lightList:cacheBehavior property provides fine-grained
+ control over how to use that cache. (See details below.)
+
+ The cache can be created by first invoking
+ ComputeLightList(ComputeModeIgnoreCache) to pre-compute the list
+ and then storing the result with UsdLuxLightListAPI::StoreLightList().
+
+ To enable efficient retrieval of the cache, it should be stored
+ on a model hierarchy prim. Furthermore, note that while you can
+ use a UsdLuxLightListAPI bound to the pseudo-root prim to query the
+ lights (as in the example above) because it will perform a
+ traversal over descendants, you cannot store the cache back to the
+ pseduo-root prim.
+
+ To consult the cached list, we invoke
+ ComputeLightList(ComputeModeConsultModelHierarchyCache):
+
+ \\code
+ 01 // Find and load all lights, using lightList cache where available
+ 02 UsdLuxLightListAPI list(stage->GetPseudoRoot());
+ 03 SdfPathSet lights = list.ComputeLightList(
+ 04 UsdLuxLightListAPI::ComputeModeConsultModelHierarchyCache);
+ 05 stage.LoadAndUnload(lights, SdfPathSet());
+ \\endcode
+
+ In this mode, ComputeLightList() will traverse the model
+ hierarchy, accumulating cached light lists.
+
+ \\section UsdLuxLightListAPI_CacheBehavior Controlling Cache Behavior
+
+ The lightList:cacheBehavior property gives additional fine-grained
+ control over cache behavior:
+
+ \\li The fallback value, "ignore", indicates that the lightList should
+ be disregarded. This provides a way to invalidate cache entries.
+ Note that unless "ignore" is specified, a lightList with an empty
+ list of targets is considered a cache indicating that no lights
+ are present.
+
+ \\li The value "consumeAndContinue" indicates that the cache should
+ be consulted to contribute lights to the scene, and that recursion
+ should continue down the model hierarchy in case additional lights
+ are added as descedants. This is the default value established when
+ StoreLightList() is invoked. This behavior allows the lights within
+ a large model, such as the BigSetWithLights example above, to be
+ published outside the payload, while also allowing referencing and
+ layering to add additional lights over that set.
+
+ \\li The value "consumeAndHalt" provides a way to terminate recursive
+ traversal of the scene for light discovery. The cache will be
+ consulted but no descendant prims will be examined.
+
+ \\section UsdLuxLightListAPI_Instancing Instancing
+
+ Where instances are present, UsdLuxLightListAPI::ComputeLightList() will
+ return the instance-unique paths to any lights discovered within
+ those instances. Lights within a UsdGeomPointInstancer will
+ not be returned, however, since they cannot be referred to
+ solely via paths.
+"""
+) {
+ rel lightList (
+ doc = """Relationship to lights in the scene."""
+ )
+ token lightList:cacheBehavior (
+ doc = """Controls how the lightList should be interpreted.
+ Valid values are:
+ - consumeAndHalt: The lightList should be consulted,
+ and if it exists, treated as a final authoritative statement
+ of any lights that exist at or below this prim, halting
+ recursive discovery of lights.
+ - consumeAndContinue: The lightList should be consulted,
+ but recursive traversal over nameChildren should continue
+ in case additional lights are added by descendants.
+ - ignore: The lightList should be entirely ignored. This
+ provides a simple way to temporarily invalidate an existing
+ cache. This is the fallback behavior.
+ """
+ allowedTokens = ["consumeAndHalt", "consumeAndContinue", "ignore"]
+ )
+}
+
+class "ListAPI" (
+ inherits =
+ doc = """
+ \\deprecated
+ Use LightListAPI instead
+"""
+) {
+ rel lightList (
+ doc = """Relationship to lights in the scene."""
+ )
+ token lightList:cacheBehavior (
+ doc = """Controls how the lightList should be interpreted.
+ Valid values are:
+ - consumeAndHalt: The lightList should be consulted,
+ and if it exists, treated as a final authoritative statement
+ of any lights that exist at or below this prim, halting
+ recursive discovery of lights.
+ - consumeAndContinue: The lightList should be consulted,
+ but recursive traversal over nameChildren should continue
+ in case additional lights are added by descendants.
+ - ignore: The lightList should be entirely ignored. This
+ provides a simple way to temporarily invalidate an existing
+ cache. This is the fallback behavior.
+ """
+ allowedTokens = ["consumeAndHalt", "consumeAndContinue", "ignore"]
+ )
+}
+
+class "ShapingAPI" (
+ inherits =
+ doc = """Controls for shaping a light's emission."""
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h" """
+ }
+
+) {
+ float inputs:shaping:focus = 0 (
+ displayGroup = "Shaping"
+ displayName = "Emission Focus"
+ doc = """A control to shape the spread of light. Higher focus
+ values pull light towards the center and narrow the spread.
+ Implemented as an off-axis cosine power exponent.
+ TODO: clarify semantics"""
+ customData = {
+ token apiName = "shaping:focus"
+ }
+ )
+ color3f inputs:shaping:focusTint = (0, 0, 0) (
+ displayGroup = "Shaping"
+ displayName = "Emission Focus Tint"
+ doc = """Off-axis color tint. This tints the emission in the
+ falloff region. The default tint is black.
+ TODO: clarify semantics"""
+ customData = {
+ token apiName = "shaping:focusTint"
+ }
+ )
+ float inputs:shaping:cone:angle = 90 (
+ displayGroup = "Shaping"
+ displayName = "Cone Angle"
+ doc = """Angular limit off the primary axis to restrict the
+ light spread."""
+ customData = {
+ token apiName = "shaping:cone:angle"
+ }
+ )
+ float inputs:shaping:cone:softness = 0 (
+ displayGroup = "Shaping"
+ displayName = "Cone Softness"
+ doc = """Controls the cutoff softness for cone angle.
+ TODO: clarify semantics"""
+ customData = {
+ token apiName = "shaping:cone:softness"
+ }
+ )
+ asset inputs:shaping:ies:file (
+ displayGroup = "Shaping"
+ displayName = "IES Profile"
+ doc = """An IES (Illumination Engineering Society) light
+ profile describing the angular distribution of light."""
+ customData = {
+ token apiName = "shaping:ies:file"
+ }
+ )
+ float inputs:shaping:ies:angleScale = 0 (
+ displayGroup = "Shaping"
+ displayName = "Profile Scale"
+ doc = """Rescales the angular distribution of the IES profile.
+ TODO: clarify semantics"""
+ customData = {
+ token apiName = "shaping:ies:angleScale"
+ }
+ )
+ bool inputs:shaping:ies:normalize = false (
+ displayGroup = "Shaping"
+ displayName = "Profile Normalization"
+ doc = """Normalizes the IES profile so that it affects the shaping
+ of the light while preserving the overall energy output."""
+ customData = {
+ token apiName = "shaping:ies:normalize"
+ }
+ )
+}
+
+class "ShadowAPI" (
+ inherits =
+ doc = """Controls to refine a light's shadow behavior. These are
+ non-physical controls that are valuable for visual lighting work."""
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h" """
+ }
+
+) {
+ bool inputs:shadow:enable = true (
+ displayGroup = "Shadows"
+ displayName = "Enable Shadows"
+ doc = """Enables shadows to be cast by this light."""
+ customData = {
+ token apiName = "shadow:enable"
+ }
+ )
+ color3f inputs:shadow:color = (0, 0, 0) (
+ displayGroup = "Shadows"
+ displayName = "Shadow Color"
+ doc = """The color of shadows cast by the light. This is a
+ non-physical control. The default is to cast black shadows."""
+ customData = {
+ token apiName = "shadow:color"
+ }
+ )
+ float inputs:shadow:distance = -1.0 (
+ displayGroup = "Shadows"
+ displayName = "Shadow Max Distance"
+ doc = """The maximum distance shadows are cast. The distance is
+ measured as the distance between the point on the surface and the
+ occluder.
+ The default value (-1) indicates no limit.
+ """
+ customData = {
+ token apiName = "shadow:distance"
+ }
+ )
+ float inputs:shadow:falloff = -1.0 (
+ displayGroup = "Shadows"
+ displayName = "Shadow Falloff"
+ doc = """The size of the shadow falloff zone within the shadow max
+ distance, which can be used to hide the hard cut-off for shadows seen
+ stretching past the max distance. The falloff zone is the area that
+ fades from full shadowing at the beginning of the falloff zone to no
+ shadowing at the max distance from the occluder. The falloff zone
+ distance cannot exceed the shadow max distance. A falloff value equal
+ to or less than zero (with -1 as the default) indicates no falloff.
+ """
+ customData = {
+ token apiName = "shadow:falloff"
+ }
+ )
+ float inputs:shadow:falloffGamma = 1.0 (
+ displayGroup = "Shadows"
+ displayName = "Shadow Falloff Gamma"
+ doc = """A gamma (i.e., exponential) control over shadow strength
+ with linear distance within the falloff zone. This controls the rate
+ of the falloff.
+ This requires the use of shadowDistance and shadowFalloff."""
+ customData = {
+ token apiName = "shadow:falloffGamma"
+ }
+ )
+}
+
+class LightFilter "LightFilter" (
+ inherits =
+ doc = """A light filter modifies the effect of a light.
+ Lights refer to filters via relationships so that filters may be
+ shared.
+
+ Linking
+
+ Filters can be linked to geometry. Linking controls which geometry
+ a light-filter affects, when considering the light filters attached
+ to a light illuminating the geometry.
+
+ Linking is specified as a collection (UsdCollectionAPI) which can
+ be accessed via GetFilterLinkCollection().
+ """
+ customData = {
+ dictionary extraPlugInfo = {
+ bool providesUsdShadeConnectableAPIBehavior = 1
+ }
+ string extraIncludes = """
+#include "pxr/usd/usd/collectionAPI.h"
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h" """
+ }
+ prepend apiSchemas = ["CollectionAPI:filterLink"]
+) {
+ uniform bool collection:filterLink:includeRoot = 1 (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ uniform token lightFilter:shaderId = "" (
+ displayGroup = "Internal"
+ doc = """Default ID for the light filter's shader.
+ This defines the shader ID for this light filter when a render context
+ specific shader ID is not available.
+
+ \\see GetShaderId
+ \\see GetShaderIdAttrForRenderContext
+ \\see SdrRegistry::GetShaderNodeByIdentifier
+ \\see SdrRegistry::GetShaderNodeByIdentifierAndType
+ """
+ customData = {
+ token apiName = "shaderId"
+ }
+ )
+
+}
+
+class "BoundableLightBase" (
+ inherits =
+ doc = """Base class for intrinsic lights that are boundable.
+
+ The primary purpose of this class is to provide a direct API to the
+ functions provided by LightAPI for concrete derived light types.
+ """
+ customData = {
+ string extraIncludes = """#include "pxr/usd/usdLux/lightAPI.h" """
+ }
+ prepend apiSchemas = ["LightAPI"]
+) {
+}
+
+class "NonboundableLightBase" (
+ inherits =
+ doc = """Base class for intrinsic lights that are not boundable.
+
+ The primary purpose of this class is to provide a direct API to the
+ functions provided by LightAPI for concrete derived light types.
+ """
+ customData = {
+ string extraIncludes = """#include "pxr/usd/usdLux/lightAPI.h" """
+ }
+ prepend apiSchemas = ["LightAPI"]
+) {
+}
+
+class DistantLight "DistantLight" (
+ inherits =
+ doc = """Light emitted from a distant source along the -Z axis.
+ Also known as a directional light."""
+) {
+ uniform token light:shaderId = "DistantLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ float inputs:angle = 0.53 (
+ displayGroup = "Basic"
+ displayName = "Angle Extent"
+ doc = """Angular size of the light in degrees.
+ As an example, the Sun is approximately 0.53 degrees as seen from Earth.
+ Higher values broaden the light and therefore soften shadow edges.
+ """
+ customData = {
+ token apiName = "angle"
+ }
+ )
+ float inputs:intensity = 50000 (
+ doc = """Scales the emission of the light linearly.
+ The DistantLight has a high default intensity to approximate the Sun."""
+ customData = {
+ token apiName = "intensity"
+ bool apiSchemaOverride = true
+ }
+ )
+}
+
+class DiskLight "DiskLight" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = 1
+ }
+ }
+ inherits =
+ doc = """Light emitted from one side of a circular disk.
+ The disk is centered in the XY plane and emits light along the -Z axis."""
+) {
+ uniform token light:shaderId = "DiskLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ float inputs:radius = 0.5 (
+ displayGroup = "Geometry"
+ displayName = "Radius"
+ doc = "Radius of the disk."
+ customData = {
+ token apiName = "radius"
+ }
+ )
+}
+
+class RectLight "RectLight" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = 1
+ }
+ }
+ inherits =
+ doc = """Light emitted from one side of a rectangle.
+ The rectangle is centered in the XY plane and emits light along the -Z axis.
+ The rectangle is 1 unit in length in the X and Y axis. In the default
+ position, a texture file's min coordinates should be at (+X, +Y) and
+ max coordinates at (-X, -Y)."""
+) {
+ uniform token light:shaderId = "RectLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ float inputs:width = 1 (
+ displayGroup = "Geometry"
+ displayName = "Width"
+ doc = "Width of the rectangle, in the local X axis."
+ customData = {
+ token apiName = "width"
+ }
+
+ )
+ float inputs:height = 1 (
+ displayGroup = "Geometry"
+ displayName = "Height"
+ doc = "Height of the rectangle, in the local Y axis."
+ customData = {
+ token apiName = "height"
+ }
+ )
+ asset inputs:texture:file (
+ displayGroup = "Basic"
+ displayName = "Color Map"
+ doc = """A color texture to use on the rectangle."""
+ customData = {
+ token apiName = "textureFile"
+ }
+ )
+}
+
+class SphereLight "SphereLight" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = 1
+ }
+ }
+ inherits =
+ doc = """Light emitted outward from a sphere."""
+) {
+ uniform token light:shaderId = "SphereLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ float inputs:radius = 0.5 (
+ displayGroup = "Geometry"
+ displayName = "Radius"
+ doc = "Radius of the sphere."
+ customData = {
+ token apiName = "radius"
+ }
+ )
+ bool treatAsPoint = false (
+ displayGroup = "Advanced"
+ displayName = "Treat As Point"
+ doc = """A hint that this light can be treated as a 'point'
+ light (effectively, a zero-radius sphere) by renderers that
+ benefit from non-area lighting. Renderers that only support
+ area lights can disregard this."""
+ )
+}
+
+class CylinderLight "CylinderLight" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = 1
+ }
+ }
+ inherits =
+ doc = """Light emitted outward from a cylinder.
+ The cylinder is centered at the origin and has its major axis on the X axis.
+ The cylinder does not emit light from the flat end-caps.
+ """
+) {
+ uniform token light:shaderId = "CylinderLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ float inputs:length = 1 (
+ displayGroup = "Geometry"
+ displayName = "Length"
+ doc = "Length of the cylinder, in the local X axis."
+ customData = {
+ token apiName = "length"
+ }
+ )
+ float inputs:radius = 0.5 (
+ displayGroup = "Geometry"
+ displayName = "Radius"
+ doc = "Radius of the cylinder."
+ customData = {
+ token apiName = "radius"
+ }
+ )
+ bool treatAsLine = false (
+ displayGroup = "Advanced"
+ displayName = "Treat As Line"
+ doc = """A hint that this light can be treated as a 'line'
+ light (effectively, a zero-radius cylinder) by renderers that
+ benefit from non-area lighting. Renderers that only support
+ area lights can disregard this."""
+ )
+}
+
+class GeometryLight "GeometryLight" (
+ inherits =
+ doc = """\\deprecated
+ Light emitted outward from a geometric prim (UsdGeomGprim),
+ which is typically a mesh."""
+) {
+ rel geometry (
+ doc = """Relationship to the geometry to use as the light source."""
+ )
+ uniform token light:shaderId = "GeometryLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+}
+
+class DomeLight "DomeLight" (
+ inherits =
+ doc = """Light emitted inward from a distant external environment,
+ such as a sky or IBL light probe.
+
+ In this version of the dome light, the dome's default orientation is such
+ that its top pole is aligned with the world's +Y axis. This adheres to the
+ OpenEXR specification for latlong environment maps. From the OpenEXR
+ documentation:
+
+ -------------------------------------------------------------------------
+ Latitude-Longitude Map:
+
+ The environment is projected onto the image using polar coordinates
+ (latitude and longitude). A pixel's x coordinate corresponds to
+ its longitude, and the y coordinate corresponds to its latitude.
+ Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and
+ longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has
+ latitude -pi/2 and longitude -pi.
+
+ In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
+ positive y direction. Latitude 0, longitude 0 points into positive
+ z direction; and latitude 0, longitude pi/2 points into positive x
+ direction.
+
+ The size of the data window should be 2*N by N pixels (width by height),
+ where N can be any integer greater than 0.
+ -------------------------------------------------------------------------
+"""
+) {
+ uniform token light:shaderId = "DomeLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ asset inputs:texture:file (
+ displayGroup = "Basic"
+ displayName = "Color Map"
+ doc = """A color texture to use on the dome, such as an HDR (high
+ dynamic range) texture intended for IBL (image based lighting)."""
+ customData = {
+ token apiName = "textureFile"
+ }
+ )
+ token inputs:texture:format = "automatic" (
+ displayGroup = "Basic"
+ displayName = "Color Map Format"
+ allowedTokens = ["automatic", "latlong", "mirroredBall", "angular", "cubeMapVerticalCross"]
+ doc = """Specifies the parameterization of the color map file.
+ Valid values are:
+ - automatic: Tries to determine the layout from the file itself.
+ For example, Renderman texture files embed an explicit
+ parameterization.
+ - latlong: Latitude as X, longitude as Y.
+ - mirroredBall: An image of the environment reflected in a
+ sphere, using an implicitly orthogonal projection.
+ - angular: Similar to mirroredBall but the radial dimension
+ is mapped linearly to the angle, providing better sampling
+ at the edges.
+ - cubeMapVerticalCross: A cube map with faces laid out as a
+ vertical cross.
+ """
+ customData = {
+ token apiName = "textureFormat"
+ }
+ )
+ rel portals (
+ doc = """Optional portals to guide light sampling."""
+ )
+ float guideRadius = 1.0e5 (
+ displayGroup = "Guides"
+ displayName = "Radius"
+ doc = """The radius of guide geometry to use to visualize the dome light. The default is 1 km for scenes whose metersPerUnit is the USD default of 0.01 (i.e., 1 world unit is 1 cm)."""
+ )
+}
+
+class DomeLight_1 "DomeLight_1" (
+ inherits =
+ doc = """Light emitted inward from a distant external environment,
+ such as a sky or IBL light probe.
+
+ In this version of the dome light, the dome's default orientation is
+ determined by its *poleAxis* property. The fallback value, "scene", means
+ that the dome starts with its top pole aligned with the stage's up axis.
+
+ Note that the rotation necessary to align the dome light with its *poleAxis*
+ is intended to be applied by a renderer to only the dome itself, and *not*
+ to inherit down to any USD namespace children of the dome light prim.
+
+ If *poleAxis* is set to "Y" or "scene" and the stage's up axis is "Y", the
+ dome's default orientation will adhere to the OpenEXR specification for
+ latlong environment maps. From the OpenEXR documentation:
+
+ -------------------------------------------------------------------------
+ Latitude-Longitude Map:
+
+ The environment is projected onto the image using polar coordinates
+ (latitude and longitude). A pixel's x coordinate corresponds to
+ its longitude, and the y coordinate corresponds to its latitude.
+ Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and
+ longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has
+ latitude -pi/2 and longitude -pi.
+
+ In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
+ positive y direction. Latitude 0, longitude 0 points into positive
+ z direction; and latitude 0, longitude pi/2 points into positive x
+ direction.
+
+ The size of the data window should be 2*N by N pixels (width by height),
+ where N can be any integer greater than 0.
+ -------------------------------------------------------------------------
+
+ If *poleAxis* is set to "Z" or "scene" and the stage's up axis is "Z",
+ latitudes -pi/2 and +pi/2 will instead correspond to the negative and
+ positive Z direction, and latitude 0, longitude 0 will instead point into
+ the negative Y direction in 3D space.
+"""
+) {
+ uniform token light:shaderId = "DomeLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ asset inputs:texture:file (
+ displayGroup = "Basic"
+ displayName = "Color Map"
+ doc = """A color texture to use on the dome, such as an HDR (high
+ dynamic range) texture intended for IBL (image based lighting)."""
+ customData = {
+ token apiName = "textureFile"
+ }
+ )
+ token inputs:texture:format = "automatic" (
+ displayGroup = "Basic"
+ displayName = "Color Map Format"
+ allowedTokens = ["automatic", "latlong", "mirroredBall", "angular", "cubeMapVerticalCross"]
+ doc = """Specifies the parameterization of the color map file.
+ Valid values are:
+ - automatic: Tries to determine the layout from the file itself.
+ For example, Renderman texture files embed an explicit
+ parameterization.
+ - latlong: Latitude as X, longitude as Y.
+ - mirroredBall: An image of the environment reflected in a
+ sphere, using an implicitly orthogonal projection.
+ - angular: Similar to mirroredBall but the radial dimension
+ is mapped linearly to the angle, providing better sampling
+ at the edges.
+ - cubeMapVerticalCross: A cube map with faces laid out as a
+ vertical cross.
+ """
+ customData = {
+ token apiName = "textureFormat"
+ }
+ )
+ rel portals (
+ doc = """Optional portals to guide light sampling."""
+ )
+ float guideRadius = 1.0e5 (
+ displayGroup = "Guides"
+ displayName = "Radius"
+ doc = """The radius of guide geometry to use to visualize the dome light. The default is 1 km for scenes whose metersPerUnit is the USD default of 0.01 (i.e., 1 world unit is 1 cm)."""
+ )
+ uniform token poleAxis = "scene" (
+ displayGroup = "Advanced"
+ displayName = "Pole Axis"
+ allowedTokens = ["scene", "Y", "Z"]
+ doc = """A token which indicates the starting alignment of the dome
+ light's top pole. This alignment is for the dome itself and is *not*
+ inherited by the namespace children of the dome.
+ Valid values are:
+ - scene: The dome light's top pole is aligned with the stage's up axis.
+ - Y: The dome light's top pole is aligned with the +Y axis.
+ - Z: The dome light's top pole is aligned with the +Z axis.
+ """
+ )
+}
+
+class PortalLight "PortalLight" (
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = 1
+ }
+ }
+ inherits =
+ doc = """A rectangular portal in the local XY plane that guides sampling
+ of a dome light. Transmits light in the -Z direction.
+ The rectangle is 1 unit in length."""
+) {
+ uniform token light:shaderId = "PortalLight" (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+ float inputs:width = 1 (
+ displayGroup = "Geometry"
+ displayName = "Width"
+ doc = "Width of the portal rectangle in the local X axis."
+ customData = {
+ token apiName = "width"
+ }
+
+ )
+ float inputs:height = 1 (
+ displayGroup = "Geometry"
+ displayName = "Height"
+ doc = "Height of the portal rectangle in the local Y axis."
+ customData = {
+ token apiName = "height"
+ }
+ )
+}
+
+class PluginLight "PluginLight" (
+ inherits =
+ doc = """Light that provides properties that allow it to identify an
+ external SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be
+ provided to render delegates without the need to provide a schema
+ definition for the light's type.
+
+ \\see \\ref usdLux_PluginSchemas
+"""
+ prepend apiSchemas = ["NodeDefAPI", "LightAPI"]
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usdShade/nodeDefAPI.h" """
+ }
+) {
+}
+
+class PluginLightFilter "PluginLightFilter" (
+ inherits =
+ doc = """Light filter that provides properties that allow it to identify an
+ external SdrShadingNode definition, through UsdShadeNodeDefAPI, that can be
+ provided to render delegates without the need to provide a schema
+ definition for the light filter's type.
+
+ \\see \\ref usdLux_PluginSchemas
+"""
+ prepend apiSchemas = ["NodeDefAPI"]
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usdShade/nodeDefAPI.h" """
+ }
+) {
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class "RenderSettingsBase" (
+ doc = """Abstract base class that defines render settings that
+ can be specified on either a RenderSettings prim or a RenderProduct
+ prim."""
+)
+{
+ uniform token aspectRatioConformPolicy = "expandAperture" (
+ allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
+ doc = '''Indicates the policy to use to resolve an aspect
+ ratio mismatch between the camera aperture and image settings.
+
+ This policy allows a standard render setting to do something
+ reasonable given varying camera inputs.
+
+ The camera aperture aspect ratio is determined by the
+ aperture atributes on the UsdGeomCamera.
+
+ The image aspect ratio is determined by the resolution and
+ pixelAspectRatio attributes in the render settings.
+
+ - "expandAperture": if necessary, expand the aperture to
+ fit the image, exposing additional scene content
+ - "cropAperture": if necessary, crop the aperture to fit
+ the image, cropping scene content
+ - "adjustApertureWidth": if necessary, adjust aperture width
+ to make its aspect ratio match the image
+ - "adjustApertureHeight": if necessary, adjust aperture height
+ to make its aspect ratio match the image
+ - "adjustPixelAspectRatio": compute pixelAspectRatio to
+ make the image exactly cover the aperture; disregards
+ existing attribute value of pixelAspectRatio
+ '''
+ )
+ rel camera (
+ doc = """The _camera_ relationship specifies the primary
+ camera to use in a render. It must target a UsdGeomCamera."""
+ )
+ uniform float4 dataWindowNDC = (0, 0, 1, 1) (
+ doc = """dataWindowNDC specifies the axis-aligned rectangular
+ region in the adjusted aperture window within which the renderer
+ should produce data.
+
+ It is specified as (xmin, ymin, xmax, ymax) in normalized
+ device coordinates, where the range 0 to 1 corresponds to the
+ aperture. (0,0) corresponds to the bottom-left
+ corner and (1,1) corresponds to the upper-right corner.
+
+ Specifying a window outside the unit square will produce
+ overscan data. Specifying a window that does not cover the unit
+ square will produce a cropped render.
+
+ A pixel is included in the rendered result if the pixel
+ center is contained by the data window. This is consistent
+ with standard rules used by polygon rasterization engines.
+ \\ref UsdRenderRasterization
+
+ The data window is expressed in NDC so that cropping and
+ overscan may be resolution independent. In interactive
+ workflows, incremental cropping and resolution adjustment
+ may be intermixed to isolate and examine parts of the scene.
+ In compositing workflows, overscan may be used to support
+ image post-processing kernels, and reduced-resolution proxy
+ renders may be used for faster iteration.
+
+ The dataWindow:ndc coordinate system references the
+ aperture after any adjustments required by
+ aspectRatioConformPolicy.
+ """
+ )
+ uniform bool disableDepthOfField = 0 (
+ doc = """Disable all depth of field by setting F-stop of the targeted
+ camera to infinity."""
+ )
+ uniform bool disableMotionBlur = 0 (
+ doc = """Disable all motion blur by setting the shutter interval
+ of the targeted camera to [0,0] - that is, take only one sample,
+ namely at the current time code."""
+ )
+ uniform bool instantaneousShutter = 0 (
+ doc = """Deprecated - use disableMotionBlur instead. Override
+ the targeted _camera_'s _shutterClose_ to be equal to the
+ value of its _shutterOpen_, to produce a zero-width shutter
+ interval. This gives us a convenient way to disable motion
+ blur."""
+ )
+ uniform float pixelAspectRatio = 1 (
+ doc = """The aspect ratio (width/height) of image pixels..
+ The default ratio 1.0 indicates square pixels."""
+ )
+ uniform int2 resolution = (2048, 1080) (
+ doc = """The image pixel resolution, corresponding to the
+ camera's screen window."""
+ )
+}
+
+class RenderSettings "RenderSettings" (
+ doc = """A UsdRenderSettings prim specifies global settings for
+ a render process, including an enumeration of the RenderProducts
+ that should result, and the UsdGeomImageable purposes that should
+ be rendered. \\ref UsdRenderHowSettingsAffectRendering"""
+)
+{
+ uniform token aspectRatioConformPolicy = "expandAperture" (
+ allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
+ doc = '''Indicates the policy to use to resolve an aspect
+ ratio mismatch between the camera aperture and image settings.
+
+ This policy allows a standard render setting to do something
+ reasonable given varying camera inputs.
+
+ The camera aperture aspect ratio is determined by the
+ aperture atributes on the UsdGeomCamera.
+
+ The image aspect ratio is determined by the resolution and
+ pixelAspectRatio attributes in the render settings.
+
+ - "expandAperture": if necessary, expand the aperture to
+ fit the image, exposing additional scene content
+ - "cropAperture": if necessary, crop the aperture to fit
+ the image, cropping scene content
+ - "adjustApertureWidth": if necessary, adjust aperture width
+ to make its aspect ratio match the image
+ - "adjustApertureHeight": if necessary, adjust aperture height
+ to make its aspect ratio match the image
+ - "adjustPixelAspectRatio": compute pixelAspectRatio to
+ make the image exactly cover the aperture; disregards
+ existing attribute value of pixelAspectRatio
+ '''
+ )
+ rel camera (
+ doc = """The _camera_ relationship specifies the primary
+ camera to use in a render. It must target a UsdGeomCamera."""
+ )
+ uniform float4 dataWindowNDC = (0, 0, 1, 1) (
+ doc = """dataWindowNDC specifies the axis-aligned rectangular
+ region in the adjusted aperture window within which the renderer
+ should produce data.
+
+ It is specified as (xmin, ymin, xmax, ymax) in normalized
+ device coordinates, where the range 0 to 1 corresponds to the
+ aperture. (0,0) corresponds to the bottom-left
+ corner and (1,1) corresponds to the upper-right corner.
+
+ Specifying a window outside the unit square will produce
+ overscan data. Specifying a window that does not cover the unit
+ square will produce a cropped render.
+
+ A pixel is included in the rendered result if the pixel
+ center is contained by the data window. This is consistent
+ with standard rules used by polygon rasterization engines.
+ \\ref UsdRenderRasterization
+
+ The data window is expressed in NDC so that cropping and
+ overscan may be resolution independent. In interactive
+ workflows, incremental cropping and resolution adjustment
+ may be intermixed to isolate and examine parts of the scene.
+ In compositing workflows, overscan may be used to support
+ image post-processing kernels, and reduced-resolution proxy
+ renders may be used for faster iteration.
+
+ The dataWindow:ndc coordinate system references the
+ aperture after any adjustments required by
+ aspectRatioConformPolicy.
+ """
+ )
+ uniform bool disableDepthOfField = 0 (
+ doc = """Disable all depth of field by setting F-stop of the targeted
+ camera to infinity."""
+ )
+ uniform bool disableMotionBlur = 0 (
+ doc = """Disable all motion blur by setting the shutter interval
+ of the targeted camera to [0,0] - that is, take only one sample,
+ namely at the current time code."""
+ )
+ uniform token[] includedPurposes = ["default", "render"] (
+ doc = """The list of UsdGeomImageable _purpose_ values that
+ should be included in the render. Note this cannot be
+ specified per-RenderProduct because it is a statement of
+ which geometry is present."""
+ )
+ uniform bool instantaneousShutter = 0 (
+ doc = """Deprecated - use disableMotionBlur instead. Override
+ the targeted _camera_'s _shutterClose_ to be equal to the
+ value of its _shutterOpen_, to produce a zero-width shutter
+ interval. This gives us a convenient way to disable motion
+ blur."""
+ )
+ uniform token[] materialBindingPurposes = ["full", ""] (
+ allowedTokens = ["full", "preview", ""]
+ doc = '''Ordered list of material purposes to consider when
+ resolving material bindings in the scene. The empty string
+ indicates the "allPurpose" binding.'''
+ )
+ uniform float pixelAspectRatio = 1 (
+ doc = """The aspect ratio (width/height) of image pixels..
+ The default ratio 1.0 indicates square pixels."""
+ )
+ rel products (
+ doc = """The set of RenderProducts the render should produce.
+ This relationship should target UsdRenderProduct prims.
+ If no _products_ are specified, an application should produce
+ an rgb image according to the RenderSettings configuration,
+ to a default display or image name."""
+ )
+ uniform token renderingColorSpace (
+ doc = """Describes a renderer's working (linear) colorSpace where all
+ the renderer/shader math is expected to happen. When no
+ renderingColorSpace is provided, renderer should use its own default."""
+ )
+ uniform int2 resolution = (2048, 1080) (
+ doc = """The image pixel resolution, corresponding to the
+ camera's screen window."""
+ )
+}
+
+class RenderVar "RenderVar" (
+ doc = """A UsdRenderVar describes a custom data variable for
+ a render to produce. The prim describes the source of the data, which
+ can be a shader output or an LPE (Light Path Expression), and also
+ allows encoding of (generally renderer-specific) parameters that
+ configure the renderer for computing the variable.
+
+ \\note The name of the RenderVar prim drives the name of the data
+ variable that the renderer will produce.
+
+ \\note In the future, UsdRender may standardize RenderVar representation
+ for well-known variables under the sourceType `intrinsic`,
+ such as _r_, _g_, _b_, _a_, _z_, or _id_.
+ """
+)
+{
+ uniform token dataType = "color3f" (
+ doc = "The type of this channel, as a USD attribute type."
+ )
+ uniform string sourceName = "" (
+ doc = """The renderer should look for an output of this name
+ as the computed value for the RenderVar."""
+ )
+ uniform token sourceType = "raw" (
+ allowedTokens = ["raw", "primvar", "lpe", "intrinsic"]
+ doc = '''Indicates the type of the source.
+
+ - "raw": The name should be passed directly to the
+ renderer. This is the default behavior.
+ - "primvar": This source represents the name of a primvar.
+ Some renderers may use this to ensure that the primvar
+ is provided; other renderers may require that a suitable
+ material network be provided, in which case this is simply
+ an advisory setting.
+ - "lpe": Specifies a Light Path Expression in the
+ [OSL Light Path Expressions language](https://github.com/imageworks/OpenShadingLanguage/wiki/OSL-Light-Path-Expressions) as the source for
+ this RenderVar. Some renderers may use extensions to
+ that syntax, which will necessarily be non-portable.
+ - "intrinsic": This setting is currently unimplemented,
+ but represents a future namespace for UsdRender to provide
+ portable baseline RenderVars, such as camera depth, that
+ may have varying implementations for each renderer.
+ '''
+ )
+}
+
+class RenderProduct "RenderProduct" (
+ doc = """A UsdRenderProduct describes an image or other
+ file-like artifact produced by a render. A RenderProduct
+ combines one or more RenderVars into a file or interactive
+ buffer. It also provides all the controls established in
+ UsdRenderSettingsBase as optional overrides to whatever the
+ owning UsdRenderSettings prim dictates.
+
+ Specific renderers may support additional settings, such
+ as a way to configure compression settings, filetype metadata,
+ and so forth. Such settings can be encoded using
+ renderer-specific API schemas applied to the product prim.
+ """
+)
+{
+ uniform token aspectRatioConformPolicy = "expandAperture" (
+ allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
+ doc = '''Indicates the policy to use to resolve an aspect
+ ratio mismatch between the camera aperture and image settings.
+
+ This policy allows a standard render setting to do something
+ reasonable given varying camera inputs.
+
+ The camera aperture aspect ratio is determined by the
+ aperture atributes on the UsdGeomCamera.
+
+ The image aspect ratio is determined by the resolution and
+ pixelAspectRatio attributes in the render settings.
+
+ - "expandAperture": if necessary, expand the aperture to
+ fit the image, exposing additional scene content
+ - "cropAperture": if necessary, crop the aperture to fit
+ the image, cropping scene content
+ - "adjustApertureWidth": if necessary, adjust aperture width
+ to make its aspect ratio match the image
+ - "adjustApertureHeight": if necessary, adjust aperture height
+ to make its aspect ratio match the image
+ - "adjustPixelAspectRatio": compute pixelAspectRatio to
+ make the image exactly cover the aperture; disregards
+ existing attribute value of pixelAspectRatio
+ '''
+ )
+ rel camera (
+ doc = """The _camera_ relationship specifies the primary
+ camera to use in a render. It must target a UsdGeomCamera."""
+ )
+ uniform float4 dataWindowNDC = (0, 0, 1, 1) (
+ doc = """dataWindowNDC specifies the axis-aligned rectangular
+ region in the adjusted aperture window within which the renderer
+ should produce data.
+
+ It is specified as (xmin, ymin, xmax, ymax) in normalized
+ device coordinates, where the range 0 to 1 corresponds to the
+ aperture. (0,0) corresponds to the bottom-left
+ corner and (1,1) corresponds to the upper-right corner.
+
+ Specifying a window outside the unit square will produce
+ overscan data. Specifying a window that does not cover the unit
+ square will produce a cropped render.
+
+ A pixel is included in the rendered result if the pixel
+ center is contained by the data window. This is consistent
+ with standard rules used by polygon rasterization engines.
+ \\ref UsdRenderRasterization
+
+ The data window is expressed in NDC so that cropping and
+ overscan may be resolution independent. In interactive
+ workflows, incremental cropping and resolution adjustment
+ may be intermixed to isolate and examine parts of the scene.
+ In compositing workflows, overscan may be used to support
+ image post-processing kernels, and reduced-resolution proxy
+ renders may be used for faster iteration.
+
+ The dataWindow:ndc coordinate system references the
+ aperture after any adjustments required by
+ aspectRatioConformPolicy.
+ """
+ )
+ uniform bool disableDepthOfField = 0 (
+ doc = """Disable all depth of field by setting F-stop of the targeted
+ camera to infinity."""
+ )
+ uniform bool disableMotionBlur = 0 (
+ doc = """Disable all motion blur by setting the shutter interval
+ of the targeted camera to [0,0] - that is, take only one sample,
+ namely at the current time code."""
+ )
+ uniform bool instantaneousShutter = 0 (
+ doc = """Deprecated - use disableMotionBlur instead. Override
+ the targeted _camera_'s _shutterClose_ to be equal to the
+ value of its _shutterOpen_, to produce a zero-width shutter
+ interval. This gives us a convenient way to disable motion
+ blur."""
+ )
+ rel orderedVars (
+ doc = """Specifies the RenderVars that should be consumed and
+ combined into the final product. If ordering is relevant to the
+ output driver, then the ordering of targets in this relationship
+ provides the order to use."""
+ )
+ uniform float pixelAspectRatio = 1 (
+ doc = """The aspect ratio (width/height) of image pixels..
+ The default ratio 1.0 indicates square pixels."""
+ )
+ token productName = "" (
+ doc = """Specifies the name that the output/display driver
+ should give the product. This is provided as-authored to the
+ driver, whose responsibility it is to situate the product on a
+ filesystem or other storage, in the desired location."""
+ )
+ uniform token productType = "raster" (
+ doc = '''The type of output to produce.
+ The default, "raster", indicates a 2D image.
+
+ \\note In the future, UsdRender may define additional product
+ types.'''
+ )
+ uniform int2 resolution = (2048, 1080) (
+ doc = """The image pixel resolution, corresponding to the
+ camera's screen window."""
+ )
+}
+
+class RenderPass "RenderPass" (
+ apiSchemas = ["CollectionAPI:renderVisibility"]
+ customData = {
+ token[] apiSchemaOverridePropertyNames = ["collection:renderVisibility:includeRoot"]
+ }
+ doc = """A RenderPass prim encapsulates the necessary information
+ to generate multipass renders. It houses properties for generating
+ dependencies and the necessary commands to run to generate renders, as
+ well as visibility controls for the scene. While RenderSettings
+ describes the information needed to generate images from a single
+ invocation of a renderer, RenderPass describes the additional information
+ needed to generate a time varying set of images.
+
+ There are two consumers of RenderPass prims - a runtime executable that
+ generates images from usdRender prims, and pipeline specific code that
+ translates between usdRender prims and the pipeline's resource scheduling
+ software. We'll refer to the latter as 'job submission code'.
+
+ \\anchor usdRender_renderVisibility
+ The objects that are relevant to the render is specified via the
+ renderVisibility collection (UsdCollectionAPI) and can be accessed via
+ GetRenderVisibilityCollectionAPI(). This collection has includeRoot set to
+ true so that all objects participate in the render by default. To render
+ only a specific set of objects, there are two options. One is to modify the
+ collection paths to explicitly exclude objects that don't participate in
+ the render, assuming it is known; the other option is to set includeRoot to
+ false and explicitly include the desired objects. These are complementary
+ approaches that may each be preferable depending on the scenario.
+
+ The name of the prim is used as the pass's name.
+ """
+)
+{
+ uniform bool collection:renderVisibility:includeRoot = 1
+ uniform string[] command (
+ doc = '''The command to run in order to generate
+ renders for this pass. The job submission code can use
+ this to properly send tasks to the job scheduling software
+ that will generate products.
+
+ The command can contain variables that will be substituted
+ appropriately during submission, as seen in the example below
+ with {fileName}.
+
+ For example:
+ command[0] = "prman"
+ command[1] = "-progress"
+ command[2] = "-pixelvariance"
+ command[3] = "-0.15"
+ command[4] = "{fileName}" # the fileName property will be substituted
+ '''
+ )
+ uniform bool denoise:enable = 0 (
+ doc = "When True, this Pass pass should be denoised."
+ )
+ rel denoise:pass (
+ doc = """The The UsdRenderDenoisePass prim from which to
+ source denoise settings.
+ """
+ )
+ uniform asset fileName (
+ doc = """The asset that contains the rendering prims or other
+ information needed to render this pass.
+ """
+ )
+ rel inputPasses (
+ doc = """The set of other Passes that this Pass depends on
+ in order to be constructed properly. For example, a Pass A
+ may generate a texture, which is then used as an input to
+ Pass B.
+
+ By default, usdRender makes some assumptions about the
+ relationship between this prim and the prims listed in inputPasses.
+ Namely, when per-frame tasks are generated from these pass prims,
+ usdRender will assume a one-to-one relationship between tasks
+ that share their frame number. Consider a pass named 'composite'
+ whose _inputPasses_ targets a Pass prim named 'beauty`.
+ By default, each frame for 'composite' will depend on the
+ same frame from 'beauty':
+ beauty.1 -> composite.1
+ beauty.2 -> composite.2
+ etc
+
+ The consumer of this RenderPass graph of inputs will need to resolve
+ the transitive dependencies.
+ """
+ )
+ uniform token passType (
+ doc = """A string used to categorize differently structured
+ or executed types of passes within a customized pipeline.
+
+ For example, when multiple DCC's (e.g. Houdini, Katana, Nuke)
+ each compute and contribute different Products to a final result,
+ it may be clearest and most flexible to create a separate
+ RenderPass for each.
+ """
+ )
+ rel renderSource (
+ doc = """The source prim to render from. If _fileName_ is not present,
+ the source is assumed to be a RenderSettings prim present in the current
+ Usd stage. If fileName is present, the source should be found in the
+ file there. This relationship might target a string attribute on this
+ or another prim that identifies the appropriate object in the external
+ container.
+
+ For example, for a Usd-backed pass, this would point to a RenderSettings
+ prim. Houdini passes would point to a Rop. Nuke passes would point to
+ a write node.
+ """
+ )
+}
+
+class RenderDenoisePass "RenderDenoisePass" (
+ doc = """A RenderDenoisePass generates renders via a denoising process.
+ This may be the same renderer that a pipeline uses for UsdRender,
+ or may be a separate one. Notably, a RenderDenoisePass requires
+ another Pass to be present for it to operate. The denoising process
+ itself is not generative, and requires images inputs to operate.
+
+ As denoising integration varies so widely across pipelines, all
+ implementation details are left to pipeline-specific prims
+ that inherit from RenderDenoisePass.
+ """
+)
+{
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "renderSettingsPrimPath": {
+ "appliesTo": "layers",
+ "default": "",
+ "type": "string"
+ }
+ },
+ "Types": {
+ "UsdRenderDenoisePass": {
+ "alias": {
+ "UsdSchemaBase": "RenderDenoisePass"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdRenderPass": {
+ "alias": {
+ "UsdSchemaBase": "RenderPass"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdRenderProduct": {
+ "alias": {
+ "UsdSchemaBase": "RenderProduct"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdRenderSettingsBase"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdRenderSettings": {
+ "alias": {
+ "UsdSchemaBase": "RenderSettings"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdRenderSettingsBase"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdRenderSettingsBase": {
+ "alias": {
+ "UsdSchemaBase": "RenderSettingsBase"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdRenderVar": {
+ "alias": {
+ "UsdSchemaBase": "RenderVar"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "concreteTyped"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdRender",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ "This file describes the USD Render schemata for code generation."
+ subLayers = [
+ @usd/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdRender"
+ string libraryPath = "pxr/usd/usdRender"
+ dictionary libraryTokens = {
+ dictionary renderSettingsPrimPath = {
+ string doc = """Stage-level metadata that encodes the
+ path to UsdRenderSettingsPrim to use for rendering."""
+ }
+ dictionary renderVisibility = {
+ string doc = """
+ This token represents the collection name to use
+ with UsdCollectionAPI to represent renderVisibility
+ of a RenderPass prim.
+ """
+ }
+ }
+ }
+)
+{
+}
+
+class "RenderSettingsBase" (
+ inherits =
+ doc = """Abstract base class that defines render settings that
+ can be specified on either a RenderSettings prim or a RenderProduct
+ prim."""
+ customData = {
+ string className = "SettingsBase"
+ }
+)
+{
+ rel camera (
+ doc = """The _camera_ relationship specifies the primary
+ camera to use in a render. It must target a UsdGeomCamera."""
+ )
+ uniform int2 resolution = (2048, 1080) (
+ doc = """The image pixel resolution, corresponding to the
+ camera's screen window."""
+ )
+ uniform float pixelAspectRatio = 1.0 (
+ doc = """The aspect ratio (width/height) of image pixels..
+ The default ratio 1.0 indicates square pixels."""
+ )
+ uniform token aspectRatioConformPolicy = "expandAperture" (
+ doc = """Indicates the policy to use to resolve an aspect
+ ratio mismatch between the camera aperture and image settings.
+
+ This policy allows a standard render setting to do something
+ reasonable given varying camera inputs.
+
+ The camera aperture aspect ratio is determined by the
+ aperture atributes on the UsdGeomCamera.
+
+ The image aspect ratio is determined by the resolution and
+ pixelAspectRatio attributes in the render settings.
+
+ - "expandAperture": if necessary, expand the aperture to
+ fit the image, exposing additional scene content
+ - "cropAperture": if necessary, crop the aperture to fit
+ the image, cropping scene content
+ - "adjustApertureWidth": if necessary, adjust aperture width
+ to make its aspect ratio match the image
+ - "adjustApertureHeight": if necessary, adjust aperture height
+ to make its aspect ratio match the image
+ - "adjustPixelAspectRatio": compute pixelAspectRatio to
+ make the image exactly cover the aperture; disregards
+ existing attribute value of pixelAspectRatio
+ """
+ allowedTokens = ["expandAperture", "cropAperture", "adjustApertureWidth", "adjustApertureHeight", "adjustPixelAspectRatio"]
+ )
+ uniform float4 dataWindowNDC = (0.0, 0.0, 1.0, 1.0) (
+ doc = """dataWindowNDC specifies the axis-aligned rectangular
+ region in the adjusted aperture window within which the renderer
+ should produce data.
+
+ It is specified as (xmin, ymin, xmax, ymax) in normalized
+ device coordinates, where the range 0 to 1 corresponds to the
+ aperture. (0,0) corresponds to the bottom-left
+ corner and (1,1) corresponds to the upper-right corner.
+
+ Specifying a window outside the unit square will produce
+ overscan data. Specifying a window that does not cover the unit
+ square will produce a cropped render.
+
+ A pixel is included in the rendered result if the pixel
+ center is contained by the data window. This is consistent
+ with standard rules used by polygon rasterization engines.
+ \\ref UsdRenderRasterization
+
+ The data window is expressed in NDC so that cropping and
+ overscan may be resolution independent. In interactive
+ workflows, incremental cropping and resolution adjustment
+ may be intermixed to isolate and examine parts of the scene.
+ In compositing workflows, overscan may be used to support
+ image post-processing kernels, and reduced-resolution proxy
+ renders may be used for faster iteration.
+
+ The dataWindow:ndc coordinate system references the
+ aperture after any adjustments required by
+ aspectRatioConformPolicy.
+ """
+ )
+ uniform bool instantaneousShutter = false (
+ doc = """Deprecated - use disableMotionBlur instead. Override
+ the targeted _camera_'s _shutterClose_ to be equal to the
+ value of its _shutterOpen_, to produce a zero-width shutter
+ interval. This gives us a convenient way to disable motion
+ blur."""
+ )
+ uniform bool disableMotionBlur = false (
+ doc = """Disable all motion blur by setting the shutter interval
+ of the targeted camera to [0,0] - that is, take only one sample,
+ namely at the current time code."""
+ )
+ uniform bool disableDepthOfField = false (
+ doc = """Disable all depth of field by setting F-stop of the targeted
+ camera to infinity."""
+ )
+}
+
+class RenderSettings "RenderSettings" (
+ inherits =
+ doc = """A UsdRenderSettings prim specifies global settings for
+ a render process, including an enumeration of the RenderProducts
+ that should result, and the UsdGeomImageable purposes that should
+ be rendered. \\ref UsdRenderHowSettingsAffectRendering"""
+ customData = {
+ string className = "Settings"
+ }
+)
+{
+ rel products (
+ doc = """The set of RenderProducts the render should produce.
+ This relationship should target UsdRenderProduct prims.
+ If no _products_ are specified, an application should produce
+ an rgb image according to the RenderSettings configuration,
+ to a default display or image name."""
+ )
+ uniform token[] includedPurposes = ["default", "render"] (
+ doc = """The list of UsdGeomImageable _purpose_ values that
+ should be included in the render. Note this cannot be
+ specified per-RenderProduct because it is a statement of
+ which geometry is present."""
+ )
+ uniform token[] materialBindingPurposes = ["full", ""] (
+ allowedTokens = ["full", "preview", ""]
+ doc = """Ordered list of material purposes to consider when
+ resolving material bindings in the scene. The empty string
+ indicates the "allPurpose" binding."""
+ )
+ uniform token renderingColorSpace (
+ doc = """Describes a renderer's working (linear) colorSpace where all
+ the renderer/shader math is expected to happen. When no
+ renderingColorSpace is provided, renderer should use its own default."""
+ )
+}
+
+class RenderVar "RenderVar" (
+ inherits =
+ doc = """A UsdRenderVar describes a custom data variable for
+ a render to produce. The prim describes the source of the data, which
+ can be a shader output or an LPE (Light Path Expression), and also
+ allows encoding of (generally renderer-specific) parameters that
+ configure the renderer for computing the variable.
+
+ \\note The name of the RenderVar prim drives the name of the data
+ variable that the renderer will produce.
+
+ \\note In the future, UsdRender may standardize RenderVar representation
+ for well-known variables under the sourceType `intrinsic`,
+ such as _r_, _g_, _b_, _a_, _z_, or _id_.
+ """
+ customData = {
+ string className = "Var"
+ }
+) {
+ uniform token dataType = "color3f" (
+ doc = """The type of this channel, as a USD attribute type."""
+ )
+ uniform string sourceName = "" (
+ doc = """The renderer should look for an output of this name
+ as the computed value for the RenderVar."""
+ )
+ uniform token sourceType = "raw" (
+ doc = """Indicates the type of the source.
+
+ - "raw": The name should be passed directly to the
+ renderer. This is the default behavior.
+ - "primvar": This source represents the name of a primvar.
+ Some renderers may use this to ensure that the primvar
+ is provided; other renderers may require that a suitable
+ material network be provided, in which case this is simply
+ an advisory setting.
+ - "lpe": Specifies a Light Path Expression in the
+ [OSL Light Path Expressions language](https://github.com/imageworks/OpenShadingLanguage/wiki/OSL-Light-Path-Expressions) as the source for
+ this RenderVar. Some renderers may use extensions to
+ that syntax, which will necessarily be non-portable.
+ - "intrinsic": This setting is currently unimplemented,
+ but represents a future namespace for UsdRender to provide
+ portable baseline RenderVars, such as camera depth, that
+ may have varying implementations for each renderer.
+ """
+ allowedTokens = ["raw", "primvar", "lpe", "intrinsic"]
+ )
+}
+
+class RenderProduct "RenderProduct" (
+ inherits =
+ doc = """A UsdRenderProduct describes an image or other
+ file-like artifact produced by a render. A RenderProduct
+ combines one or more RenderVars into a file or interactive
+ buffer. It also provides all the controls established in
+ UsdRenderSettingsBase as optional overrides to whatever the
+ owning UsdRenderSettings prim dictates.
+
+ Specific renderers may support additional settings, such
+ as a way to configure compression settings, filetype metadata,
+ and so forth. Such settings can be encoded using
+ renderer-specific API schemas applied to the product prim.
+ """
+ customData = {
+ string className = "Product"
+ dictionary schemaTokens = {
+ dictionary raster = {
+ string doc = """RenderProduct productType value that
+ indicates a 2D raster image of pixels."""
+ }
+ }
+ }
+) {
+ uniform token productType = "raster" (
+ doc = """The type of output to produce.
+ The default, "raster", indicates a 2D image.
+
+ \\note In the future, UsdRender may define additional product
+ types."""
+ )
+ token productName = "" (
+ doc = """Specifies the name that the output/display driver
+ should give the product. This is provided as-authored to the
+ driver, whose responsibility it is to situate the product on a
+ filesystem or other storage, in the desired location."""
+ )
+ rel orderedVars (
+ doc = """Specifies the RenderVars that should be consumed and
+ combined into the final product. If ordering is relevant to the
+ output driver, then the ordering of targets in this relationship
+ provides the order to use."""
+ )
+}
+
+
+class RenderPass "RenderPass" (
+ inherits =
+ doc = """A RenderPass prim encapsulates the necessary information
+ to generate multipass renders. It houses properties for generating
+ dependencies and the necessary commands to run to generate renders, as
+ well as visibility controls for the scene. While RenderSettings
+ describes the information needed to generate images from a single
+ invocation of a renderer, RenderPass describes the additional information
+ needed to generate a time varying set of images.
+
+ There are two consumers of RenderPass prims - a runtime executable that
+ generates images from usdRender prims, and pipeline specific code that
+ translates between usdRender prims and the pipeline's resource scheduling
+ software. We'll refer to the latter as 'job submission code'.
+
+ \\anchor usdRender_renderVisibility
+ The objects that are relevant to the render is specified via the
+ renderVisibility collection (UsdCollectionAPI) and can be accessed via
+ GetRenderVisibilityCollectionAPI(). This collection has includeRoot set to
+ true so that all objects participate in the render by default. To render
+ only a specific set of objects, there are two options. One is to modify the
+ collection paths to explicitly exclude objects that don't participate in
+ the render, assuming it is known; the other option is to set includeRoot to
+ false and explicitly include the desired objects. These are complementary
+ approaches that may each be preferable depending on the scenario.
+
+ The name of the prim is used as the pass's name.
+ """
+ customData = {
+ string className = "Pass"
+ string extraIncludes = """
+#include "pxr/usd/usd/collectionAPI.h" """
+ }
+ prepend apiSchemas = ["CollectionAPI:renderVisibility"]
+) {
+ uniform token passType (
+ doc = """A string used to categorize differently structured
+ or executed types of passes within a customized pipeline.
+
+ For example, when multiple DCC's (e.g. Houdini, Katana, Nuke)
+ each compute and contribute different Products to a final result,
+ it may be clearest and most flexible to create a separate
+ RenderPass for each.
+ """
+ )
+
+ uniform string[] command (
+ doc = """The command to run in order to generate
+ renders for this pass. The job submission code can use
+ this to properly send tasks to the job scheduling software
+ that will generate products.
+
+ The command can contain variables that will be substituted
+ appropriately during submission, as seen in the example below
+ with {fileName}.
+
+ For example:
+ command[0] = "prman"
+ command[1] = "-progress"
+ command[2] = "-pixelvariance"
+ command[3] = "-0.15"
+ command[4] = "{fileName}" # the fileName property will be substituted
+ """
+ )
+
+ rel renderSource (
+ doc = """The source prim to render from. If _fileName_ is not present,
+ the source is assumed to be a RenderSettings prim present in the current
+ Usd stage. If fileName is present, the source should be found in the
+ file there. This relationship might target a string attribute on this
+ or another prim that identifies the appropriate object in the external
+ container.
+
+ For example, for a Usd-backed pass, this would point to a RenderSettings
+ prim. Houdini passes would point to a Rop. Nuke passes would point to
+ a write node.
+ """
+ )
+
+ rel inputPasses (
+ doc = """The set of other Passes that this Pass depends on
+ in order to be constructed properly. For example, a Pass A
+ may generate a texture, which is then used as an input to
+ Pass B.
+
+ By default, usdRender makes some assumptions about the
+ relationship between this prim and the prims listed in inputPasses.
+ Namely, when per-frame tasks are generated from these pass prims,
+ usdRender will assume a one-to-one relationship between tasks
+ that share their frame number. Consider a pass named 'composite'
+ whose _inputPasses_ targets a Pass prim named 'beauty`.
+ By default, each frame for 'composite' will depend on the
+ same frame from 'beauty':
+ beauty.1 -> composite.1
+ beauty.2 -> composite.2
+ etc
+
+ The consumer of this RenderPass graph of inputs will need to resolve
+ the transitive dependencies.
+ """
+ )
+
+ uniform asset fileName (
+ doc = """The asset that contains the rendering prims or other
+ information needed to render this pass.
+ """
+ )
+
+ uniform bool denoise:enable = false (
+ doc = """When True, this Pass pass should be denoised."""
+ )
+
+ rel denoise:pass (
+ doc = """The The UsdRenderDenoisePass prim from which to
+ source denoise settings.
+ """
+ )
+
+ uniform bool collection:renderVisibility:includeRoot = 1 (
+ customData = {
+ bool apiSchemaOverride = true
+ }
+ )
+}
+
+
+class RenderDenoisePass "RenderDenoisePass" (
+ inherits =
+ doc = """A RenderDenoisePass generates renders via a denoising process.
+ This may be the same renderer that a pipeline uses for UsdRender,
+ or may be a separate one. Notably, a RenderDenoisePass requires
+ another Pass to be present for it to operate. The denoising process
+ itself is not generative, and requires images inputs to operate.
+
+ As denoising integration varies so widely across pipelines, all
+ implementation details are left to pipeline-specific prims
+ that inherit from RenderDenoisePass.
+ """
+ customData = {
+ string className = "DenoisePass"
+ }
+) {
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class NodeGraph "NodeGraph" (
+ doc = '''A node-graph is a container for shading nodes, as well as other
+ node-graphs. It has a public input interface and provides a list of public
+ outputs.
+
+ Node Graph Interfaces
+
+ One of the most important functions of a node-graph is to host the "interface"
+ with which clients of already-built shading networks will interact. Please
+ see "Interface Inputs" for a detailed
+ explanation of what the interface provides, and how to construct and
+ use it, to effectively share/instance shader networks.
+
+ Node Graph Outputs
+
+ These behave like outputs on a shader and are typically connected to an
+ output on a shader inside the node-graph.
+ '''
+)
+{
+}
+
+class Material "Material" (
+ doc = """A Material provides a container into which multiple \"render contexts\"
+ can add data that defines a \"shading material\" for a renderer. Typically
+ this consists of one or more UsdShadeOutput properties connected to outputs
+ of nested Shader prims - though a context/client is free to add
+ any data that is suitable. We strongly advise that all contexts
+ adopt the convention that all properties be prefixed with a namespace
+ that identifies the context e.g. \"token outputs:ri:surface.connect =
+ resolved Material that will be used to shade the gprim (exceptions,
+ of course, for gprims that possess UsdGeomSubsets, as each subset can be
+ shaded by a different Material). A gprim and each of its ancestor
+ prims can possess, through the MaterialBindingAPI, both a
+ direct binding to a Material, and any number of
+ collection-based bindings to Materials; each binding can be generic
+ or declared for a particular purpose, and given a specific binding
+ strength. It is the process of \"material resolution\" (see
+ that examines all of
+ these bindings, and selects the one Material that best matches the
+ client's needs.
+
+ The intent of purpose is that each gprim should be able to resolve a
+ Material for any given purpose, which implies it can have differently bound
+ materials for different purposes. There are two special values of
+ purpose defined in UsdShade, although the API fully supports
+ specifying arbitrary values for it, for the sake of extensibility:
+
UsdShadeTokens->full: to be used when the purpose of the
+ render is entirely to visualize the truest representation of a scene,
+ considering all lighting and material information, at highest fidelity.
+
UsdShadeTokens->preview: to be used when the render is in
+ service of a goal other than a high fidelity \"full\" render (such as scene
+ manipulation, modeling, or realtime playback). Latency and speed are
+ generally of greater concern for preview renders, therefore preview
+ materials are generally designed to be \"lighterweight\" compared to full
+ materials.
+ A binding can also have no specific purpose at all, in which
+ case, it is considered to be the fallback or all-purpose binding (denoted
+ by the empty-valued token UsdShadeTokens->allPurpose).
+
+ The purpose of a material binding is encoded in the name of the
+ binding relationship.
+
+ In the case of a direct binding, the allPurpose binding is
+ represented by the relationship named material:binding.
+ Special-purpose direct bindings are represented by relationships named
+ material:binding:purpose. A direct binding relationship
+ must have a single target path that points to a UsdShadeMaterial.
+
+ In the case of a collection-based binding, the allPurpose binding is
+ represented by a relationship named
+ material:binding:collection:bindingName, where
+ bindingName establishes an identity for the binding that is unique
+ on the prim. Attempting to establish two collection bindings of the same
+ name on the same prim will result in the first binding simply being
+ overridden. A special-purpose collection-based binding is represented by a
+ relationship named material:binding:collection:purpose:bindingName.
+ A collection-based binding relationship must have exacly two targets, one of
+ which should be a collection-path (see
+ and the other should point to a
+ UsdShadeMaterial. In the future, we may allow a single collection
+ binding to target multiple collections, if we can establish a reasonable
+ round-tripping pattern for applications that only allow a single collection
+ to be associated with each Material.
+
+
+
+ Note: Both bindingName and purpose must be
+ non-namespaced tokens. This allows us to know the role of a binding
+ relationship simply from the number of tokens in it.
+
Two tokens: the fallback, \"all purpose\", direct binding,
+ material:binding
+
Three tokens: a purpose-restricted, direct, fallback binding,
+ e.g. material:binding:preview
+
Four tokens: an all-purpose, collection-based binding, e.g.
+ material:binding:collection:metalBits
+
Five tokens: a purpose-restricted, collection-based binding,
+ e.g. material:binding:collection:full:metalBits
+
+
+ A binding-strength value is used to specify whether a binding
+ authored on a prim should be weaker or stronger than bindings that appear
+ lower in namespace. We encode the binding strength with as token-valued
+ metadata 'bindMaterialAs' for future flexibility, even though for
+ now, there are only two possible values:
+ UsdShadeTokens->weakerThanDescendants and
+ UsdShadeTokens->strongerThanDescendants. When binding-strength is
+ not authored (i.e. empty) on a binding-relationship, the default behavior
+ matches UsdShadeTokens->weakerThanDescendants.
+
+ \\note If a material binding relationship is a built-in property defined as
+ part of a typed prim's schema, a fallback value should not be provided for
+ it. This is because the \"material resolution\" algorithm only conisders
+ authored properties.
+ """
+)
+{
+}
+
+class "CoordSysAPI" (
+ doc = '''UsdShadeCoordSysAPI provides a way to designate, name,
+ and discover coordinate systems.
+
+ Coordinate systems are implicitly established by UsdGeomXformable
+ prims, using their local space. That coordinate system may be
+ bound (i.e., named) from another prim. The binding is encoded
+ as a single-target relationship.
+ Coordinate system bindings apply to descendants of the prim
+ where the binding is expressed, but names may be re-bound by
+ descendant prims.
+
+ CoordSysAPI is a multi-apply API schema, where instance names
+ signify the named coordinate systems. The instance names are
+ used with the "coordSys:" namespace to determine the binding
+ to the UsdGeomXformable prim.
+
+ Named coordinate systems are useful in shading (and other) workflows.
+ An example is projection paint, which projects a texture
+ from a certain view (the paint coordinate system), encoded as
+ (e.g.) "rel coordSys:paint:binding". Using the paint coordinate frame
+ avoids the need to assign a UV set to the object, and can be a
+ concise way to project paint across a collection of objects with
+ a single shared paint coordinate system.
+ '''
+)
+{
+ rel coordSys:__INSTANCE_NAME__:binding (
+ displayName = "Bound Coordinate System"
+ doc = "Prim binding expressing the appropriate coordinate systems."
+ )
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "bindMaterialAs": {
+ "appliesTo": [
+ "relationships"
+ ],
+ "displayGroup": "Shading",
+ "documentation": "Metadata authored on collection-based material binding relationship to indicate the strength of the binding relative to bindings authored on descendant prims.",
+ "type": "token"
+ },
+ "connectability": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": "full",
+ "displayGroup": "Shading",
+ "documentation": "Metadata authored on UsdShadeInput's to specify what they can be connected to. Can be either \"full\" or \"interfaceOnly\". \"full\" implies that the input can be connected to any other input or output. \"interfaceOnly\" implies that the input can only connect to a NodeGraph Input (which represents an interface override, not a render-time dataflow connection), or another Input whose connectability is also \"interfaceOnly\".",
+ "type": "token"
+ },
+ "outputName": {
+ "appliesTo": [
+ "relationships"
+ ],
+ "displayGroup": "deprecated",
+ "type": "token"
+ },
+ "renderType": {
+ "appliesTo": [
+ "properties"
+ ],
+ "displayGroup": "Rendering",
+ "type": "token"
+ },
+ "sdrMetadata": {
+ "appliesTo": [
+ "prims",
+ "attributes"
+ ],
+ "displayGroup": "Shading",
+ "type": "dictionary"
+ }
+ },
+ "Types": {
+ "UsdShadeConnectableAPI": {
+ "alias": {
+ "UsdSchemaBase": "ConnectableAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "nonAppliedAPI"
+ },
+ "UsdShadeCoordSysAPI": {
+ "alias": {
+ "UsdSchemaBase": "CoordSysAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "multipleApplyAPI"
+ },
+ "UsdShadeMaterial": {
+ "alias": {
+ "UsdSchemaBase": "Material"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdShadeNodeGraph"
+ ],
+ "providesUsdShadeConnectableAPIBehavior": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdShadeMaterialBindingAPI": {
+ "alias": {
+ "UsdSchemaBase": "MaterialBindingAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdShadeNodeDefAPI": {
+ "alias": {
+ "UsdSchemaBase": "NodeDefAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdShadeNodeGraph": {
+ "alias": {
+ "UsdSchemaBase": "NodeGraph"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "providesUsdShadeConnectableAPIBehavior": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdShadeShader": {
+ "alias": {
+ "UsdSchemaBase": "Shader"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "providesUsdShadeConnectableAPIBehavior": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdShadeShaderDefParserPlugin": {
+ "bases": [
+ "NdrParserPlugin"
+ ],
+ "displayName": "USD-based shader definition parser plugin"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdShade",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ "This file describes the USD Shader schemata for code generation."
+ subLayers = [
+ @usd/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdShade"
+ string libraryPath = "pxr/usd/usdShade"
+ dictionary libraryTokens = {
+ dictionary materialBind = {
+ string doc = """The name of the GeomSubset family used to
+ identify face subsets defined for the purpose of binding
+ materials to facesets.
+ """
+ }
+ dictionary full = {
+ string doc= """Possible value for 'connectability' metadata on
+ a UsdShadeInput. When connectability of an input is set to
+ "full", it implies that it can be connected to any input or
+ output.
+ """
+ }
+ dictionary interfaceOnly = {
+ string doc= """Possible value for 'connectability' metadata on
+ a UsdShadeInput. It implies that the input can only connect to
+ a NodeGraph Input (which represents an interface override, not
+ a render-time dataflow connection), or another Input whose
+ connectability is also 'interfaceOnly'.
+ """
+ }
+ dictionary outputs = {
+ string value = "outputs:"
+ string doc = """The prefix on shading attributes
+ denoting an output.
+ """
+ }
+ dictionary inputs = {
+ string value = "inputs:"
+ string doc = """The prefix on shading attributes
+ denoting an input.
+ """
+ }
+ }
+ }
+)
+{
+}
+
+class NodeGraph "NodeGraph" (
+ inherits =
+ doc = """A node-graph is a container for shading nodes, as well as other
+ node-graphs. It has a public input interface and provides a list of public
+ outputs.
+
+ Node Graph Interfaces
+
+ One of the most important functions of a node-graph is to host the "interface"
+ with which clients of already-built shading networks will interact. Please
+ see \\ref UsdShadeNodeGraph_Interfaces "Interface Inputs" for a detailed
+ explanation of what the interface provides, and how to construct and
+ use it, to effectively share/instance shader networks.
+
+ Node Graph Outputs
+
+ These behave like outputs on a shader and are typically connected to an
+ output on a shader inside the node-graph.
+ """
+ customData = {
+ dictionary extraPlugInfo = {
+ bool providesUsdShadeConnectableAPIBehavior = 1
+ }
+ string extraIncludes = '''
+#include
+#include "pxr/usd/usd/editTarget.h"
+#include "pxr/usd/usd/relationship.h"
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h"
+#include "pxr/usd/usdShade/shader.h"
+#include "pxr/usd/usdShade/connectableAPIBehavior.h"'''
+ }
+) {
+
+}
+
+
+class Material "Material" (
+ inherits =
+ doc = """A Material provides a container into which multiple "render contexts"
+ can add data that defines a "shading material" for a renderer. Typically
+ this consists of one or more UsdShadeOutput properties connected to outputs
+ of nested Shader prims - though a context/client is free to add
+ any data that is suitable. We strongly advise that all contexts
+ adopt the convention that all properties be prefixed with a namespace
+ that identifies the context e.g. "token outputs:ri:surface.connect =
+ surface output
+ terminal on a UsdShadeMaterial. It is used to define the
+ terminal UsdShadeShader describing the surface of a
+ UsdShadeMaterial.
+ """
+ }
+ dictionary displacement = {
+ string doc = """Describes the displacement output
+ terminal on a UsdShadeMaterial. It is used to define the
+ terminal UsdShadeShader describing the displacement of a
+ UsdShadeMaterial.
+ """
+ }
+ dictionary volume = {
+ string doc = """Describes the volume output
+ terminal on a UsdShadeMaterial. It is used to define the
+ terminal UsdShadeShader describing the volume of a
+ UsdShadeMaterial.
+ """
+ }
+ dictionary universalRenderContext = {
+ string value = ""
+ string doc = """Possible value for the "renderContext" parameter
+ in \\ref UsdShadeMaterial_Outputs API. Represents the universal
+ renderContext. An output with a universal renderContext is
+ applicable to all possible rendering contexts.
+ """
+ }
+ }
+ }
+)
+{
+ token outputs:surface (
+ doc = """Represents the universal "surface" output terminal of a
+ material."""
+ displayGroup = "Outputs"
+ customData = {
+ string apiName = "surface"
+ }
+ )
+ token outputs:displacement (
+ doc = """Represents the universal "displacement" output terminal of a
+ material."""
+ displayGroup = "Outputs"
+ customData = {
+ string apiName = "displacement"
+ }
+ )
+ token outputs:volume (
+ doc = """Represents the universal "volume" output terminal of a
+ material."""
+ displayGroup = "Outputs"
+ customData = {
+ string apiName = "volume"
+ }
+ )
+}
+
+class Shader "Shader" (
+ inherits =
+ prepend apiSchemas = ["NodeDefAPI"]
+ doc = """Base class for all USD shaders. Shaders are the building blocks
+ of shading networks. While UsdShadeShader objects are not target specific,
+ each renderer or application target may derive its own renderer-specific
+ shader object types from this base, if needed.
+
+ Objects of this class generally represent a single shading object, whether
+ it exists in the target renderer or not. For example, a texture, a fractal,
+ or a mix node.
+
+ The UsdShadeNodeDefAPI provides attributes to uniquely identify the
+ type of this node. The id resolution into a renderable shader target
+ type of this node. The id resolution into a renderable shader target
+ is deferred to the consuming application.
+
+ The purpose of representing them in Usd is two-fold:
+ \\li To represent, via "connections" the topology of the shading network
+ that must be reconstructed in the renderer. Facilities for authoring and
+ manipulating connections are encapsulated in the API schema
+ UsdShadeConnectableAPI.
+ \\li To present a (partial or full) interface of typed input parameters
+ whose values can be set and overridden in Usd, to be provided later at
+ render-time as parameter values to the actual render shader objects. Shader
+ input parameters are encapsulated in the property schema UsdShadeInput.
+ """
+ customData = {
+ dictionary extraPlugInfo = {
+ bool providesUsdShadeConnectableAPIBehavior = 1
+ }
+ string extraIncludes = '''
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h"
+#include "pxr/usd/usdShade/tokens.h"
+#include "pxr/usd/ndr/declare.h"
+#include "pxr/usd/sdr/shaderNode.h"'''
+ }
+) {
+}
+
+class "NodeDefAPI"
+(
+ inherits =
+ doc = """UsdShadeNodeDefAPI is an API schema that provides attributes
+ for a prim to select a corresponding Shader Node Definition ("Sdr Node"),
+ as well as to look up a runtime entry for that shader node in the
+ form of an SdrShaderNode.
+
+ UsdShadeNodeDefAPI is intended to be a pre-applied API schema for any
+ prim type that wants to refer to the SdrRegistry for further implementation
+ details about the behavior of that prim. The primary use in UsdShade
+ itself is as UsdShadeShader, which is a basis for material shading networks
+ (UsdShadeMaterial), but this is intended to be used in other domains
+ that also use the Sdr node mechanism.
+
+ This schema provides properties that allow a prim to identify an external
+ node definition, either by a direct identifier key into the SdrRegistry
+ (info:id), an asset to be parsed by a suitable NdrParserPlugin
+ (info:sourceAsset), or an inline source code that must also be parsed
+ (info:sourceCode); as well as a selector attribute to determine which
+ specifier is active (info:implementationSource).
+ """
+ customData = {
+ token apiSchemaType = "singleApply"
+ string extraIncludes = """
+#include "pxr/usd/ndr/declare.h"
+#include "pxr/usd/sdr/shaderNode.h"
+ """
+ dictionary schemaTokens = {
+ dictionary universalSourceType = {
+ string value = ""
+ string doc = """Possible value for the "sourceType" parameter
+ in \\ref UsdShadeNodeDefAPI_ImplementationSource API. Represents
+ the universal or fallback source type.
+ """
+ }
+ dictionary sdrMetadata = {
+ string doc = """Dictionary valued metadata key authored on
+ Shader prims with implementationSource value of sourceAsset or
+ sourceCode to pass along metadata to the shader parser or
+ compiler. It is also used to author metadata on shader
+ properties in a UsdShade-based shader definition file.
+ """
+ }
+ dictionary subIdentifier = {
+ string doc = """This identifier is used in conjunction with a
+ specific source asset to indicate a particular definition within
+ the source asset, if the source asset specifies more than one
+ shader node definition.
+ """
+ }
+ }
+ }
+)
+{
+ uniform token info:implementationSource = "id" (
+ allowedTokens = ["id", "sourceAsset", "sourceCode"]
+ doc = """Specifies the attribute that should be consulted to get the
+ shader's implementation or its source code.
+
+ * If set to "id", the "info:id" attribute's value is used to
+ determine the shader source from the shader registry.
+ * If set to "sourceAsset", the resolved value of the "info:sourceAsset"
+ attribute corresponding to the desired implementation (or source-type)
+ is used to locate the shader source. A source asset file may also
+ specify multiple shader definitions, so there is an optional attribute
+ "info:sourceAsset:subIdentifier" whose value should be used to indicate
+ a particular shader definition from a source asset file.
+ * If set to "sourceCode", the value of "info:sourceCode" attribute
+ corresponding to the desired implementation (or source type) is used as
+ the shader source.
+ """
+ customData = {
+ string apiName = "implementationSource"
+ }
+ )
+
+ uniform token info:id (
+ doc = """The id is an identifier for the type or purpose of the
+ shader. E.g.: Texture or FractalFloat.
+ The use of this id will depend on the render context: some will turn it
+ into an actual shader path, some will use it to generate shader source
+ code dynamically.
+
+ \\sa SetShaderId()
+ """
+ customData = {
+ string apiName = "id"
+ }
+ )
+}
+
+class "ConnectableAPI"
+(
+ inherits =
+ doc = """UsdShadeConnectableAPI is an API schema that provides a common
+ interface for creating outputs and making connections between shading
+ parameters and outputs. The interface is common to all UsdShade schemas
+ that support Inputs and Outputs, which currently includes UsdShadeShader,
+ UsdShadeNodeGraph, and UsdShadeMaterial .
+
+ One can construct a UsdShadeConnectableAPI directly from a UsdPrim, or
+ from objects of any of the schema classes listed above. If it seems
+ onerous to need to construct a secondary schema object to interact with
+ Inputs and Outputs, keep in mind that any function whose purpose is either
+ to walk material/shader networks via their connections, or to create such
+ networks, can typically be written entirely in terms of
+ UsdShadeConnectableAPI objects, without needing to care what the underlying
+ prim type is.
+
+ Additionally, the most common UsdShadeConnectableAPI behaviors
+ (creating Inputs and Outputs, and making connections) are wrapped as
+ convenience methods on the prim schema classes (creation) and
+ UsdShadeInput and UsdShadeOutput.
+ """
+ customData = {
+ token apiSchemaType = "nonApplied"
+ string extraIncludes = '''
+#include "pxr/usd/usd/typed.h"
+#include "pxr/usd/usdShade/input.h"
+#include "pxr/usd/usdShade/output.h"
+#include "pxr/usd/usdShade/tokens.h"
+#include "pxr/usd/usdShade/types.h"'''
+ }
+)
+{
+}
+
+class "MaterialBindingAPI"
+(
+ inherits =
+ doc = """UsdShadeMaterialBindingAPI is an API schema that provides an
+ interface for binding materials to prims or collections of prims
+ (represented by UsdCollectionAPI objects).
+
+ In the USD shading model, each renderable gprim computes a single
+ resolved Material that will be used to shade the gprim (exceptions,
+ of course, for gprims that possess UsdGeomSubsets, as each subset can be
+ shaded by a different Material). A gprim and each of its ancestor
+ prims can possess, through the MaterialBindingAPI, both a
+ direct binding to a Material, and any number of
+ collection-based bindings to Materials; each binding can be generic
+ or declared for a particular purpose, and given a specific binding
+ strength. It is the process of "material resolution" (see
+ \\ref UsdShadeMaterialBindingAPI_MaterialResolution) that examines all of
+ these bindings, and selects the one Material that best matches the
+ client's needs.
+
+ The intent of purpose is that each gprim should be able to resolve a
+ Material for any given purpose, which implies it can have differently bound
+ materials for different purposes. There are two special values of
+ purpose defined in UsdShade, although the API fully supports
+ specifying arbitrary values for it, for the sake of extensibility:
+
UsdShadeTokens->full: to be used when the purpose of the
+ render is entirely to visualize the truest representation of a scene,
+ considering all lighting and material information, at highest fidelity.
+
UsdShadeTokens->preview: to be used when the render is in
+ service of a goal other than a high fidelity "full" render (such as scene
+ manipulation, modeling, or realtime playback). Latency and speed are
+ generally of greater concern for preview renders, therefore preview
+ materials are generally designed to be "lighterweight" compared to full
+ materials.
+ A binding can also have no specific purpose at all, in which
+ case, it is considered to be the fallback or all-purpose binding (denoted
+ by the empty-valued token UsdShadeTokens->allPurpose).
+
+ The purpose of a material binding is encoded in the name of the
+ binding relationship.
+
+ In the case of a direct binding, the allPurpose binding is
+ represented by the relationship named material:binding.
+ Special-purpose direct bindings are represented by relationships named
+ material:binding:purpose. A direct binding relationship
+ must have a single target path that points to a UsdShadeMaterial.
+
+ In the case of a collection-based binding, the allPurpose binding is
+ represented by a relationship named
+ material:binding:collection:bindingName, where
+ bindingName establishes an identity for the binding that is unique
+ on the prim. Attempting to establish two collection bindings of the same
+ name on the same prim will result in the first binding simply being
+ overridden. A special-purpose collection-based binding is represented by a
+ relationship named material:binding:collection:purpose:bindingName.
+ A collection-based binding relationship must have exacly two targets, one of
+ which should be a collection-path (see
+ \ref UsdCollectionAPI::GetCollectionPath()) and the other should point to a
+ UsdShadeMaterial. In the future, we may allow a single collection
+ binding to target multiple collections, if we can establish a reasonable
+ round-tripping pattern for applications that only allow a single collection
+ to be associated with each Material.
+
+
+
+ Note: Both bindingName and purpose must be
+ non-namespaced tokens. This allows us to know the role of a binding
+ relationship simply from the number of tokens in it.
+
Two tokens: the fallback, "all purpose", direct binding,
+ material:binding
+
Three tokens: a purpose-restricted, direct, fallback binding,
+ e.g. material:binding:preview
+
Four tokens: an all-purpose, collection-based binding, e.g.
+ material:binding:collection:metalBits
+
Five tokens: a purpose-restricted, collection-based binding,
+ e.g. material:binding:collection:full:metalBits
+
+
+ A binding-strength value is used to specify whether a binding
+ authored on a prim should be weaker or stronger than bindings that appear
+ lower in namespace. We encode the binding strength with as token-valued
+ metadata 'bindMaterialAs' for future flexibility, even though for
+ now, there are only two possible values:
+ UsdShadeTokens->weakerThanDescendants and
+ UsdShadeTokens->strongerThanDescendants. When binding-strength is
+ not authored (i.e. empty) on a binding-relationship, the default behavior
+ matches UsdShadeTokens->weakerThanDescendants.
+
+ \\note If a material binding relationship is a built-in property defined as
+ part of a typed prim's schema, a fallback value should not be provided for
+ it. This is because the "material resolution" algorithm only conisders
+ authored properties.
+ """
+ customData = {
+ string extraIncludes = """
+#include "pxr/usd/usd/collectionAPI.h"
+#include "pxr/usd/usdGeom/subset.h"
+#include "pxr/usd/usdShade/material.h"
+#include """
+ dictionary schemaTokens = {
+ dictionary materialBinding = {
+ string value = "material:binding"
+ string doc = """
+ The relationship name on non-shading prims to
+ denote a binding to a UsdShadeMaterial.
+ """
+ }
+ dictionary materialBindingCollection = {
+ string value = "material:binding:collection"
+ string doc = """
+ The relationship name on non-shading prims to
+ denote a collection-based binding to a UsdShadeMaterial.
+ """
+ }
+ dictionary allPurpose = {
+ string value = ""
+ string doc = """Possible value for the 'materialPurpose' parameter
+ in the various methods available in UsdShadeMaterialBindingAPI.
+ Its value is empty and its purpose is to represent a general
+ purpose material-binding that applies in the absence of a
+ specific-purpose binding.
+ """
+ }
+ dictionary preview = {
+ string doc = """Possible value for the 'materialPurpose'
+ parameter in UsdShadeMaterialBindingAPI, to be used when the
+ render is in service of a goal other than a high fidelity "full"
+ render (such as scene manipulation, modeling, or realtime
+ playback). Latency and speed are generally of greater concern
+ for preview renders, therefore preview materials are generally
+ designed to be "lighterweight" compared to full materials.
+ """
+ }
+
+ dictionary full = {
+ string doc= """Possible value for the 'materialPurpose'
+ parameter in UsdShadeMaterialBindingAPI, to be used when the
+ purpose of the render is entirely about visualizing the truest
+ representation of a scene, considering all lighting and material
+ information, at highest fidelity.
+ """
+ }
+ dictionary bindMaterialAs = {
+ string doc = """Token valued metadata key authored on a material
+ binding relationship to indicate the strength of the binding
+ relative to bindings authored on descendants.
+ """
+ }
+ dictionary weakerThanDescendants = {
+ string doc = """Possible value for 'bindMaterialAs' metadata on the
+ collection-based material binding relationship. Indicates
+ that the binding represented by the relationship is weaker than
+ any bindings authored on the descendants."""
+ }
+ dictionary strongerThanDescendants = {
+ string doc = """Possible value for 'bindMaterialAs' metadata on the
+ collection-based material binding relationship. Indicates
+ that the binding represented by the relationship is stronger than
+ any bindings authored on the descendants."""
+ }
+ dictionary fallbackStrength = {
+ string doc = """Sentinal value to be used for 'bindMaterialAs'
+ metadata's default value. Clients should pass this in for the
+ 'bindingStrength' argument to UsdShadeMaterialBindingAPI::Bind(),
+ if they want to author the default value (weakerThanDescendants)
+ sparsely. The value "fallbackStrength" never gets authored
+ into scene description."""
+ }
+ }
+ }
+)
+{
+
+}
+
+class "CoordSysAPI"
+(
+ inherits =
+ doc = """UsdShadeCoordSysAPI provides a way to designate, name,
+ and discover coordinate systems.
+
+ Coordinate systems are implicitly established by UsdGeomXformable
+ prims, using their local space. That coordinate system may be
+ bound (i.e., named) from another prim. The binding is encoded
+ as a single-target relationship.
+ Coordinate system bindings apply to descendants of the prim
+ where the binding is expressed, but names may be re-bound by
+ descendant prims.
+
+ CoordSysAPI is a multi-apply API schema, where instance names
+ signify the named coordinate systems. The instance names are
+ used with the "coordSys:" namespace to determine the binding
+ to the UsdGeomXformable prim.
+
+ Named coordinate systems are useful in shading (and other) workflows.
+ An example is projection paint, which projects a texture
+ from a certain view (the paint coordinate system), encoded as
+ (e.g.) "rel coordSys:paint:binding". Using the paint coordinate frame
+ avoids the need to assign a UV set to the object, and can be a
+ concise way to project paint across a collection of objects with
+ a single shared paint coordinate system.
+ """
+ customData = {
+ token apiSchemaType = "multipleApply"
+ token propertyNamespacePrefix = "coordSys"
+ string extraIncludes = '''
+#include "pxr/usd/usdGeom/xformable.h"'''
+ }
+)
+{
+ rel binding (
+ displayName = "Bound Coordinate System"
+ doc = "Prim binding expressing the appropriate coordinate systems."
+ )
+}
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "UsdShadersDiscoveryPlugin" : {
+ "bases": ["NdrDiscoveryPlugin"],
+ "displayName": "USD-based shader definition discovery plugin."
+ }
+ },
+ # Allow usdShaders/shaders to be accessible by hio/glslfx.cpp's
+ # ShaderResourceRegistry
+ "ShaderResources": "shaders"
+ },
+ "LibraryPath": "",
+ "Name": "usdShaders",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+
+#import $TOOLS/hdSt/shaders/surfaceHelpers.glslfx
+
+-- configuration
+{
+ "techniques": {
+ "default": {
+ "displacementShader": {
+ "source": [ "Preview.Displacement" ]
+ },
+ "surfaceShader": {
+ "source": [ "Preview.LightStructures",
+ "SurfaceHelpers.Lighting",
+ "Preview.Lighting",
+ "Preview.LightIntegration",
+ "SurfaceHelpers.TangentSpace",
+ "Preview.NormalMapping",
+ "Preview.Surface" ]
+ }
+ }
+ }
+}
+
+
+-- glsl Preview.Displacement
+
+vec4
+displacementShader(int index, vec4 Peye, vec3 Neye, vec4 patchCoord)
+{
+ // Calculate scalar displacement.
+ float texDisplacement = HdGetScalar_displacement(index);
+ return Peye + vec4(Neye*texDisplacement, 0);
+}
+
+
+-- glsl Preview.Surface
+
+vec4
+surfaceShader(vec4 Peye, vec3 Neye, vec4 color, vec4 patchCoord)
+{
+ float clearcoatAmount = HdGetScalar_clearcoat();
+ float clearcoatRoughness = HdGetScalar_clearcoatRoughness();
+ vec3 diffuseColor = HdGet_diffuseColor().xyz;
+ vec3 emissiveColor = HdGet_emissiveColor().xyz;
+ float ior = HdGetScalar_ior();
+ float metallic = HdGetScalar_metallic();
+ float occlusion = HdGetScalar_occlusion();
+ float opacity = HdGetScalar_opacity();
+ float opacityThreshold = HdGetScalar_opacityThreshold();
+ float roughness = HdGetScalar_roughness();
+ vec3 specularColor = HdGet_specularColor().xyz;
+ bool useSpecularWorkflow = (HdGetScalar_useSpecularWorkflow() == 1);
+
+ vec3 clearcoatColor = vec3(1.0);
+ float specularAmount = 1.0;
+
+#ifdef HD_MATERIAL_TAG_MASKED
+ if (opacity < opacityThreshold) {
+ discard;
+ return vec4(1.0);
+ }
+ opacity = 1.0;
+#endif
+
+ // Selection highlighting.
+ vec4 colorAndOpacity = vec4(diffuseColor, opacity);
+ diffuseColor = ApplyColorOverrides(colorAndOpacity).rgb;
+
+ // Pre-multiply diffuse color by opacity if not done so already
+#ifndef diffuseColor_IS_PREMULTIPLIED
+ diffuseColor *= opacity;
+#endif
+
+ // Evaluate all lights.
+ vec3 c = evaluateLights(
+ emissiveColor,
+ diffuseColor,
+ useSpecularWorkflow,
+ ior,
+ metallic,
+ specularAmount,
+ specularColor,
+ roughness,
+ clearcoatAmount,
+ clearcoatColor,
+ clearcoatRoughness,
+ occlusion,
+ Peye,
+ perturbFragmentNormal(Peye.xyz, Neye));
+
+ return vec4(c, colorAndOpacity.a);
+}
+
+
+-- glsl Preview.LightStructures
+
+struct LightingContributions
+{
+ vec3 diffuse;
+ vec3 specular;
+};
+
+
+-- glsl Preview.Lighting
+
+#define EPSILON 0.001
+
+
+float
+SchlickFresnel(float EdotH)
+{
+ return pow(max(0.0, 1.0 - EdotH), 5.0);
+}
+
+float
+NormalDistribution(float specularRoughness, float NdotH)
+{
+ float alpha = specularRoughness * specularRoughness;
+ float alpha2 = alpha * alpha;
+ float NdotH2 = NdotH * NdotH;
+ float DDenom = (NdotH2 * (alpha2 - 1.0)) + 1.0;
+ DDenom *= DDenom;
+ DDenom *= PI;
+ float D = (alpha2 + EPSILON) / DDenom;
+ return D;
+}
+
+float
+Geometric(
+ float specularRoughness,
+ float NdotL,
+ float NdotE,
+ float NdotH,
+ float EdotH)
+{
+ float alpha = specularRoughness * specularRoughness;
+ float k = alpha * 0.5;
+ float G = NdotE / (NdotE * (1.0 - k) + k);
+ G *= NdotL / (NdotL * (1.0 - k) + k);
+ return G;
+}
+
+vec3
+evaluateDirectDiffuse()
+{
+ return vec3(1.0 / PI);
+}
+
+vec3
+evaluateDirectSpecular(
+ vec3 specularColorF0,
+ vec3 specularColorF90,
+ float specularRoughness,
+ float fresnel,
+ float NdotL,
+ float NdotE,
+ float NdotH,
+ float EdotH)
+{
+ vec3 F = mix(specularColorF0, specularColorF90, fresnel);
+ float D = NormalDistribution(specularRoughness, NdotH);
+ float G = Geometric(specularRoughness, NdotL, NdotE, NdotH, EdotH);
+ vec3 RNum = F * G * D;
+ float RDenom = 4.0f * NdotL * NdotE + EPSILON;
+ return RNum / RDenom;
+}
+
+LightingContributions
+evaluateLight(
+ vec3 diffuseColor,
+ bool useSpecularWorkflow,
+ float ior,
+ float metallic,
+ float specularAmount,
+ vec3 specularColor,
+ float specularRoughness,
+ float clearcoatAmount,
+ vec3 clearcoatColor,
+ float clearcoatRoughness,
+ float occlusion,
+ float NdotL,
+ float NdotE,
+ float NdotH,
+ float EdotH,
+ vec3 lightDiffuseIrradiance,
+ vec3 lightSpecularIrradiance)
+{
+ specularRoughness = max(0.001, specularRoughness);
+ clearcoatRoughness = max(0.001, clearcoatRoughness);
+
+ float fresnel = SchlickFresnel(EdotH);
+
+ // Evaluate diffuse
+ vec3 d = diffuseColor * evaluateDirectDiffuse();
+
+ // Evaluate specular first lobe
+ vec3 s1 = vec3(0.0);
+ const float R = (1.0 - ior) / (1.0 + ior);
+ if (specularAmount > 0.0) {
+ vec3 F0 = specularColor;
+ vec3 F90 = vec3(1.0);
+
+ if (!useSpecularWorkflow) {
+ vec3 specColor = mix(vec3(1.0), diffuseColor, metallic);
+ F0 = mix(R * R * specColor, specColor, metallic);
+ F90 = specColor;
+
+ // For metallic workflows, pure metals have no diffuse
+ d *= 1.0 - metallic;
+ }
+
+ s1 = specularAmount * evaluateDirectSpecular(
+ F0, // Specular color 0
+ F90, // Specular color 90
+ specularRoughness, // Roughness
+ fresnel, // Fresnel
+ NdotL, NdotE, NdotH, EdotH); // Dot products needed for lights
+
+ // Adjust the diffuse so glazing angles have less diffuse
+ d *= (1.0 - mix(F0, F90, fresnel));
+ }
+
+ // Evaluate clearcoat
+ vec3 s2 = vec3(0.0);
+ if (clearcoatAmount > 0.0) {
+ s2 = clearcoatAmount * evaluateDirectSpecular(
+ R * R * clearcoatColor, // Clearcoat color 0
+ clearcoatColor, // Clearcoat color 90
+ clearcoatRoughness, // Roughness
+ fresnel, // Fresnel
+ NdotL, NdotE, NdotH, EdotH); // Dot products needed for lights
+ }
+
+ LightingContributions lightingContrib;
+
+ lightingContrib.diffuse =
+ occlusion * NdotL * d * lightDiffuseIrradiance;
+
+ lightingContrib.specular =
+ occlusion * NdotL * (s1 + s2) * lightSpecularIrradiance;
+
+ return lightingContrib;
+}
+
+
+-- glsl Preview.LightIntegration
+
+mat4 GetDomeLightTransform(mat4 worldToLightTransform)
+{
+ // transform from view space to light space
+ mat4 worldToViewInverse = GetWorldToViewInverseMatrix();
+ return worldToLightTransform * worldToViewInverse;
+}
+
+LightingContributions
+evaluateIndirectLighting(
+ vec3 diffuseColor,
+ vec3 specularColor,
+ vec3 Neye,
+ vec3 Reye,
+ float NdotE,
+ float EdotH,
+ float ior,
+ float metallic,
+ float occlusion,
+ float roughness,
+ bool useSpecularWorkflow,
+ float clearcoatAmount,
+ vec3 clearcoatColor,
+ float clearcoatRoughness,
+ mat4 worldToLightTransform)
+{
+ LightingContributions indirect;
+ indirect.diffuse = vec3(0.0);
+ indirect.specular = vec3(0.0);
+
+#ifdef HD_HAS_domeLightIrradiance
+ vec3 F0 = specularColor;
+ vec3 F90 = vec3(1.0);
+ vec3 d = diffuseColor;
+ const float R = (1.0 - ior) / (1.0 + ior);
+ if (!useSpecularWorkflow) {
+ vec3 specColor = mix(vec3(1.0), diffuseColor, metallic);
+ F0 = mix(R * R * specColor, specColor, metallic);
+ F90 = specColor;
+
+ // For metallic workflows, pure metals have no diffuse
+ d *= 1.0 - metallic;
+ }
+ // Adjust the diffuse so glazing angles have less diffuse
+ float fresnel = SchlickFresnel(EdotH);
+ vec3 F = mix(F0, F90, fresnel);
+ d *= (1.0 - F);
+
+ mat4 transformationMatrix = GetDomeLightTransform(worldToLightTransform);
+
+ // Diffuse Component
+ vec3 dir = normalize((transformationMatrix * vec4(Neye,0.0)).xyz);
+ vec2 coord = ProjectToLatLong(dir);
+ vec3 diffuse = HdGet_domeLightIrradiance(coord).rgb;
+
+ // Specular Component
+ const float MAX_REFLECTION_LOD =
+ textureQueryLevels(HdGetSampler_domeLightPrefilter());
+ float lod = roughness * MAX_REFLECTION_LOD;
+ vec3 Rdir = normalize((transformationMatrix * vec4(Reye,0.0)).xyz);
+ vec2 Rcoord = ProjectToLatLong(Rdir);
+ vec3 prefilter = HdTextureLod_domeLightPrefilter(Rcoord, lod).rgb;
+
+ vec2 brdf = HdGet_domeLightBRDF(vec2(NdotE, roughness)).rg;
+
+ vec3 specular = prefilter * (F * brdf.x + brdf.y);
+
+ // Clearcoat Component
+ vec3 clearcoat = vec3(0.0);
+ if (clearcoatAmount > 0.0) {
+ const vec3 clearcoatF = clearcoatAmount * mix(
+ R * R * clearcoatColor, // Clearcoat F0
+ clearcoatColor, // Clearcoat F90
+ fresnel);
+ lod = clearcoatRoughness * MAX_REFLECTION_LOD;
+ prefilter = HdTextureLod_domeLightPrefilter(Rcoord, lod).rgb;
+ clearcoat = prefilter * (clearcoatF * brdf.x + brdf.y);
+ }
+
+ // Indirect Lighting
+ indirect.diffuse = (d * diffuse) * occlusion;
+ indirect.specular = (specular + clearcoat) * occlusion;
+
+#endif
+
+ return indirect;
+}
+
+vec3
+evaluateLights(
+ vec3 emissiveColor,
+ vec3 diffuseColor,
+ bool useSpecularWorkflow,
+ float ior,
+ float metallic,
+ float specularAmount,
+ vec3 specularColor,
+ float specularRoughness,
+ float clearcoatAmount,
+ vec3 clearcoatColor,
+ float clearcoatRoughness,
+ float occlusion,
+ vec4 Peye,
+ vec3 Neye)
+{
+ vec3 n = Neye;
+ vec3 e = normalize(-Peye.xyz);
+ float NdotE = max(0.0, dot(n, e));
+
+ vec3 Reye = reflect(-e, n);
+
+ vec3 directLight = vec3(0.0);
+ vec3 indirectLight = vec3(0.0);
+
+#if NUM_LIGHTS > 0
+ for (int i = 0; i < NUM_LIGHTS; ++i) {
+ LightSource light = GetLightSource(i);
+
+ // Calculate necessary vector information for lighting
+ vec4 Plight = light.isIndirectLight
+ ? vec4(0,0,0,1)
+ : light.position;
+ vec3 l = (Plight.w == 0.0)
+ ? normalize(Plight.xyz)
+ : normalize(Plight - Peye).xyz;
+ vec3 h = normalize(e + l);
+ float NdotL = max(0.0, dot(n, l));
+ float NdotH = max(0.0, dot(n, h));
+ float EdotH = max(0.0, dot(e, h));
+
+ // Calculate light intensity
+ float atten = lightDistanceAttenuation(Peye, i);
+ float spot = lightSpotAttenuation(l, i);
+
+ // Calculate the shadow factor
+ float shadow = 1.0;
+ #if USE_SHADOWS
+ shadow = light.hasShadow ?
+ shadowing(/*lightIndex=*/i, Peye) : 1.0;
+ #endif
+
+ float intensity = atten * spot * shadow;
+
+ vec3 lightDiffuseIrradiance = intensity * light.diffuse.rgb;
+ vec3 lightSpecularIrradiance = intensity * light.specular.rgb;
+
+ LightingContributions lightingContrib = evaluateLight(
+ diffuseColor,
+ useSpecularWorkflow,
+ ior,
+ metallic,
+ specularAmount,
+ specularColor,
+ specularRoughness,
+ clearcoatAmount,
+ clearcoatColor,
+ clearcoatRoughness,
+ occlusion,
+ NdotL,
+ NdotE,
+ NdotH,
+ EdotH,
+ lightDiffuseIrradiance,
+ lightSpecularIrradiance);
+
+ // calculate the indirect light (DomeLight)
+ if (light.isIndirectLight) {
+
+ LightingContributions indirectLightContrib =
+ evaluateIndirectLighting(diffuseColor, specularColor,
+ Neye, Reye, NdotE, EdotH, ior, metallic, occlusion,
+ specularRoughness, useSpecularWorkflow,
+ clearcoatAmount, clearcoatColor, clearcoatRoughness,
+ light.worldToLightTransform);
+ indirectLight = (indirectLightContrib.diffuse * light.diffuse.rgb
+ + indirectLightContrib.specular * light.specular.rgb);
+ }
+ // all other light sources contribute to the direct lighting
+ else {
+ directLight += (lightingContrib.diffuse + lightingContrib.specular);
+ }
+ }
+#endif
+
+ return (emissiveColor + directLight + indirectLight);
+}
+
+
+-- glsl Preview.NormalMapping
+
+vec3
+perturbFragmentNormal(vec3 P, vec3 N)
+{
+#ifdef HD_HAS_COORD_normal
+ vec3 Nt = normalize(HdGet_normal().xyz);
+ vec2 st = HdGetCoord_normal().xy;
+ return PerturbNormal(P, N, st, Nt);
+#endif
+ return N;
+}
+
+
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+
+-- configuration
+{
+ "techniques": {
+ "default": {
+ }
+ }
+}
+
+-- This file is intentionally empty.
+#usda 1.0
+
+def Shader "UsdPreviewSurface" (
+ doc = "Preview surface specification"
+)
+{
+ uniform token info:id = "UsdPreviewSurface"
+ uniform token info:implementationSource = "sourceAsset"
+
+ # XXX: This doesn't resolve if it's defined as a search path.
+ # Might require special resolver configuration, to include the resources
+ # directory.
+ uniform asset info:glslfx:sourceAsset = @./previewSurface.glslfx@
+
+ # Outputs
+ token outputs:surface (
+ sdrMetadata = {
+ string renderType = "terminal surface"
+ }
+ )
+ token outputs:displacement (
+ sdrMetadata = {
+ string renderType = "terminal displacement"
+ }
+ )
+
+ # Inputs
+ color3f inputs:diffuseColor = (0.18, 0.18, 0.18) (
+ doc = """Parameter used as diffuseColor when using the specular
+ workflow, when using metallic workflow this is interpreted
+ as albedo."""
+ )
+
+ color3f inputs:emissiveColor = (0.0, 0.0, 0.0) (
+ doc = """Emissive component."""
+ )
+
+ int inputs:useSpecularWorkflow = 0 (
+ connectability = "interfaceOnly"
+ doc = """This node can fundamentally operate in two modes :
+ Specular workflow where you provide a texture/value to the
+ "specularColor" input. Or, Metallic workflow where you
+ provide a texture/value to the "metallic" input."""
+ )
+
+ color3f inputs:specularColor = (0.0, 0.0, 0.0) (
+ doc = """Used only in the specular workflow.
+ Specular color to be used.
+ This is the color at 0 incidence. Edge color is assumed white.
+ Transition between the two colors according to Schlick fresnel
+ approximation."""
+ )
+
+ float inputs:metallic = 0.0 (
+ doc = """Used only in the metalness workflow.
+ 1 for metallic surfaces and 0 for non-metallic.
+ - If metallic is 1, then both F0 (reflectivity at 0 degree
+ incidence) and edge F90 reflectivity will simply be the Albedo.
+ - If metallic is 0, then Albedo is ignored in the calculation of F0
+ and F90; F0 is derived from ior via ( (1-ior)/(1+ior) )^2 and F90 is
+ white.
+ In between, we interpolate."""
+ )
+
+ float inputs:roughness = 0.5 (
+ doc = """Roughness for the specular lobe. The value ranges from 0 to 1,
+ which goes from a perfectly specular surface at 0.0 to maximum roughness
+ of the specular lobe. This value is usually squared before use with a
+ GGX or Beckmann lobe."""
+ )
+
+ float inputs:clearcoat = 0.0 (
+ doc = """Second specular lobe amount. The color is white."""
+ )
+
+ float inputs:clearcoatRoughness = 0.01 (
+ doc = """Roughness for the second specular lobe."""
+ )
+
+ float inputs:opacity = 1.0 (
+ doc = """Opacity of the material."""
+ )
+
+ float inputs:opacityThreshold = 0.0 (
+ connectability = "interfaceOnly"
+ doc = """Threshold used to determine opacity values that will be
+ considered fully transparent. A value of 0.0 indicates that no masking
+ is applied to the opacity input, while a value greater than 0.0 indicates
+ that rendering of the surface is limited to the areas where the opacity
+ is greater or equal to that value. Note that when opacityThreshold is
+ greater than zero, the opacity values less than the opacityThreshold will
+ not be rendered, and the opacity values greater than or equal to the
+ opacityThreshold will be fully visible."""
+ )
+
+ float inputs:ior = 1.5 (
+ doc = """Index of Refraction to be used for translucent objects."""
+ )
+
+ normal3f inputs:normal = (0.0, 0.0, 1.0) (
+ doc = """Expects normal in tangent space [(-1,-1,-1), (1,1,1)]
+ This means your texture reader implementation should provide
+ data to this node that is properly scaled and ready
+ to be consumed as a tangent space normal.
+ If the texture has 8 bits per component, then scale and bias must be
+ adjusted to be (2.0, 2.0, 2.0, 1.0) and (-1, -1, -1, 0) respectively
+ in order to satisfy tangent space requirements.
+ Normal map data is commonly expected to be linearly encoded.
+ However, many image-writing tools automatically set the profile of
+ three-channel, 8-bit images to SRGB. To prevent an unwanted
+ transformation, the sourceColorSpace must also be set to "raw"."""
+ )
+
+ float inputs:displacement = 0.0 (
+ doc = """Displacement in the direction of the normal. """
+ )
+
+ float inputs:occlusion = 1.0 (
+ doc = """Occlusion signal. This provides extra information about the
+ occlusion of different parts of the mesh that this material is applied
+ to. Occlusion only makes sense as a surface-varying signal, and
+ pathtracers will likely choose to ignore it. An occlusion value of 0.0
+ means the surface point is fully occluded by other parts of the surface,
+ and a value of 1.0 means the surface point is completely unoccluded by
+ other parts of the surface. """
+ )
+}
+
+def Shader "UsdUVTexture" (
+ doc = """Texture Node Specification represents a node that can be used to
+ read UV textures, including tiled textures such as Mari UDIM's.
+
+ Reads from a texture file and outputs one or more values. If the texture has
+ 8 bits per component, [0, 255] values will first be converted to floating
+ point in the range [0, 1] and then any transformations (bias, scale)
+ indicated are applied. Otherwise any indicated transformation (bias,
+ scale) is just applied. If a single-channel texture is fed into a
+ UsdUVTexture, the r, g, and b components of the rgb output will repeat the
+ channel's value, while the single 'a' output will be set to 1.0. If a
+ two-channel texture is fed into a UsdUVTexture, the r, g, and b components
+ of the rgb output will repeat the first channel's value, while the single
+ 'a' output will be set to the second channel's value. If a three-channel
+ texture is fed into a UsdUVTexture, the r, g, and b components of the rgb
+ outputs will contain the assigned texture channel's value, while the single
+ 'a' output will be set to 1.0.
+"""
+ sdrMetadata = {
+ token role = "texture"
+ }
+)
+{
+ uniform token info:id = "UsdUVTexture"
+ uniform token info:implementationSource = "sourceAsset"
+ uniform asset info:glslfx:sourceAsset = @./uvTexture.glslfx@
+
+ asset inputs:file = @@ (
+ connectability = "interfaceOnly"
+ doc = """Path to the texture this node uses."""
+ )
+
+ float2 inputs:st = (0.0, 0.0) (
+ doc = """This input provides the texture coordinates. It is usually
+ connected to a (primvar) node that will provide the texture
+ coords."""
+ )
+
+ token inputs:wrapS = "useMetadata" (
+ allowedTokens = ["black", "clamp", "repeat", "mirror", "useMetadata"]
+ connectability = "interfaceOnly"
+ doc = """ black, clamp, repeat, mirror, useMetadata."""
+ )
+
+ token inputs:wrapT = "useMetadata" (
+ allowedTokens = ["black", "clamp", "repeat", "mirror", "useMetadata"]
+ connectability = "interfaceOnly"
+ doc = """ black, clamp, repeat, mirror, useMetadata."""
+ )
+
+ float4 inputs:fallback = (0.0, 0.0, 0.0, 1.0) (
+ doc = """Fallback value to be used when no texture is connected."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ float4 inputs:scale = (1.0, 1.0, 1.0, 1.0) (
+ connectability = "interfaceOnly"
+ doc = """Scale to be applied to all components of the texture.
+ value * scale + bias.
+ Please see UsdPreviewSurface.inputs:normal for special
+ considerations for reading normal maps."""
+ )
+
+ float4 inputs:bias = (0.0, 0.0, 0.0, 0.0) (
+ connectability = "interfaceOnly"
+ doc = """Bias to be applied to all components of the texture.
+ value * scale + bias).
+ Please see UsdPreviewSurface.inputs:normal for special
+ considerations for reading normal maps."""
+ )
+
+ token inputs:sourceColorSpace = "auto" (
+ connectability = "interfaceOnly"
+ allowedTokens = ["raw", "sRGB", "auto"]
+ doc = """ raw, sRGB, auto. Flag indicating the color
+ space in which the source texture is encoded. If set to sRGB,
+ the texture will be read using the sRGB transfer curve, but
+ not filtered against the sRGB gamut. Please see
+ UsdPreviewSurface.inputs:normal for special considerations for
+ reading normal maps."""
+ )
+
+ float outputs:r (
+ doc = "Outputs the red channel."
+ sdrMetadata = {
+ token swizzle = "x"
+ }
+ )
+
+ float outputs:g (
+ doc = "Outputs the green channel."
+ sdrMetadata = {
+ token swizzle = "y"
+ }
+ )
+
+ float outputs:b (
+ doc = "Outputs the blue channnel."
+ sdrMetadata = {
+ token swizzle = "z"
+ }
+ )
+
+ float outputs:a (
+ doc = "Outputs the alpha channnel."
+ sdrMetadata = {
+ token swizzle = "w"
+ }
+ )
+
+ float3 outputs:rgb (
+ doc = "Outputs the red, green and blue channels."
+ sdrMetadata = {
+ token swizzle = "xyz"
+ }
+ )
+}
+
+class "UsdPrimvarReader" (
+ sdrMetadata = {
+ token role = "primvar"
+ }
+)
+{
+ uniform token info:implementationSource = "sourceAsset"
+ uniform asset info:glslfx:sourceAsset = @./primvarReader.glslfx@
+ string inputs:varname = "" (
+ connectability = "interfaceOnly"
+ doc = """Name of the primvar to be fetched from the geometry."""
+ sdrMetadata = {
+ token primvarProperty = "1"
+ }
+ )
+}
+
+def Shader "UsdPrimvarReader_float" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_float"
+
+ float inputs:fallback = 0.0 (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ float outputs:result
+}
+
+def Shader "UsdPrimvarReader_float2" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_float2"
+
+ float2 inputs:fallback = (0.0, 0.0) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ float2 outputs:result
+}
+
+def Shader "UsdPrimvarReader_float3" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_float3"
+
+ float3 inputs:fallback = (0.0, 0.0, 0.0) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ float3 outputs:result
+}
+
+def Shader "UsdPrimvarReader_float4" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_float4"
+
+ float4 inputs:fallback = (0.0, 0.0, 0.0, 0.0) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ float4 outputs:result
+}
+
+def Shader "UsdPrimvarReader_int" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_int"
+
+ int inputs:fallback = 0 (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ int outputs:result
+}
+
+def Shader "UsdPrimvarReader_string" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_string"
+
+ string inputs:fallback = "" (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ string outputs:result
+}
+
+def Shader "UsdPrimvarReader_normal" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_normal"
+
+ normal3f inputs:fallback = (0.0, 0.0, 0.0) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ normal3f outputs:result
+}
+
+def Shader "UsdPrimvarReader_point" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_point"
+
+ point3f inputs:fallback = (0.0, 0.0, 0.0) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ point3f outputs:result
+}
+
+def Shader "UsdPrimvarReader_vector" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_vector"
+
+ vector3f inputs:fallback = (0.0, 0.0, 0.0) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ vector3f outputs:result
+}
+
+def Shader "UsdPrimvarReader_matrix" (
+ inherits =
+)
+{
+ uniform token info:id = "UsdPrimvarReader_matrix"
+
+ matrix4d inputs:fallback = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) ) (
+ doc = """Fallback value to be returned when fetch failed."""
+ sdrMetadata = {
+ token defaultInput = "1"
+ }
+ )
+
+ matrix4d outputs:result
+}
+
+def Shader "UsdTransform2d" (
+ doc = """Transform 2d represents a node that can be used to
+ transform 2d data (for instance, texture coordinates).
+ The node applies the following transformation :
+ in * scale * rotate + translation"""
+ sdrMetadata = {
+ token role = "math"
+ }
+)
+{
+ uniform token info:id = "UsdTransform2d"
+ uniform token info:implementationSource = "sourceAsset"
+ uniform asset info:glslfx:sourceAsset = @./transform2d.glslfx@
+
+ float2 inputs:in = (0.0, 0.0) (
+ doc = """This input provides the data. It is usually
+ connected to a UsdPrimvarReader_float2 that
+ will provide the data."""
+ )
+
+ float inputs:rotation = 0.0 (
+ connectability = "interfaceOnly"
+ doc = """Counter-clockwise rotation in degrees around the origin to be applied
+ to all components of the data."""
+ )
+
+ float2 inputs:scale = (1.0, 1.0) (
+ connectability = "interfaceOnly"
+ doc = """Scale around the origin to be applied to all components of the data."""
+ )
+
+ float2 inputs:translation = (0.0, 0.0) (
+ connectability = "interfaceOnly"
+ doc = """Translation to be applied to all components of the data."""
+ )
+
+ float2 outputs:result (
+ doc = "Outputs transformed float2 values."
+ )
+}
+-- glslfx version 0.1
+
+//
+// Copyright 2020 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+
+-- configuration
+{
+ "techniques": {
+ "default": {
+ }
+ }
+}
+
+-- This file is intentionally empty.
+-- glslfx version 0.1
+
+//
+// Copyright 2018 Pixar
+//
+// Licensed under the Apache License, Version 2.0 (the "Apache License")
+// with the following modification; you may not use this file except in
+// compliance with the Apache License and the following modification to it:
+// Section 6. Trademarks. is deleted and replaced with:
+//
+// 6. Trademarks. This License does not grant permission to use the trade
+// names, trademarks, service marks, or product names of the Licensor
+// and its affiliates, except as required to comply with Section 4(c) of
+// the License and to reproduce the content of the NOTICE file.
+//
+// You may obtain a copy of the Apache License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the Apache License with the above modification is
+// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the Apache License for the specific
+// language governing permissions and limitations under the Apache License.
+//
+
+-- configuration
+{
+ "techniques": {
+ "default": {
+ }
+ }
+}
+
+-- This file is intentionally empty.
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class SkelRoot "SkelRoot" (
+ doc = '''Boundable prim type used to identify a scope beneath which
+ skeletally-posed primitives are defined.
+
+ A SkelRoot must be defined at or above a skinned primitive for any skinning
+ behaviors in UsdSkel.
+
+ See the extended "Skel Root Schema" documentation for
+ more information.'''
+)
+{
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Skeleton "Skeleton" (
+ doc = '''Describes a skeleton.
+
+ See the extended "Skeleton Schema" documentation for
+ more information.
+ '''
+)
+{
+ uniform matrix4d[] bindTransforms (
+ doc = """Specifies the bind-pose transforms of each joint in
+ **world space**, in the ordering imposed by *joints*."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ uniform token[] jointNames (
+ doc = """If authored, provides a unique name per joint. This may be
+ optionally set to provide better names when translating to DCC apps
+ that require unique joint names."""
+ )
+ uniform token[] joints (
+ doc = """An array of path tokens identifying the set of joints that make
+ up the skeleton, and their order. Each token in the array must be valid
+ when parsed as an SdfPath. The parent-child relationships of the
+ corresponding paths determine the parent-child relationships of each
+ joint. It is not required that the name at the end of each path be
+ unique, but rather only that the paths themselves be unique."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ uniform matrix4d[] restTransforms (
+ doc = """Specifies the rest-pose transforms of each joint in
+ **local space**, in the ordering imposed by *joints*. This provides
+ fallback values for joint transforms when a Skeleton either has no
+ bound animation source, or when that animation source only contains
+ animation for a subset of a Skeleton's joints."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class SkelAnimation "SkelAnimation" (
+ doc = '''Describes a skel animation, where joint animation is stored in a
+ vectorized form.
+
+ See the extended "Skel Animation"
+ documentation for more information.
+ '''
+)
+{
+ uniform token[] blendShapes (
+ doc = """Array of tokens identifying which blend shapes this
+ animation's data applies to. The tokens for blendShapes correspond to
+ the tokens set in the *skel:blendShapes* binding property of the
+ UsdSkelBindingAPI."""
+ )
+ float[] blendShapeWeights (
+ doc = """Array of weight values for each blend shape. Each weight value
+ is associated with the corresponding blend shape identified within the
+ *blendShapes* token array, and therefore must have the same length as
+ *blendShapes."""
+ )
+ uniform token[] joints (
+ doc = """Array of tokens identifying which joints this animation's
+ data applies to. The tokens for joints correspond to the tokens of
+ Skeleton primitives. The order of the joints as listed here may
+ vary from the order of joints on the Skeleton itself."""
+ )
+ quatf[] rotations (
+ doc = """Joint-local unit quaternion rotations of all affected joints,
+ in 32-bit precision. Array length should match the size of the
+ *joints* attribute."""
+ )
+ half3[] scales (
+ doc = """Joint-local scales of all affected joints, in
+ 16 bit precision. Array length should match the size of the *joints*
+ attribute."""
+ )
+ float3[] translations (
+ doc = """Joint-local translations of all affected joints. Array length
+ should match the size of the *joints* attribute."""
+ )
+}
+
+class "SkelBindingAPI" (
+ doc = '''Provides API for authoring and extracting all the skinning-related
+ data that lives in the "geometry hierarchy" of prims and models that want
+ to be skeletally deformed.
+
+ See the extended "UsdSkelBindingAPI schema"
+ documentation for more about bindings and how they apply in a scene graph.
+ '''
+)
+{
+ matrix4d primvars:skel:geomBindTransform (
+ doc = '''Encodes the bind-time world space transforms of the prim.
+ If the transform is identical for a group of gprims that share a common
+ ancestor, the transform may be authored on the ancestor, to "inherit"
+ down to all the leaf gprims. If this transform is unset, an identity
+ transform is used instead.'''
+ )
+ int[] primvars:skel:jointIndices (
+ doc = """Indices into the *joints* attribute of the closest
+ (in namespace) bound Skeleton that affect each point of a PointBased
+ gprim. The primvar can have either *constant* or *vertex* interpolation.
+ This primvar's *elementSize* will determine how many joint influences
+ apply to each point. Indices must point be valid. Null influences should
+ be defined by setting values in jointWeights to zero.
+ See UsdGeomPrimvar for more information on interpolation and
+ elementSize."""
+ )
+ float[] primvars:skel:jointWeights (
+ doc = """Weights for the joints that affect each point of a PointBased
+ gprim. The primvar can have either *constant* or *vertex* interpolation.
+ This primvar's *elementSize* will determine how many joints influences
+ apply to each point. The length, interpolation, and elementSize of
+ *jointWeights* must match that of *jointIndices*. See UsdGeomPrimvar
+ for more information on interpolation and elementSize."""
+ )
+ uniform token primvars:skel:skinningMethod = "classicLinear" (
+ allowedTokens = ["classicLinear", "dualQuaternion"]
+ doc = "The skinningMethod specifies the skinning method for the prim."
+ )
+ rel skel:animationSource (
+ doc = """Animation source to be bound to Skeleton primitives at or
+ beneath the location at which this property is defined.
+ """
+ )
+ uniform token[] skel:blendShapes (
+ doc = """An array of tokens defining the order onto which blend shape
+ weights from an animation source map onto the *skel:blendShapeTargets*
+ rel of a binding site. If authored, the number of elements must be equal
+ to the number of targets in the _blendShapeTargets_ rel. This property
+ is not inherited hierarchically, and is expected to be authored directly
+ on the skinnable primitive to which the blend shapes apply."""
+ )
+ rel skel:blendShapeTargets (
+ doc = """Ordered list of all target blend shapes. This property is not
+ inherited hierarchically, and is expected to be authored directly on
+ the skinnable primitive to which the the blend shapes apply."""
+ )
+ uniform token[] skel:joints (
+ doc = """An (optional) array of tokens defining the list of
+ joints to which jointIndices apply. If not defined, jointIndices applies
+ to the ordered list of joints defined in the bound Skeleton's *joints*
+ attribute. If undefined on a primitive, the primitive inherits the
+ value of the nearest ancestor prim, if any."""
+ )
+ rel skel:skeleton (
+ doc = """Skeleton to be bound to this prim and its descendents that
+ possess a mapping and weighting to the joints of the identified
+ Skeleton."""
+ )
+}
+
+class BlendShape "BlendShape" (
+ doc = '''Describes a target blend shape, possibly containing inbetween
+ shapes.
+
+ See the extended "Blend Shape Schema
+ documentation for information.
+ '''
+)
+{
+ uniform vector3f[] normalOffsets (
+ doc = """**Required property**. Normal offsets which, when added to the
+ base pose, provides the normals of the target shape."""
+ )
+ uniform vector3f[] offsets (
+ doc = """**Required property**. Position offsets which, when added to the
+ base pose, provides the target shape."""
+ )
+ uniform int[] pointIndices (
+ doc = """**Optional property**. Indices into the original mesh that
+ correspond to the values in *offsets* and of any inbetween shapes. If
+ authored, the number of elements must be equal to the number of elements
+ in the *offsets* array."""
+ )
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "SdfMetadata": {
+ "weight": {
+ "appliesTo": [
+ "attributes"
+ ],
+ "default": 0,
+ "displayGroup": "BlendShape",
+ "documentation": "The weight value at which an inbeteen shape is applied.",
+ "type": "float"
+ }
+ },
+ "Types": {
+ "UsdSkelAnimation": {
+ "alias": {
+ "UsdSchemaBase": "SkelAnimation"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdSkelBindingAPI": {
+ "alias": {
+ "UsdSchemaBase": "SkelBindingAPI"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdAPISchemaBase"
+ ],
+ "schemaKind": "singleApplyAPI"
+ },
+ "UsdSkelBlendShape": {
+ "alias": {
+ "UsdSchemaBase": "BlendShape"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdTyped"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdSkelRoot": {
+ "alias": {
+ "UsdSchemaBase": "SkelRoot"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomBoundable"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ },
+ "UsdSkelSkeleton": {
+ "alias": {
+ "UsdSchemaBase": "Skeleton"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomBoundable"
+ ],
+ "implementsComputeExtent": true,
+ "schemaKind": "concreteTyped"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdSkel",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+(
+ """ This file contains a schema for supporting skeletal animations in USD.
+ """
+ subLayers = [
+ @usdGeom/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdSkel"
+ string libraryPath = "pxr/usd/usdSkel"
+
+ dictionary libraryTokens = {
+ dictionary weight = {
+ string doc = """UsdSkelInbetweenShape - The weight location at
+ which the inbetween shape applies."""
+ }
+ }
+ }
+) {
+}
+
+
+class SkelRoot "SkelRoot" (
+ inherits =
+ doc = """Boundable prim type used to identify a scope beneath which
+ skeletally-posed primitives are defined.
+
+ A SkelRoot must be defined at or above a skinned primitive for any skinning
+ behaviors in UsdSkel.
+
+ See the extended \\ref UsdSkel_SkelRoot "Skel Root Schema" documentation for
+ more information."""
+ customData = {
+ string className = "Root"
+
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+ }
+) {
+}
+
+
+class Skeleton "Skeleton" (
+ inherits =
+ doc = """Describes a skeleton.
+
+ See the extended \\ref UsdSkel_Skeleton "Skeleton Schema" documentation for
+ more information.
+ """
+ customData = {
+ dictionary extraPlugInfo = {
+ bool implementsComputeExtent = true
+ }
+
+ string extraIncludes = """
+#include "pxr/usd/usdSkel/topology.h" """
+ }
+) {
+ uniform token[] joints (
+ doc = """An array of path tokens identifying the set of joints that make
+ up the skeleton, and their order. Each token in the array must be valid
+ when parsed as an SdfPath. The parent-child relationships of the
+ corresponding paths determine the parent-child relationships of each
+ joint. It is not required that the name at the end of each path be
+ unique, but rather only that the paths themselves be unique."""
+ )
+
+ uniform token[] jointNames (
+ doc = """If authored, provides a unique name per joint. This may be
+ optionally set to provide better names when translating to DCC apps
+ that require unique joint names."""
+ )
+
+ uniform matrix4d[] bindTransforms (
+ doc = """Specifies the bind-pose transforms of each joint in
+ **world space**, in the ordering imposed by *joints*."""
+ )
+ uniform matrix4d[] restTransforms (
+ doc = """Specifies the rest-pose transforms of each joint in
+ **local space**, in the ordering imposed by *joints*. This provides
+ fallback values for joint transforms when a Skeleton either has no
+ bound animation source, or when that animation source only contains
+ animation for a subset of a Skeleton's joints."""
+ )
+}
+
+
+class SkelAnimation "SkelAnimation" (
+ inherits =
+ doc = """Describes a skel animation, where joint animation is stored in a
+ vectorized form.
+
+ See the extended \\ref UsdSkel_SkelAnimation "Skel Animation"
+ documentation for more information.
+ """
+ customData = {
+ string className = "Animation"
+ }
+) {
+ uniform token[] joints (
+ doc = """Array of tokens identifying which joints this animation's
+ data applies to. The tokens for joints correspond to the tokens of
+ Skeleton primitives. The order of the joints as listed here may
+ vary from the order of joints on the Skeleton itself."""
+ )
+
+ float3[] translations (
+ doc = """Joint-local translations of all affected joints. Array length
+ should match the size of the *joints* attribute."""
+ )
+
+ quatf[] rotations (
+ doc = """Joint-local unit quaternion rotations of all affected joints,
+ in 32-bit precision. Array length should match the size of the
+ *joints* attribute."""
+ )
+
+ half3[] scales (
+ doc = """Joint-local scales of all affected joints, in
+ 16 bit precision. Array length should match the size of the *joints*
+ attribute."""
+ )
+
+ uniform token[] blendShapes (
+ doc = """Array of tokens identifying which blend shapes this
+ animation's data applies to. The tokens for blendShapes correspond to
+ the tokens set in the *skel:blendShapes* binding property of the
+ UsdSkelBindingAPI."""
+ )
+
+ float[] blendShapeWeights (
+ doc = """Array of weight values for each blend shape. Each weight value
+ is associated with the corresponding blend shape identified within the
+ *blendShapes* token array, and therefore must have the same length as
+ *blendShapes."""
+ )
+}
+
+class "SkelBindingAPI" (
+ inherits =
+ doc = """Provides API for authoring and extracting all the skinning-related
+ data that lives in the "geometry hierarchy" of prims and models that want
+ to be skeletally deformed.
+
+ See the extended \\ref UsdSkel_BindingAPI "UsdSkelBindingAPI schema"
+ documentation for more about bindings and how they apply in a scene graph.
+ """
+ customData = {
+ string className = "BindingAPI"
+ string extraIncludes = """
+#include "pxr/base/tf/span.h"
+#include "pxr/usd/usdGeom/primvar.h"
+#include "pxr/usd/usdSkel/skeleton.h" """
+ }
+)
+{
+ rel skel:animationSource (
+ customData = {
+ string apiName = "animationSource"
+ }
+ doc = """Animation source to be bound to Skeleton primitives at or
+ beneath the location at which this property is defined.
+ """
+ )
+
+ rel skel:skeleton (
+ customData = {
+ string apiName = "skeleton"
+ }
+ doc = """Skeleton to be bound to this prim and its descendents that
+ possess a mapping and weighting to the joints of the identified
+ Skeleton."""
+ )
+
+ uniform token primvars:skel:skinningMethod = "classicLinear" (
+ customData = {
+ string apiName = "skinningMethod"
+ }
+ allowedTokens = ["classicLinear", "dualQuaternion"]
+ doc = """The skinningMethod specifies the skinning method for the prim."""
+ )
+
+ matrix4d primvars:skel:geomBindTransform (
+ customData = {
+ string apiName = "geomBindTransform"
+ }
+ doc = """Encodes the bind-time world space transforms of the prim.
+ If the transform is identical for a group of gprims that share a common
+ ancestor, the transform may be authored on the ancestor, to "inherit"
+ down to all the leaf gprims. If this transform is unset, an identity
+ transform is used instead."""
+ )
+
+ uniform token[] skel:joints (
+ customData = {
+ string apiName = "joints"
+ }
+ doc = """An (optional) array of tokens defining the list of
+ joints to which jointIndices apply. If not defined, jointIndices applies
+ to the ordered list of joints defined in the bound Skeleton's *joints*
+ attribute. If undefined on a primitive, the primitive inherits the
+ value of the nearest ancestor prim, if any."""
+ )
+
+ int[] primvars:skel:jointIndices (
+ customData = {
+ string apiName = "jointIndices"
+ }
+ doc = """Indices into the *joints* attribute of the closest
+ (in namespace) bound Skeleton that affect each point of a PointBased
+ gprim. The primvar can have either *constant* or *vertex* interpolation.
+ This primvar's *elementSize* will determine how many joint influences
+ apply to each point. Indices must point be valid. Null influences should
+ be defined by setting values in jointWeights to zero.
+ See UsdGeomPrimvar for more information on interpolation and
+ elementSize."""
+ )
+
+ float[] primvars:skel:jointWeights (
+ customData = {
+ string apiName = "jointWeights"
+ }
+ doc = """Weights for the joints that affect each point of a PointBased
+ gprim. The primvar can have either *constant* or *vertex* interpolation.
+ This primvar's *elementSize* will determine how many joints influences
+ apply to each point. The length, interpolation, and elementSize of
+ *jointWeights* must match that of *jointIndices*. See UsdGeomPrimvar
+ for more information on interpolation and elementSize."""
+ )
+
+ uniform token[] skel:blendShapes (
+ customData = {
+ string apiName = "blendShapes"
+ }
+ doc = """An array of tokens defining the order onto which blend shape
+ weights from an animation source map onto the *skel:blendShapeTargets*
+ rel of a binding site. If authored, the number of elements must be equal
+ to the number of targets in the _blendShapeTargets_ rel. This property
+ is not inherited hierarchically, and is expected to be authored directly
+ on the skinnable primitive to which the blend shapes apply."""
+ )
+ rel skel:blendShapeTargets (
+ customData = {
+ string apiName= "blendShapeTargets"
+ }
+ doc = """Ordered list of all target blend shapes. This property is not
+ inherited hierarchically, and is expected to be authored directly on
+ the skinnable primitive to which the the blend shapes apply."""
+ )
+}
+
+
+class BlendShape "BlendShape" (
+ inherits =
+ doc = """Describes a target blend shape, possibly containing inbetween
+ shapes.
+
+ See the extended \\ref UsdSkel_BlendShape "Blend Shape Schema
+ documentation for information.
+ """
+ customData = {
+ string extraIncludes = """
+#include "pxr/base/tf/span.h"
+#include "pxr/usd/usdSkel/inbetweenShape.h" """
+ }
+)
+{
+ uniform vector3f[] offsets (
+ doc = """**Required property**. Position offsets which, when added to the
+ base pose, provides the target shape."""
+ )
+
+ uniform vector3f[] normalOffsets (
+ doc = """**Required property**. Normal offsets which, when added to the
+ base pose, provides the normals of the target shape."""
+ )
+
+ uniform int[] pointIndices (
+ doc = """**Optional property**. Indices into the original mesh that
+ correspond to the values in *offsets* and of any inbetween shapes. If
+ authored, the number of elements must be equal to the number of elements
+ in the *offsets* array."""
+ )
+}
+#usda 1.0
+(
+ "WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
+)
+
+class Volume "Volume" (
+ doc = """A renderable volume primitive. A volume is made up of any number
+ of FieldBase primitives bound together in this volume. Each
+ FieldBase primitive is specified as a relationship with a
+ namespace prefix of \"field\".
+
+ The relationship name is used by the renderer to associate
+ individual fields with the named input parameters on the volume
+ shader. Using this indirect approach to connecting fields to
+ shader parameters (rather than using the field prim's name)
+ allows a single field to be reused for different shader inputs, or
+ to be used as different shader parameters when rendering different
+ Volumes. This means that the name of the field prim is not
+ relevant to its contribution to the volume prims which refer to
+ it. Nor does the field prim's location in the scene graph have
+ any relevance, and Volumes may refer to fields anywhere in the
+ scene graph. **However**, unless Field prims need to be shared
+ by multiple Volumes, a Volume's Field prims should be located
+ under the Volume in namespace, for enhanced organization."""
+)
+{
+ uniform bool doubleSided = 0 (
+ doc = """Although some renderers treat all parametric or polygonal
+ surfaces as if they were effectively laminae with outward-facing
+ normals on both sides, some renderers derive significant optimizations
+ by considering these surfaces to have only a single outward side,
+ typically determined by control-point winding order and/or
+ orientation. By doing so they can perform \"backface culling\" to
+ avoid drawing the many polygons of most closed surfaces that face away
+ from the viewer.
+
+ However, it is often advantageous to model thin objects such as paper
+ and cloth as single, open surfaces that must be viewable from both
+ sides, always. Setting a gprim's doubleSided attribute to
+ \\c true instructs all renderers to disable optimizations such as
+ backface culling for the gprim, and attempt (not all renderers are able
+ to do so, but the USD reference GL renderer always will) to provide
+ forward-facing normals on each side of the surface for lighting
+ calculations."""
+ )
+ float3[] extent (
+ doc = """Extent is a three dimensional range measuring the geometric
+ extent of the authored gprim in its own local space (i.e. its own
+ transform not applied), without accounting for any shader-induced
+ displacement. If __any__ extent value has been authored for a given
+ Boundable, then it should be authored at every timeSample at which
+ geometry-affecting properties are authored, to ensure correct
+ evaluation via ComputeExtent(). If __no__ extent value has been
+ authored, then ComputeExtent() will call the Boundable's registered
+ ComputeExtentFunction(), which may be expensive, which is why we
+ strongly encourage proper authoring of extent.
+ \\sa ComputeExtent()
+ \\sa \\ref UsdGeom_Boundable_Extent.
+
+ An authored extent on a prim which has children is expected to include
+ the extent of all children, as they will be pruned from BBox computation
+ during traversal."""
+ )
+ uniform token orientation = "rightHanded" (
+ allowedTokens = ["rightHanded", "leftHanded"]
+ doc = """Orientation specifies whether the gprim's surface normal
+ should be computed using the right hand rule, or the left hand rule.
+ Please see for a deeper explanation and
+ generalization of orientation to composed scenes with transformation
+ hierarchies."""
+ )
+ color3f[] primvars:displayColor (
+ doc = '''It is useful to have an "official" colorSet that can be used
+ as a display or modeling color, even in the absence of any specified
+ shader for a gprim. DisplayColor serves this role; because it is a
+ UsdGeomPrimvar, it can also be used as a gprim override for any shader
+ that consumes a displayColor parameter.'''
+ )
+ float[] primvars:displayOpacity (
+ doc = """Companion to displayColor that specifies opacity, broken
+ out as an independent attribute rather than an rgba color, both so that
+ each can be independently overridden, and because shaders rarely consume
+ rgba parameters."""
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "FieldBase" (
+ doc = "Base class for field primitives."
+)
+{
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class "FieldAsset" (
+ doc = "Base class for field primitives defined by an external file."
+)
+{
+ token fieldDataType (
+ doc = """Token which is used to indicate the data type of an
+ individual field. Authors use this to tell consumers more
+ about the field without opening the file on disk. The list of
+ allowed tokens is specified with the specific asset type.
+ A missing value is considered an error."""
+ )
+ int fieldIndex (
+ doc = """A file can contain multiple fields with the same
+ name. This optional attribute is an index used to
+ disambiguate between these multiple fields with the same
+ name."""
+ )
+ token fieldName (
+ doc = """Name of an individual field within the file specified by
+ the filePath attribute."""
+ )
+ asset filePath (
+ doc = """An asset path attribute that points to a file on disk.
+ For each supported file format, a separate FieldAsset
+ subclass is required.
+
+ This attribute's value can be animated over time, as most
+ volume asset formats represent just a single timeSample of
+ a volume. However, it does not, at this time, support
+ any pattern substitutions like \"$F\". """
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token vectorDataRoleHint = "None" (
+ allowedTokens = ["None", "Point", "Normal", "Vector", "Color"]
+ doc = """Optional token which is used to indicate the role of a vector
+ valued field. This can drive the data type in which fields
+ are made available in a renderer or whether the vector values
+ are to be transformed."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class Field3DAsset "Field3DAsset" (
+ doc = """Field3D field primitive. The FieldAsset filePath attribute must
+ specify a file in the Field3D format on disk."""
+)
+{
+ token fieldDataType (
+ allowedTokens = ["half", "float", "double", "half3", "float3", "double3"]
+ doc = """Token which is used to indicate the data type of an
+ individual field. Authors use this to tell consumers more
+ about the field without opening the file on disk. The list of
+ allowed tokens reflects the available choices for Field3d
+ volumes."""
+ )
+ int fieldIndex (
+ doc = """A file can contain multiple fields with the same
+ name. This optional attribute is an index used to
+ disambiguate between these multiple fields with the same
+ name."""
+ )
+ token fieldName (
+ doc = """Name of an individual field within the file specified by
+ the filePath attribute."""
+ )
+ token fieldPurpose (
+ doc = """Optional token which can be used to indicate the purpose or
+ grouping of an individual field. Clients which consume Field3D
+ files should treat this as the Field3D field name."""
+ )
+ asset filePath (
+ doc = """An asset path attribute that points to a file on disk.
+ For each supported file format, a separate FieldAsset
+ subclass is required.
+
+ This attribute's value can be animated over time, as most
+ volume asset formats represent just a single timeSample of
+ a volume. However, it does not, at this time, support
+ any pattern substitutions like \"$F\". """
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token vectorDataRoleHint = "None" (
+ allowedTokens = ["None", "Point", "Normal", "Vector", "Color"]
+ doc = """Optional token which is used to indicate the role of a vector
+ valued field. This can drive the data type in which fields
+ are made available in a renderer or whether the vector values
+ are to be transformed."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+class OpenVDBAsset "OpenVDBAsset" (
+ doc = """OpenVDB field primitive. The FieldAsset filePath attribute must
+ specify a file in the OpenVDB format on disk."""
+)
+{
+ token fieldClass (
+ allowedTokens = ["levelSet", "fogVolume", "staggered", "unknown"]
+ doc = """Optional token which can be used to indicate the class of
+ an individual grid. This is a mapping to openvdb::GridClass
+ where the values are GRID_LEVEL_SET, GRID_FOG_VOLUME,
+ GRID_STAGGERED, and GRID_UNKNOWN."""
+ )
+ token fieldDataType (
+ allowedTokens = ["half", "float", "double", "int", "uint", "int64", "half2", "float2", "double2", "int2", "half3", "float3", "double3", "int3", "matrix3d", "matrix4d", "quatd", "bool", "mask", "string"]
+ doc = """Token which is used to indicate the data type of an
+ individual field. Authors use this to tell consumers more
+ about the field without opening the file on disk. The list of
+ allowed tokens reflects the available choices for OpenVDB
+ volumes."""
+ )
+ int fieldIndex (
+ doc = """A file can contain multiple fields with the same
+ name. This optional attribute is an index used to
+ disambiguate between these multiple fields with the same
+ name."""
+ )
+ token fieldName (
+ doc = """Name of an individual field within the file specified by
+ the filePath attribute."""
+ )
+ asset filePath (
+ doc = """An asset path attribute that points to a file on disk.
+ For each supported file format, a separate FieldAsset
+ subclass is required.
+
+ This attribute's value can be animated over time, as most
+ volume asset formats represent just a single timeSample of
+ a volume. However, it does not, at this time, support
+ any pattern substitutions like \"$F\". """
+ )
+ rel proxyPrim (
+ doc = '''The proxyPrim relationship allows us to link a
+ prim whose purpose is "render" to its (single target)
+ purpose="proxy" prim. This is entirely optional, but can be
+ useful in several scenarios:
+
+ - In a pipeline that does pruning (for complexity management)
+ by deactivating prims composed from asset references, when we
+ deactivate a purpose="render" prim, we will be able to discover
+ and additionally deactivate its associated purpose="proxy" prim,
+ so that preview renders reflect the pruning accurately.
+
+ - DCC importers may be able to make more aggressive optimizations
+ for interactive processing and display if they can discover the proxy
+ for a given render prim.
+
+ - With a little more work, a Hydra-based application will be able
+ to map a picked proxy prim back to its render geometry for selection.
+
+ \\note It is only valid to author the proxyPrim relationship on
+ prims whose purpose is "render".'''
+ )
+ uniform token purpose = "default" (
+ allowedTokens = ["default", "render", "proxy", "guide"]
+ doc = """Purpose is a classification of geometry into categories that
+ can each be independently included or excluded from traversals of prims
+ on a stage, such as rendering or bounding-box computation traversals.
+
+ See for more detail about how
+ purpose is computed and used."""
+ )
+ token vectorDataRoleHint = "None" (
+ allowedTokens = ["None", "Point", "Normal", "Vector", "Color"]
+ doc = """Optional token which is used to indicate the role of a vector
+ valued field. This can drive the data type in which fields
+ are made available in a renderer or whether the vector values
+ are to be transformed."""
+ )
+ token visibility = "inherited" (
+ allowedTokens = ["inherited", "invisible"]
+ doc = '''Visibility is meant to be the simplest form of "pruning"
+ visibility that is supported by most DCC apps. Visibility is
+ animatable, allowing a sub-tree of geometry to be present for some
+ segment of a shot, and absent from others; unlike the action of
+ deactivating geometry prims, invisible geometry is still
+ available for inspection, for positioning, for defining volumes, etc.'''
+ )
+ uniform token[] xformOpOrder (
+ doc = """Encodes the sequence of transformation operations in the
+ order in which they should be pushed onto a transform stack while
+ visiting a UsdStage's prims in a graph traversal that will effect
+ the desired positioning for this prim and its descendant prims.
+
+ You should rarely, if ever, need to manipulate this attribute directly.
+ It is managed by the AddXformOp(), SetResetXformStack(), and
+ SetXformOpOrder(), and consulted by GetOrderedXformOps() and
+ GetLocalTransformation()."""
+ )
+}
+
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+ "Plugins": [
+ {
+ "Info": {
+ "Types": {
+ "UsdVolField3DAsset": {
+ "alias": {
+ "UsdSchemaBase": "Field3DAsset"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdVolFieldAsset"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdVolFieldAsset": {
+ "alias": {
+ "UsdSchemaBase": "FieldAsset"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdVolFieldBase"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdVolFieldBase": {
+ "alias": {
+ "UsdSchemaBase": "FieldBase"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomXformable"
+ ],
+ "schemaKind": "abstractTyped"
+ },
+ "UsdVolOpenVDBAsset": {
+ "alias": {
+ "UsdSchemaBase": "OpenVDBAsset"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdVolFieldAsset"
+ ],
+ "schemaKind": "concreteTyped"
+ },
+ "UsdVolVolume": {
+ "alias": {
+ "UsdSchemaBase": "Volume"
+ },
+ "autoGenerated": true,
+ "bases": [
+ "UsdGeomGprim"
+ ],
+ "schemaKind": "concreteTyped"
+ }
+ }
+ },
+ "LibraryPath": "",
+ "Name": "usdVol",
+ "ResourcePath": "resources",
+ "Root": "..",
+ "Type": "library"
+ }
+ ]
+}
+#usda 1.0
+
+(
+ subLayers = [
+ @usdGeom/schema.usda@
+ ]
+)
+
+over "GLOBAL" (
+ customData = {
+ string libraryName = "usdVol"
+ string libraryPath = "pxr/usd/usdVol"
+ dictionary libraryTokens = {
+ dictionary field = {
+ string doc = """This is the namespace prefix used to
+ specify the fields that make up a volume primitive."""
+ }
+ }
+ }
+)
+{
+}
+
+class Volume "Volume" (
+ inherits =
+ doc = """A renderable volume primitive. A volume is made up of any number
+ of FieldBase primitives bound together in this volume. Each
+ FieldBase primitive is specified as a relationship with a
+ namespace prefix of "field".
+
+ The relationship name is used by the renderer to associate
+ individual fields with the named input parameters on the volume
+ shader. Using this indirect approach to connecting fields to
+ shader parameters (rather than using the field prim's name)
+ allows a single field to be reused for different shader inputs, or
+ to be used as different shader parameters when rendering different
+ Volumes. This means that the name of the field prim is not
+ relevant to its contribution to the volume prims which refer to
+ it. Nor does the field prim's location in the scene graph have
+ any relevance, and Volumes may refer to fields anywhere in the
+ scene graph. **However**, unless Field prims need to be shared
+ by multiple Volumes, a Volume's Field prims should be located
+ under the Volume in namespace, for enhanced organization."""
+)
+{
+}
+
+class "FieldBase" (
+ inherits =
+ doc = """Base class for field primitives."""
+)
+{
+}
+
+class "FieldAsset" (
+ doc = "Base class for field primitives defined by an external file."
+ inherits =
+)
+{
+ asset filePath (
+ doc = """An asset path attribute that points to a file on disk.
+ For each supported file format, a separate FieldAsset
+ subclass is required.
+
+ This attribute's value can be animated over time, as most
+ volume asset formats represent just a single timeSample of
+ a volume. However, it does not, at this time, support
+ any pattern substitutions like \"$F\". """
+ )
+ token fieldName (
+ doc = """Name of an individual field within the file specified by
+ the filePath attribute."""
+ )
+ int fieldIndex (
+ doc = """A file can contain multiple fields with the same
+ name. This optional attribute is an index used to
+ disambiguate between these multiple fields with the same
+ name."""
+ )
+ token fieldDataType (
+ doc = """Token which is used to indicate the data type of an
+ individual field. Authors use this to tell consumers more
+ about the field without opening the file on disk. The list of
+ allowed tokens is specified with the specific asset type.
+ A missing value is considered an error."""
+ )
+ token vectorDataRoleHint = "None" (
+ allowedTokens = ["None", "Point", "Normal", "Vector", "Color"]
+ doc = """Optional token which is used to indicate the role of a vector
+ valued field. This can drive the data type in which fields
+ are made available in a renderer or whether the vector values
+ are to be transformed."""
+ )
+}
+
+class Field3DAsset "Field3DAsset" (
+ doc = """Field3D field primitive. The FieldAsset filePath attribute must
+ specify a file in the Field3D format on disk."""
+ inherits =
+)
+{
+ token fieldDataType (
+ allowedTokens = ["half", "float", "double",
+ "half3", "float3", "double3"]
+ doc = """Token which is used to indicate the data type of an
+ individual field. Authors use this to tell consumers more
+ about the field without opening the file on disk. The list of
+ allowed tokens reflects the available choices for Field3d
+ volumes."""
+ )
+ token fieldPurpose (
+ doc = """Optional token which can be used to indicate the purpose or
+ grouping of an individual field. Clients which consume Field3D
+ files should treat this as the Field3D field \\em name."""
+ )
+}
+
+class OpenVDBAsset "OpenVDBAsset" (
+ doc = """OpenVDB field primitive. The FieldAsset filePath attribute must
+ specify a file in the OpenVDB format on disk."""
+ inherits =
+)
+{
+ token fieldDataType (
+ allowedTokens = ["half", "float", "double", "int", "uint", "int64",
+ "half2", "float2", "double2", "int2",
+ "half3", "float3", "double3", "int3",
+ "matrix3d", "matrix4d", "quatd",
+ "bool", "mask", "string"]
+ doc = """Token which is used to indicate the data type of an
+ individual field. Authors use this to tell consumers more
+ about the field without opening the file on disk. The list of
+ allowed tokens reflects the available choices for OpenVDB
+ volumes."""
+ )
+ token fieldClass (
+ allowedTokens = ["levelSet", "fogVolume", "staggered", "unknown"]
+ doc = """Optional token which can be used to indicate the class of
+ an individual grid. This is a mapping to openvdb::GridClass
+ where the values are GRID_LEVEL_SET, GRID_FOG_VOLUME,
+ GRID_STAGGERED, and GRID_UNKNOWN."""
+ )
+}
+
diff --git a/web/threeVisualizer/assets/emHdBindings-qRmJXJBb.js b/web/threeVisualizer/assets/emHdBindings-qRmJXJBb.js
new file mode 100644
index 0000000..86777e8
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings-qRmJXJBb.js
@@ -0,0 +1 @@
+const s="/extensions/ComfyUI-Rodin/threeVisualizer/assets/emHdBindings-BNKz2vMm.wasm";export{s as default};
diff --git a/web/threeVisualizer/assets/emHdBindings.worker-CyHENA1f.js b/web/threeVisualizer/assets/emHdBindings.worker-CyHENA1f.js
new file mode 100644
index 0000000..59823b4
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings.worker-CyHENA1f.js
@@ -0,0 +1 @@
+const Z="data:text/javascript;base64,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";export{Z as default};
diff --git a/web/threeVisualizer/assets/emHdBindings.worker-DUEm-236.js b/web/threeVisualizer/assets/emHdBindings.worker-DUEm-236.js
new file mode 100644
index 0000000..16fecd4
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings.worker-DUEm-236.js
@@ -0,0 +1,2 @@
+(function(){"use strict";var a={},d=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";if(d){var l=require("worker_threads"),c=l.parentPort;c.on("message",e=>onmessage({data:e}));var m=require("fs");Object.assign(global,{self:global,require,Module:a,location:{href:__filename},Worker:l.Worker,importScripts:e=>(0,eval)(m.readFileSync(e,"utf8")+"//# sourceURL="+e),postMessage:e=>c.postMessage(e),performance:global.performance||{now:Date.now}})}var o=!1;function u(){var e=Array.prototype.slice.call(arguments).join(" ");if(d){m.writeSync(2,e+`
+`);return}console.error(e)}function _(){var e=Array.prototype.slice.call(arguments).join(" ");postMessage({cmd:"alert",text:e,threadId:a._pthread_self()})}var f=u;self.alert=_,a.instantiateWasm=(e,s)=>{var r=a.wasmModule;a.wasmModule=null;var t=new WebAssembly.Instance(r,e);return s(t)},self.onunhandledrejection=e=>{throw e.reason||e};function i(e){try{if(e.data.cmd==="load"){let r=[];self.onmessage=t=>r.push(t),self.startWorker=t=>{a=t,postMessage({cmd:"loaded"});for(let n of r)i(n);self.onmessage=i},a.wasmModule=e.data.wasmModule;for(const t of e.data.handlers)a[t]=(...n)=>{postMessage({cmd:"callHandler",handler:t,args:n})};if(a.wasmMemory=e.data.wasmMemory,a.buffer=a.wasmMemory.buffer,a.ENVIRONMENT_IS_PTHREAD=!0,typeof e.data.urlOrBlob=="string")importScripts(e.data.urlOrBlob);else{var s=URL.createObjectURL(e.data.urlOrBlob);importScripts(s),URL.revokeObjectURL(s)}getUsdModule(a)}else if(e.data.cmd==="run"){a.__emscripten_thread_init(e.data.pthread_ptr,0,0,1),a.__emscripten_thread_mailbox_await(e.data.pthread_ptr),a.establishStackSpace(),a.PThread.receiveObjectTransfer(e.data),a.PThread.threadInitTLS(),o||(a.__embind_initialize_bindings(),o=!0);try{a.invokeEntryPoint(e.data.start_routine,e.data.arg)}catch(r){if(r!="unwind")throw r}}else e.data.cmd==="cancel"?a._pthread_self()&&a.__emscripten_thread_exit(-1):e.data.target==="setimmediate"||(e.data.cmd==="checkMailbox"?o&&a.checkMailbox():e.data.cmd&&(f(`worker.js received unknown command ${e.data.cmd}`),f(e.data)))}catch(r){throw a.__emscripten_thread_crashed&&a.__emscripten_thread_crashed(),r}}self.onmessage=i})();
diff --git a/web/threeVisualizer/assets/emHdBindings.worker-t1x5VIsg.js b/web/threeVisualizer/assets/emHdBindings.worker-t1x5VIsg.js
new file mode 100644
index 0000000..fe74632
--- /dev/null
+++ b/web/threeVisualizer/assets/emHdBindings.worker-t1x5VIsg.js
@@ -0,0 +1 @@
+const e="/extensions/ComfyUI-Rodin/threeVisualizer/assets/emHdBindings.worker-DUEm-236.js";export{e as default};
diff --git a/web/threeVisualizer/assets/index-CCfjSMW2.js b/web/threeVisualizer/assets/index-CCfjSMW2.js
new file mode 100644
index 0000000..40f8cde
--- /dev/null
+++ b/web/threeVisualizer/assets/index-CCfjSMW2.js
@@ -0,0 +1,4254 @@
+var KP=Object.defineProperty;var ZP=(n,e,t)=>e in n?KP(n,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):n[e]=t;var QP=(n,e)=>()=>(e||n((e={exports:{}}).exports,e),e.exports);var Ve=(n,e,t)=>ZP(n,typeof e!="symbol"?e+"":e,t);var r8=QP((_T,xg)=>{(function(){const e=document.createElement("link").relList;if(e&&e.supports&&e.supports("modulepreload"))return;for(const r of document.querySelectorAll('link[rel="modulepreload"]'))i(r);new MutationObserver(r=>{for(const s of r)if(s.type==="childList")for(const a of s.addedNodes)a.tagName==="LINK"&&a.rel==="modulepreload"&&i(a)}).observe(document,{childList:!0,subtree:!0});function t(r){const s={};return r.integrity&&(s.integrity=r.integrity),r.referrerPolicy&&(s.referrerPolicy=r.referrerPolicy),r.crossOrigin==="use-credentials"?s.credentials="include":r.crossOrigin==="anonymous"?s.credentials="omit":s.credentials="same-origin",s}function i(r){if(r.ep)return;r.ep=!0;const s=t(r);fetch(r.href,s)}})();var YS={exports:{}},Sh={},$S={exports:{}},Dt={};/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Bc=Symbol.for("react.element"),JP=Symbol.for("react.portal"),e2=Symbol.for("react.fragment"),t2=Symbol.for("react.strict_mode"),n2=Symbol.for("react.profiler"),i2=Symbol.for("react.provider"),r2=Symbol.for("react.context"),s2=Symbol.for("react.forward_ref"),a2=Symbol.for("react.suspense"),o2=Symbol.for("react.memo"),l2=Symbol.for("react.lazy"),Vb=Symbol.iterator;function c2(n){return n===null||typeof n!="object"?null:(n=Vb&&n[Vb]||n["@@iterator"],typeof n=="function"?n:null)}var qS={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},KS=Object.assign,ZS={};function al(n,e,t){this.props=n,this.context=e,this.refs=ZS,this.updater=t||qS}al.prototype.isReactComponent={};al.prototype.setState=function(n,e){if(typeof n!="object"&&typeof n!="function"&&n!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,n,e,"setState")};al.prototype.forceUpdate=function(n){this.updater.enqueueForceUpdate(this,n,"forceUpdate")};function QS(){}QS.prototype=al.prototype;function wg(n,e,t){this.props=n,this.context=e,this.refs=ZS,this.updater=t||qS}var Sg=wg.prototype=new QS;Sg.constructor=wg;KS(Sg,al.prototype);Sg.isPureReactComponent=!0;var Wb=Array.isArray,JS=Object.prototype.hasOwnProperty,Mg={current:null},eM={key:!0,ref:!0,__self:!0,__source:!0};function tM(n,e,t){var i,r={},s=null,a=null;if(e!=null)for(i in e.ref!==void 0&&(a=e.ref),e.key!==void 0&&(s=""+e.key),e)JS.call(e,i)&&!eM.hasOwnProperty(i)&&(r[i]=e[i]);var l=arguments.length-2;if(l===1)r.children=t;else if(1>>1,Pe=Y[Ae];if(0>>1;Aer(ge,_e))cer(Me,ge)?(Y[Ae]=Me,Y[ce]=_e,Ae=ce):(Y[Ae]=ge,Y[ae]=_e,Ae=ae);else if(cer(Me,_e))Y[Ae]=Me,Y[ce]=_e,Ae=ce;else break e}}return pe}function r(Y,pe){var _e=Y.sortIndex-pe.sortIndex;return _e!==0?_e:Y.id-pe.id}if(typeof performance=="object"&&typeof performance.now=="function"){var s=performance;n.unstable_now=function(){return s.now()}}else{var a=Date,l=a.now();n.unstable_now=function(){return a.now()-l}}var d=[],h=[],m=1,u=null,g=3,v=!1,w=!1,T=!1,M=typeof setTimeout=="function"?setTimeout:null,b=typeof clearTimeout=="function"?clearTimeout:null,A=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function E(Y){for(var pe=t(h);pe!==null;){if(pe.callback===null)i(h);else if(pe.startTime<=Y)i(h),pe.sortIndex=pe.expirationTime,e(d,pe);else break;pe=t(h)}}function P(Y){if(T=!1,E(Y),!w)if(t(d)!==null)w=!0,$(G);else{var pe=t(h);pe!==null&&ue(P,pe.startTime-Y)}}function G(Y,pe){w=!1,T&&(T=!1,b(F),F=-1),v=!0;var _e=g;try{for(E(pe),u=t(d);u!==null&&(!(u.expirationTime>pe)||Y&&!V());){var Ae=u.callback;if(typeof Ae=="function"){u.callback=null,g=u.priorityLevel;var Pe=Ae(u.expirationTime<=pe);pe=n.unstable_now(),typeof Pe=="function"?u.callback=Pe:u===t(d)&&i(d),E(pe)}else i(d);u=t(d)}if(u!==null)var Ue=!0;else{var ae=t(h);ae!==null&&ue(P,ae.startTime-pe),Ue=!1}return Ue}finally{u=null,g=_e,v=!1}}var O=!1,B=null,F=-1,D=5,L=-1;function V(){return!(n.unstable_now()-LY||125Ae?(Y.sortIndex=_e,e(h,Y),t(d)===null&&Y===t(h)&&(T?(b(F),F=-1):T=!0,ue(P,_e-Ae))):(Y.sortIndex=Pe,e(d,Y),w||v||(w=!0,$(G))),Y},n.unstable_shouldYield=V,n.unstable_wrapCallback=function(Y){var pe=g;return function(){var _e=g;g=pe;try{return Y.apply(this,arguments)}finally{g=_e}}}})(aM);sM.exports=aM;var b2=sM.exports;/**
+ * @license React
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var x2=Xn,$i=b2;function Be(n){for(var e="https://reactjs.org/docs/error-decoder.html?invariant="+n,t=1;t"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),Np=Object.prototype.hasOwnProperty,w2=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,Xb={},Yb={};function S2(n){return Np.call(Yb,n)?!0:Np.call(Xb,n)?!1:w2.test(n)?Yb[n]=!0:(Xb[n]=!0,!1)}function M2(n,e,t,i){if(t!==null&&t.type===0)return!1;switch(typeof e){case"function":case"symbol":return!0;case"boolean":return i?!1:t!==null?!t.acceptsBooleans:(n=n.toLowerCase().slice(0,5),n!=="data-"&&n!=="aria-");default:return!1}}function E2(n,e,t,i){if(e===null||typeof e>"u"||M2(n,e,t,i))return!0;if(i)return!1;if(t!==null)switch(t.type){case 3:return!e;case 4:return e===!1;case 5:return isNaN(e);case 6:return isNaN(e)||1>e}return!1}function Ai(n,e,t,i,r,s,a){this.acceptsBooleans=e===2||e===3||e===4,this.attributeName=i,this.attributeNamespace=r,this.mustUseProperty=t,this.propertyName=n,this.type=e,this.sanitizeURL=s,this.removeEmptyString=a}var ai={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(n){ai[n]=new Ai(n,0,!1,n,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(n){var e=n[0];ai[e]=new Ai(e,1,!1,n[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(n){ai[n]=new Ai(n,2,!1,n.toLowerCase(),null,!1,!1)});["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(n){ai[n]=new Ai(n,2,!1,n,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(n){ai[n]=new Ai(n,3,!1,n.toLowerCase(),null,!1,!1)});["checked","multiple","muted","selected"].forEach(function(n){ai[n]=new Ai(n,3,!0,n,null,!1,!1)});["capture","download"].forEach(function(n){ai[n]=new Ai(n,4,!1,n,null,!1,!1)});["cols","rows","size","span"].forEach(function(n){ai[n]=new Ai(n,6,!1,n,null,!1,!1)});["rowSpan","start"].forEach(function(n){ai[n]=new Ai(n,5,!1,n.toLowerCase(),null,!1,!1)});var Tg=/[\-:]([a-z])/g;function Ag(n){return n[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(n){var e=n.replace(Tg,Ag);ai[e]=new Ai(e,1,!1,n,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(n){var e=n.replace(Tg,Ag);ai[e]=new Ai(e,1,!1,n,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(n){var e=n.replace(Tg,Ag);ai[e]=new Ai(e,1,!1,n,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(n){ai[n]=new Ai(n,1,!1,n.toLowerCase(),null,!1,!1)});ai.xlinkHref=new Ai("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(n){ai[n]=new Ai(n,1,!1,n.toLowerCase(),null,!0,!0)});function Cg(n,e,t,i){var r=ai.hasOwnProperty(e)?ai[e]:null;(r!==null?r.type!==0:i||!(2l||r[a]!==s[l]){var d=`
+`+r[a].replace(" at new "," at ");return n.displayName&&d.includes("")&&(d=d.replace("",n.displayName)),d}while(1<=a&&0<=l);break}}}finally{wf=!1,Error.prepareStackTrace=t}return(n=n?n.displayName||n.name:"")?jl(n):""}function T2(n){switch(n.tag){case 5:return jl(n.type);case 16:return jl("Lazy");case 13:return jl("Suspense");case 19:return jl("SuspenseList");case 0:case 2:case 15:return n=Sf(n.type,!1),n;case 11:return n=Sf(n.type.render,!1),n;case 1:return n=Sf(n.type,!0),n;default:return""}}function Gp(n){if(n==null)return null;if(typeof n=="function")return n.displayName||n.name||null;if(typeof n=="string")return n;switch(n){case po:return"Fragment";case fo:return"Portal";case Bp:return"Profiler";case Rg:return"StrictMode";case zp:return"Suspense";case Hp:return"SuspenseList"}if(typeof n=="object")switch(n.$$typeof){case cM:return(n.displayName||"Context")+".Consumer";case lM:return(n._context.displayName||"Context")+".Provider";case Pg:var e=n.render;return n=n.displayName,n||(n=e.displayName||e.name||"",n=n!==""?"ForwardRef("+n+")":"ForwardRef"),n;case Lg:return e=n.displayName||null,e!==null?e:Gp(n.type)||"Memo";case Ds:e=n._payload,n=n._init;try{return Gp(n(e))}catch{}}return null}function A2(n){var e=n.type;switch(n.tag){case 24:return"Cache";case 9:return(e.displayName||"Context")+".Consumer";case 10:return(e._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return n=e.render,n=n.displayName||n.name||"",e.displayName||(n!==""?"ForwardRef("+n+")":"ForwardRef");case 7:return"Fragment";case 5:return e;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return Gp(e);case 8:return e===Rg?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e}return null}function qs(n){switch(typeof n){case"boolean":case"number":case"string":case"undefined":return n;case"object":return n;default:return""}}function dM(n){var e=n.type;return(n=n.nodeName)&&n.toLowerCase()==="input"&&(e==="checkbox"||e==="radio")}function C2(n){var e=dM(n)?"checked":"value",t=Object.getOwnPropertyDescriptor(n.constructor.prototype,e),i=""+n[e];if(!n.hasOwnProperty(e)&&typeof t<"u"&&typeof t.get=="function"&&typeof t.set=="function"){var r=t.get,s=t.set;return Object.defineProperty(n,e,{configurable:!0,get:function(){return r.call(this)},set:function(a){i=""+a,s.call(this,a)}}),Object.defineProperty(n,e,{enumerable:t.enumerable}),{getValue:function(){return i},setValue:function(a){i=""+a},stopTracking:function(){n._valueTracker=null,delete n[e]}}}}function vu(n){n._valueTracker||(n._valueTracker=C2(n))}function hM(n){if(!n)return!1;var e=n._valueTracker;if(!e)return!0;var t=e.getValue(),i="";return n&&(i=dM(n)?n.checked?"true":"false":n.value),n=i,n!==t?(e.setValue(n),!0):!1}function Bd(n){if(n=n||(typeof document<"u"?document:void 0),typeof n>"u")return null;try{return n.activeElement||n.body}catch{return n.body}}function Vp(n,e){var t=e.checked;return Cn({},e,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:t??n._wrapperState.initialChecked})}function qb(n,e){var t=e.defaultValue==null?"":e.defaultValue,i=e.checked!=null?e.checked:e.defaultChecked;t=qs(e.value!=null?e.value:t),n._wrapperState={initialChecked:i,initialValue:t,controlled:e.type==="checkbox"||e.type==="radio"?e.checked!=null:e.value!=null}}function fM(n,e){e=e.checked,e!=null&&Cg(n,"checked",e,!1)}function Wp(n,e){fM(n,e);var t=qs(e.value),i=e.type;if(t!=null)i==="number"?(t===0&&n.value===""||n.value!=t)&&(n.value=""+t):n.value!==""+t&&(n.value=""+t);else if(i==="submit"||i==="reset"){n.removeAttribute("value");return}e.hasOwnProperty("value")?jp(n,e.type,t):e.hasOwnProperty("defaultValue")&&jp(n,e.type,qs(e.defaultValue)),e.checked==null&&e.defaultChecked!=null&&(n.defaultChecked=!!e.defaultChecked)}function Kb(n,e,t){if(e.hasOwnProperty("value")||e.hasOwnProperty("defaultValue")){var i=e.type;if(!(i!=="submit"&&i!=="reset"||e.value!==void 0&&e.value!==null))return;e=""+n._wrapperState.initialValue,t||e===n.value||(n.value=e),n.defaultValue=e}t=n.name,t!==""&&(n.name=""),n.defaultChecked=!!n._wrapperState.initialChecked,t!==""&&(n.name=t)}function jp(n,e,t){(e!=="number"||Bd(n.ownerDocument)!==n)&&(t==null?n.defaultValue=""+n._wrapperState.initialValue:n.defaultValue!==""+t&&(n.defaultValue=""+t))}var Xl=Array.isArray;function Io(n,e,t,i){if(n=n.options,e){e={};for(var r=0;r"+e.valueOf().toString()+"",e=yu.firstChild;n.firstChild;)n.removeChild(n.firstChild);for(;e.firstChild;)n.appendChild(e.firstChild)}});function pc(n,e){if(e){var t=n.firstChild;if(t&&t===n.lastChild&&t.nodeType===3){t.nodeValue=e;return}}n.textContent=e}var ec={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},R2=["Webkit","ms","Moz","O"];Object.keys(ec).forEach(function(n){R2.forEach(function(e){e=e+n.charAt(0).toUpperCase()+n.substring(1),ec[e]=ec[n]})});function _M(n,e,t){return e==null||typeof e=="boolean"||e===""?"":t||typeof e!="number"||e===0||ec.hasOwnProperty(n)&&ec[n]?(""+e).trim():e+"px"}function vM(n,e){n=n.style;for(var t in e)if(e.hasOwnProperty(t)){var i=t.indexOf("--")===0,r=_M(t,e[t],i);t==="float"&&(t="cssFloat"),i?n.setProperty(t,r):n[t]=r}}var P2=Cn({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function $p(n,e){if(e){if(P2[n]&&(e.children!=null||e.dangerouslySetInnerHTML!=null))throw Error(Be(137,n));if(e.dangerouslySetInnerHTML!=null){if(e.children!=null)throw Error(Be(60));if(typeof e.dangerouslySetInnerHTML!="object"||!("__html"in e.dangerouslySetInnerHTML))throw Error(Be(61))}if(e.style!=null&&typeof e.style!="object")throw Error(Be(62))}}function qp(n,e){if(n.indexOf("-")===-1)return typeof e.is=="string";switch(n){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var Kp=null;function Ig(n){return n=n.target||n.srcElement||window,n.correspondingUseElement&&(n=n.correspondingUseElement),n.nodeType===3?n.parentNode:n}var Zp=null,Do=null,ko=null;function Jb(n){if(n=Gc(n)){if(typeof Zp!="function")throw Error(Be(280));var e=n.stateNode;e&&(e=Ch(e),Zp(n.stateNode,n.type,e))}}function yM(n){Do?ko?ko.push(n):ko=[n]:Do=n}function bM(){if(Do){var n=Do,e=ko;if(ko=Do=null,Jb(n),e)for(n=0;n>>=0,n===0?32:31-(H2(n)/G2|0)|0}var bu=64,xu=4194304;function Yl(n){switch(n&-n){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return n&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return n&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return n}}function Vd(n,e){var t=n.pendingLanes;if(t===0)return 0;var i=0,r=n.suspendedLanes,s=n.pingedLanes,a=t&268435455;if(a!==0){var l=a&~r;l!==0?i=Yl(l):(s&=a,s!==0&&(i=Yl(s)))}else a=t&~r,a!==0?i=Yl(a):s!==0&&(i=Yl(s));if(i===0)return 0;if(e!==0&&e!==i&&!(e&r)&&(r=i&-i,s=e&-e,r>=s||r===16&&(s&4194240)!==0))return e;if(i&4&&(i|=t&16),e=n.entangledLanes,e!==0)for(n=n.entanglements,e&=i;0t;t++)e.push(n);return e}function zc(n,e,t){n.pendingLanes|=e,e!==536870912&&(n.suspendedLanes=0,n.pingedLanes=0),n=n.eventTimes,e=31-Tr(e),n[e]=t}function X2(n,e){var t=n.pendingLanes&~e;n.pendingLanes=e,n.suspendedLanes=0,n.pingedLanes=0,n.expiredLanes&=e,n.mutableReadLanes&=e,n.entangledLanes&=e,e=n.entanglements;var i=n.eventTimes;for(n=n.expirationTimes;0=nc),lx=" ",cx=!1;function zM(n,e){switch(n){case"keyup":return bL.indexOf(e.keyCode)!==-1;case"keydown":return e.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function HM(n){return n=n.detail,typeof n=="object"&&"data"in n?n.data:null}var mo=!1;function wL(n,e){switch(n){case"compositionend":return HM(e);case"keypress":return e.which!==32?null:(cx=!0,lx);case"textInput":return n=e.data,n===lx&&cx?null:n;default:return null}}function SL(n,e){if(mo)return n==="compositionend"||!zg&&zM(n,e)?(n=NM(),bd=Og=Os=null,mo=!1,n):null;switch(n){case"paste":return null;case"keypress":if(!(e.ctrlKey||e.altKey||e.metaKey)||e.ctrlKey&&e.altKey){if(e.char&&1=e)return{node:t,offset:e-n};n=i}e:{for(;t;){if(t.nextSibling){t=t.nextSibling;break e}t=t.parentNode}t=void 0}t=fx(t)}}function jM(n,e){return n&&e?n===e?!0:n&&n.nodeType===3?!1:e&&e.nodeType===3?jM(n,e.parentNode):"contains"in n?n.contains(e):n.compareDocumentPosition?!!(n.compareDocumentPosition(e)&16):!1:!1}function XM(){for(var n=window,e=Bd();e instanceof n.HTMLIFrameElement;){try{var t=typeof e.contentWindow.location.href=="string"}catch{t=!1}if(t)n=e.contentWindow;else break;e=Bd(n.document)}return e}function Hg(n){var e=n&&n.nodeName&&n.nodeName.toLowerCase();return e&&(e==="input"&&(n.type==="text"||n.type==="search"||n.type==="tel"||n.type==="url"||n.type==="password")||e==="textarea"||n.contentEditable==="true")}function IL(n){var e=XM(),t=n.focusedElem,i=n.selectionRange;if(e!==t&&t&&t.ownerDocument&&jM(t.ownerDocument.documentElement,t)){if(i!==null&&Hg(t)){if(e=i.start,n=i.end,n===void 0&&(n=e),"selectionStart"in t)t.selectionStart=e,t.selectionEnd=Math.min(n,t.value.length);else if(n=(e=t.ownerDocument||document)&&e.defaultView||window,n.getSelection){n=n.getSelection();var r=t.textContent.length,s=Math.min(i.start,r);i=i.end===void 0?s:Math.min(i.end,r),!n.extend&&s>i&&(r=i,i=s,s=r),r=px(t,s);var a=px(t,i);r&&a&&(n.rangeCount!==1||n.anchorNode!==r.node||n.anchorOffset!==r.offset||n.focusNode!==a.node||n.focusOffset!==a.offset)&&(e=e.createRange(),e.setStart(r.node,r.offset),n.removeAllRanges(),s>i?(n.addRange(e),n.extend(a.node,a.offset)):(e.setEnd(a.node,a.offset),n.addRange(e)))}}for(e=[],n=t;n=n.parentNode;)n.nodeType===1&&e.push({element:n,left:n.scrollLeft,top:n.scrollTop});for(typeof t.focus=="function"&&t.focus(),t=0;t=document.documentMode,go=null,im=null,rc=null,rm=!1;function mx(n,e,t){var i=t.window===t?t.document:t.nodeType===9?t:t.ownerDocument;rm||go==null||go!==Bd(i)||(i=go,"selectionStart"in i&&Hg(i)?i={start:i.selectionStart,end:i.selectionEnd}:(i=(i.ownerDocument&&i.ownerDocument.defaultView||window).getSelection(),i={anchorNode:i.anchorNode,anchorOffset:i.anchorOffset,focusNode:i.focusNode,focusOffset:i.focusOffset}),rc&&bc(rc,i)||(rc=i,i=Xd(im,"onSelect"),0yo||(n.current=um[yo],um[yo]=null,yo--)}function cn(n,e){yo++,um[yo]=n.current,n.current=e}var Ks={},vi=ea(Ks),Ui=ea(!1),Ca=Ks;function Xo(n,e){var t=n.type.contextTypes;if(!t)return Ks;var i=n.stateNode;if(i&&i.__reactInternalMemoizedUnmaskedChildContext===e)return i.__reactInternalMemoizedMaskedChildContext;var r={},s;for(s in t)r[s]=e[s];return i&&(n=n.stateNode,n.__reactInternalMemoizedUnmaskedChildContext=e,n.__reactInternalMemoizedMaskedChildContext=r),r}function Oi(n){return n=n.childContextTypes,n!=null}function $d(){gn(Ui),gn(vi)}function wx(n,e,t){if(vi.current!==Ks)throw Error(Be(168));cn(vi,e),cn(Ui,t)}function t1(n,e,t){var i=n.stateNode;if(e=e.childContextTypes,typeof i.getChildContext!="function")return t;i=i.getChildContext();for(var r in i)if(!(r in e))throw Error(Be(108,A2(n)||"Unknown",r));return Cn({},t,i)}function qd(n){return n=(n=n.stateNode)&&n.__reactInternalMemoizedMergedChildContext||Ks,Ca=vi.current,cn(vi,n),cn(Ui,Ui.current),!0}function Sx(n,e,t){var i=n.stateNode;if(!i)throw Error(Be(169));t?(n=t1(n,e,Ca),i.__reactInternalMemoizedMergedChildContext=n,gn(Ui),gn(vi),cn(vi,n)):gn(Ui),cn(Ui,t)}var rs=null,Rh=!1,Of=!1;function n1(n){rs===null?rs=[n]:rs.push(n)}function WL(n){Rh=!0,n1(n)}function ta(){if(!Of&&rs!==null){Of=!0;var n=0,e=rn;try{var t=rs;for(rn=1;n>=a,r-=a,os=1<<32-Tr(e)+r|t<F?(D=B,B=null):D=B.sibling;var L=g(b,B,E[F],P);if(L===null){B===null&&(B=D);break}n&&B&&L.alternate===null&&e(b,B),A=s(L,A,F),O===null?G=L:O.sibling=L,O=L,B=D}if(F===E.length)return t(b,B),xn&&pa(b,F),G;if(B===null){for(;FF?(D=B,B=null):D=B.sibling;var V=g(b,B,L.value,P);if(V===null){B===null&&(B=D);break}n&&B&&V.alternate===null&&e(b,B),A=s(V,A,F),O===null?G=V:O.sibling=V,O=V,B=D}if(L.done)return t(b,B),xn&&pa(b,F),G;if(B===null){for(;!L.done;F++,L=E.next())L=u(b,L.value,P),L!==null&&(A=s(L,A,F),O===null?G=L:O.sibling=L,O=L);return xn&&pa(b,F),G}for(B=i(b,B);!L.done;F++,L=E.next())L=v(B,b,F,L.value,P),L!==null&&(n&&L.alternate!==null&&B.delete(L.key===null?F:L.key),A=s(L,A,F),O===null?G=L:O.sibling=L,O=L);return n&&B.forEach(function(ie){return e(b,ie)}),xn&&pa(b,F),G}function M(b,A,E,P){if(typeof E=="object"&&E!==null&&E.type===po&&E.key===null&&(E=E.props.children),typeof E=="object"&&E!==null){switch(E.$$typeof){case _u:e:{for(var G=E.key,O=A;O!==null;){if(O.key===G){if(G=E.type,G===po){if(O.tag===7){t(b,O.sibling),A=r(O,E.props.children),A.return=b,b=A;break e}}else if(O.elementType===G||typeof G=="object"&&G!==null&&G.$$typeof===Ds&&Tx(G)===O.type){t(b,O.sibling),A=r(O,E.props),A.ref=Ll(b,O,E),A.return=b,b=A;break e}t(b,O);break}else e(b,O);O=O.sibling}E.type===po?(A=Ta(E.props.children,b.mode,P,E.key),A.return=b,b=A):(P=Cd(E.type,E.key,E.props,null,b.mode,P),P.ref=Ll(b,A,E),P.return=b,b=P)}return a(b);case fo:e:{for(O=E.key;A!==null;){if(A.key===O)if(A.tag===4&&A.stateNode.containerInfo===E.containerInfo&&A.stateNode.implementation===E.implementation){t(b,A.sibling),A=r(A,E.children||[]),A.return=b,b=A;break e}else{t(b,A);break}else e(b,A);A=A.sibling}A=jf(E,b.mode,P),A.return=b,b=A}return a(b);case Ds:return O=E._init,M(b,A,O(E._payload),P)}if(Xl(E))return w(b,A,E,P);if(Tl(E))return T(b,A,E,P);Cu(b,E)}return typeof E=="string"&&E!==""||typeof E=="number"?(E=""+E,A!==null&&A.tag===6?(t(b,A.sibling),A=r(A,E),A.return=b,b=A):(t(b,A),A=Wf(E,b.mode,P),A.return=b,b=A),a(b)):t(b,A)}return M}var $o=a1(!0),o1=a1(!1),Qd=ea(null),Jd=null,wo=null,jg=null;function Xg(){jg=wo=Jd=null}function Yg(n){var e=Qd.current;gn(Qd),n._currentValue=e}function fm(n,e,t){for(;n!==null;){var i=n.alternate;if((n.childLanes&e)!==e?(n.childLanes|=e,i!==null&&(i.childLanes|=e)):i!==null&&(i.childLanes&e)!==e&&(i.childLanes|=e),n===t)break;n=n.return}}function Uo(n,e){Jd=n,jg=wo=null,n=n.dependencies,n!==null&&n.firstContext!==null&&(n.lanes&e&&(Fi=!0),n.firstContext=null)}function dr(n){var e=n._currentValue;if(jg!==n)if(n={context:n,memoizedValue:e,next:null},wo===null){if(Jd===null)throw Error(Be(308));wo=n,Jd.dependencies={lanes:0,firstContext:n}}else wo=wo.next=n;return e}var Sa=null;function $g(n){Sa===null?Sa=[n]:Sa.push(n)}function l1(n,e,t,i){var r=e.interleaved;return r===null?(t.next=t,$g(e)):(t.next=r.next,r.next=t),e.interleaved=t,ps(n,i)}function ps(n,e){n.lanes|=e;var t=n.alternate;for(t!==null&&(t.lanes|=e),t=n,n=n.return;n!==null;)n.childLanes|=e,t=n.alternate,t!==null&&(t.childLanes|=e),t=n,n=n.return;return t.tag===3?t.stateNode:null}var ks=!1;function qg(n){n.updateQueue={baseState:n.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function c1(n,e){n=n.updateQueue,e.updateQueue===n&&(e.updateQueue={baseState:n.baseState,firstBaseUpdate:n.firstBaseUpdate,lastBaseUpdate:n.lastBaseUpdate,shared:n.shared,effects:n.effects})}function ds(n,e){return{eventTime:n,lane:e,tag:0,payload:null,callback:null,next:null}}function Ws(n,e,t){var i=n.updateQueue;if(i===null)return null;if(i=i.shared,qt&2){var r=i.pending;return r===null?e.next=e:(e.next=r.next,r.next=e),i.pending=e,ps(n,t)}return r=i.interleaved,r===null?(e.next=e,$g(i)):(e.next=r.next,r.next=e),i.interleaved=e,ps(n,t)}function wd(n,e,t){if(e=e.updateQueue,e!==null&&(e=e.shared,(t&4194240)!==0)){var i=e.lanes;i&=n.pendingLanes,t|=i,e.lanes=t,kg(n,t)}}function Ax(n,e){var t=n.updateQueue,i=n.alternate;if(i!==null&&(i=i.updateQueue,t===i)){var r=null,s=null;if(t=t.firstBaseUpdate,t!==null){do{var a={eventTime:t.eventTime,lane:t.lane,tag:t.tag,payload:t.payload,callback:t.callback,next:null};s===null?r=s=a:s=s.next=a,t=t.next}while(t!==null);s===null?r=s=e:s=s.next=e}else r=s=e;t={baseState:i.baseState,firstBaseUpdate:r,lastBaseUpdate:s,shared:i.shared,effects:i.effects},n.updateQueue=t;return}n=t.lastBaseUpdate,n===null?t.firstBaseUpdate=e:n.next=e,t.lastBaseUpdate=e}function eh(n,e,t,i){var r=n.updateQueue;ks=!1;var s=r.firstBaseUpdate,a=r.lastBaseUpdate,l=r.shared.pending;if(l!==null){r.shared.pending=null;var d=l,h=d.next;d.next=null,a===null?s=h:a.next=h,a=d;var m=n.alternate;m!==null&&(m=m.updateQueue,l=m.lastBaseUpdate,l!==a&&(l===null?m.firstBaseUpdate=h:l.next=h,m.lastBaseUpdate=d))}if(s!==null){var u=r.baseState;a=0,m=h=d=null,l=s;do{var g=l.lane,v=l.eventTime;if((i&g)===g){m!==null&&(m=m.next={eventTime:v,lane:0,tag:l.tag,payload:l.payload,callback:l.callback,next:null});e:{var w=n,T=l;switch(g=e,v=t,T.tag){case 1:if(w=T.payload,typeof w=="function"){u=w.call(v,u,g);break e}u=w;break e;case 3:w.flags=w.flags&-65537|128;case 0:if(w=T.payload,g=typeof w=="function"?w.call(v,u,g):w,g==null)break e;u=Cn({},u,g);break e;case 2:ks=!0}}l.callback!==null&&l.lane!==0&&(n.flags|=64,g=r.effects,g===null?r.effects=[l]:g.push(l))}else v={eventTime:v,lane:g,tag:l.tag,payload:l.payload,callback:l.callback,next:null},m===null?(h=m=v,d=u):m=m.next=v,a|=g;if(l=l.next,l===null){if(l=r.shared.pending,l===null)break;g=l,l=g.next,g.next=null,r.lastBaseUpdate=g,r.shared.pending=null}}while(!0);if(m===null&&(d=u),r.baseState=d,r.firstBaseUpdate=h,r.lastBaseUpdate=m,e=r.shared.interleaved,e!==null){r=e;do a|=r.lane,r=r.next;while(r!==e)}else s===null&&(r.shared.lanes=0);La|=a,n.lanes=a,n.memoizedState=u}}function Cx(n,e,t){if(n=e.effects,e.effects=null,n!==null)for(e=0;et?t:4,n(!0);var i=Bf.transition;Bf.transition={};try{n(!1),e()}finally{rn=t,Bf.transition=i}}function T1(){return hr().memoizedState}function $L(n,e,t){var i=Xs(n);if(t={lane:i,action:t,hasEagerState:!1,eagerState:null,next:null},A1(n))C1(e,t);else if(t=l1(n,e,t,i),t!==null){var r=Mi();Ar(t,n,i,r),R1(t,e,i)}}function qL(n,e,t){var i=Xs(n),r={lane:i,action:t,hasEagerState:!1,eagerState:null,next:null};if(A1(n))C1(e,r);else{var s=n.alternate;if(n.lanes===0&&(s===null||s.lanes===0)&&(s=e.lastRenderedReducer,s!==null))try{var a=e.lastRenderedState,l=s(a,t);if(r.hasEagerState=!0,r.eagerState=l,Rr(l,a)){var d=e.interleaved;d===null?(r.next=r,$g(e)):(r.next=d.next,d.next=r),e.interleaved=r;return}}catch{}finally{}t=l1(n,e,r,i),t!==null&&(r=Mi(),Ar(t,n,i,r),R1(t,e,i))}}function A1(n){var e=n.alternate;return n===An||e!==null&&e===An}function C1(n,e){sc=nh=!0;var t=n.pending;t===null?e.next=e:(e.next=t.next,t.next=e),n.pending=e}function R1(n,e,t){if(t&4194240){var i=e.lanes;i&=n.pendingLanes,t|=i,e.lanes=t,kg(n,t)}}var ih={readContext:dr,useCallback:ui,useContext:ui,useEffect:ui,useImperativeHandle:ui,useInsertionEffect:ui,useLayoutEffect:ui,useMemo:ui,useReducer:ui,useRef:ui,useState:ui,useDebugValue:ui,useDeferredValue:ui,useTransition:ui,useMutableSource:ui,useSyncExternalStore:ui,useId:ui,unstable_isNewReconciler:!1},KL={readContext:dr,useCallback:function(n,e){return kr().memoizedState=[n,e===void 0?null:e],n},useContext:dr,useEffect:Px,useImperativeHandle:function(n,e,t){return t=t!=null?t.concat([n]):null,Md(4194308,4,x1.bind(null,e,n),t)},useLayoutEffect:function(n,e){return Md(4194308,4,n,e)},useInsertionEffect:function(n,e){return Md(4,2,n,e)},useMemo:function(n,e){var t=kr();return e=e===void 0?null:e,n=n(),t.memoizedState=[n,e],n},useReducer:function(n,e,t){var i=kr();return e=t!==void 0?t(e):e,i.memoizedState=i.baseState=e,n={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:n,lastRenderedState:e},i.queue=n,n=n.dispatch=$L.bind(null,An,n),[i.memoizedState,n]},useRef:function(n){var e=kr();return n={current:n},e.memoizedState=n},useState:Rx,useDebugValue:i_,useDeferredValue:function(n){return kr().memoizedState=n},useTransition:function(){var n=Rx(!1),e=n[0];return n=YL.bind(null,n[1]),kr().memoizedState=n,[e,n]},useMutableSource:function(){},useSyncExternalStore:function(n,e,t){var i=An,r=kr();if(xn){if(t===void 0)throw Error(Be(407));t=t()}else{if(t=e(),ni===null)throw Error(Be(349));Pa&30||f1(i,e,t)}r.memoizedState=t;var s={value:t,getSnapshot:e};return r.queue=s,Px(m1.bind(null,i,s,n),[n]),i.flags|=2048,Cc(9,p1.bind(null,i,s,t,e),void 0,null),t},useId:function(){var n=kr(),e=ni.identifierPrefix;if(xn){var t=ls,i=os;t=(i&~(1<<32-Tr(i)-1)).toString(32)+t,e=":"+e+"R"+t,t=Tc++,0<\/script>",n=n.removeChild(n.firstChild)):typeof i.is=="string"?n=a.createElement(t,{is:i.is}):(n=a.createElement(t),t==="select"&&(a=n,i.multiple?a.multiple=!0:i.size&&(a.size=i.size))):n=a.createElementNS(n,t),n[Fr]=e,n[Sc]=i,B1(n,e,!1,!1),e.stateNode=n;e:{switch(a=qp(t,i),t){case"dialog":fn("cancel",n),fn("close",n),r=i;break;case"iframe":case"object":case"embed":fn("load",n),r=i;break;case"video":case"audio":for(r=0;r<$l.length;r++)fn($l[r],n);r=i;break;case"source":fn("error",n),r=i;break;case"img":case"image":case"link":fn("error",n),fn("load",n),r=i;break;case"details":fn("toggle",n),r=i;break;case"input":qb(n,i),r=Vp(n,i),fn("invalid",n);break;case"option":r=i;break;case"select":n._wrapperState={wasMultiple:!!i.multiple},r=Cn({},i,{value:void 0}),fn("invalid",n);break;case"textarea":Zb(n,i),r=Xp(n,i),fn("invalid",n);break;default:r=i}$p(t,r),l=r;for(s in l)if(l.hasOwnProperty(s)){var d=l[s];s==="style"?vM(n,d):s==="dangerouslySetInnerHTML"?(d=d?d.__html:void 0,d!=null&&gM(n,d)):s==="children"?typeof d=="string"?(t!=="textarea"||d!=="")&&pc(n,d):typeof d=="number"&&pc(n,""+d):s!=="suppressContentEditableWarning"&&s!=="suppressHydrationWarning"&&s!=="autoFocus"&&(fc.hasOwnProperty(s)?d!=null&&s==="onScroll"&&fn("scroll",n):d!=null&&Cg(n,s,d,a))}switch(t){case"input":vu(n),Kb(n,i,!1);break;case"textarea":vu(n),Qb(n);break;case"option":i.value!=null&&n.setAttribute("value",""+qs(i.value));break;case"select":n.multiple=!!i.multiple,s=i.value,s!=null?Io(n,!!i.multiple,s,!1):i.defaultValue!=null&&Io(n,!!i.multiple,i.defaultValue,!0);break;default:typeof r.onClick=="function"&&(n.onclick=Yd)}switch(t){case"button":case"input":case"select":case"textarea":i=!!i.autoFocus;break e;case"img":i=!0;break e;default:i=!1}}i&&(e.flags|=4)}e.ref!==null&&(e.flags|=512,e.flags|=2097152)}return di(e),null;case 6:if(n&&e.stateNode!=null)H1(n,e,n.memoizedProps,i);else{if(typeof i!="string"&&e.stateNode===null)throw Error(Be(166));if(t=Ma(Ec.current),Ma(Hr.current),Au(e)){if(i=e.stateNode,t=e.memoizedProps,i[Fr]=e,(s=i.nodeValue!==t)&&(n=Yi,n!==null))switch(n.tag){case 3:Tu(i.nodeValue,t,(n.mode&1)!==0);break;case 5:n.memoizedProps.suppressHydrationWarning!==!0&&Tu(i.nodeValue,t,(n.mode&1)!==0)}s&&(e.flags|=4)}else i=(t.nodeType===9?t:t.ownerDocument).createTextNode(i),i[Fr]=e,e.stateNode=i}return di(e),null;case 13:if(gn(En),i=e.memoizedState,n===null||n.memoizedState!==null&&n.memoizedState.dehydrated!==null){if(xn&&Xi!==null&&e.mode&1&&!(e.flags&128))s1(),Yo(),e.flags|=98560,s=!1;else if(s=Au(e),i!==null&&i.dehydrated!==null){if(n===null){if(!s)throw Error(Be(318));if(s=e.memoizedState,s=s!==null?s.dehydrated:null,!s)throw Error(Be(317));s[Fr]=e}else Yo(),!(e.flags&128)&&(e.memoizedState=null),e.flags|=4;di(e),s=!1}else Sr!==null&&(Rm(Sr),Sr=null),s=!0;if(!s)return e.flags&65536?e:null}return e.flags&128?(e.lanes=t,e):(i=i!==null,i!==(n!==null&&n.memoizedState!==null)&&i&&(e.child.flags|=8192,e.mode&1&&(n===null||En.current&1?$n===0&&($n=3):u_())),e.updateQueue!==null&&(e.flags|=4),di(e),null);case 4:return qo(),xm(n,e),n===null&&xc(e.stateNode.containerInfo),di(e),null;case 10:return Yg(e.type._context),di(e),null;case 17:return Oi(e.type)&&$d(),di(e),null;case 19:if(gn(En),s=e.memoizedState,s===null)return di(e),null;if(i=(e.flags&128)!==0,a=s.rendering,a===null)if(i)Il(s,!1);else{if($n!==0||n!==null&&n.flags&128)for(n=e.child;n!==null;){if(a=th(n),a!==null){for(e.flags|=128,Il(s,!1),i=a.updateQueue,i!==null&&(e.updateQueue=i,e.flags|=4),e.subtreeFlags=0,i=t,t=e.child;t!==null;)s=t,n=i,s.flags&=14680066,a=s.alternate,a===null?(s.childLanes=0,s.lanes=n,s.child=null,s.subtreeFlags=0,s.memoizedProps=null,s.memoizedState=null,s.updateQueue=null,s.dependencies=null,s.stateNode=null):(s.childLanes=a.childLanes,s.lanes=a.lanes,s.child=a.child,s.subtreeFlags=0,s.deletions=null,s.memoizedProps=a.memoizedProps,s.memoizedState=a.memoizedState,s.updateQueue=a.updateQueue,s.type=a.type,n=a.dependencies,s.dependencies=n===null?null:{lanes:n.lanes,firstContext:n.firstContext}),t=t.sibling;return cn(En,En.current&1|2),e.child}n=n.sibling}s.tail!==null&&kn()>Zo&&(e.flags|=128,i=!0,Il(s,!1),e.lanes=4194304)}else{if(!i)if(n=th(a),n!==null){if(e.flags|=128,i=!0,t=n.updateQueue,t!==null&&(e.updateQueue=t,e.flags|=4),Il(s,!0),s.tail===null&&s.tailMode==="hidden"&&!a.alternate&&!xn)return di(e),null}else 2*kn()-s.renderingStartTime>Zo&&t!==1073741824&&(e.flags|=128,i=!0,Il(s,!1),e.lanes=4194304);s.isBackwards?(a.sibling=e.child,e.child=a):(t=s.last,t!==null?t.sibling=a:e.child=a,s.last=a)}return s.tail!==null?(e=s.tail,s.rendering=e,s.tail=e.sibling,s.renderingStartTime=kn(),e.sibling=null,t=En.current,cn(En,i?t&1|2:t&1),e):(di(e),null);case 22:case 23:return c_(),i=e.memoizedState!==null,n!==null&&n.memoizedState!==null!==i&&(e.flags|=8192),i&&e.mode&1?ji&1073741824&&(di(e),e.subtreeFlags&6&&(e.flags|=8192)):di(e),null;case 24:return null;case 25:return null}throw Error(Be(156,e.tag))}function rI(n,e){switch(Vg(e),e.tag){case 1:return Oi(e.type)&&$d(),n=e.flags,n&65536?(e.flags=n&-65537|128,e):null;case 3:return qo(),gn(Ui),gn(vi),Qg(),n=e.flags,n&65536&&!(n&128)?(e.flags=n&-65537|128,e):null;case 5:return Zg(e),null;case 13:if(gn(En),n=e.memoizedState,n!==null&&n.dehydrated!==null){if(e.alternate===null)throw Error(Be(340));Yo()}return n=e.flags,n&65536?(e.flags=n&-65537|128,e):null;case 19:return gn(En),null;case 4:return qo(),null;case 10:return Yg(e.type._context),null;case 22:case 23:return c_(),null;case 24:return null;default:return null}}var Pu=!1,pi=!1,sI=typeof WeakSet=="function"?WeakSet:Set,st=null;function So(n,e){var t=n.ref;if(t!==null)if(typeof t=="function")try{t(null)}catch(i){Rn(n,e,i)}else t.current=null}function wm(n,e,t){try{t()}catch(i){Rn(n,e,i)}}var Hx=!1;function aI(n,e){if(sm=Wd,n=XM(),Hg(n)){if("selectionStart"in n)var t={start:n.selectionStart,end:n.selectionEnd};else e:{t=(t=n.ownerDocument)&&t.defaultView||window;var i=t.getSelection&&t.getSelection();if(i&&i.rangeCount!==0){t=i.anchorNode;var r=i.anchorOffset,s=i.focusNode;i=i.focusOffset;try{t.nodeType,s.nodeType}catch{t=null;break e}var a=0,l=-1,d=-1,h=0,m=0,u=n,g=null;t:for(;;){for(var v;u!==t||r!==0&&u.nodeType!==3||(l=a+r),u!==s||i!==0&&u.nodeType!==3||(d=a+i),u.nodeType===3&&(a+=u.nodeValue.length),(v=u.firstChild)!==null;)g=u,u=v;for(;;){if(u===n)break t;if(g===t&&++h===r&&(l=a),g===s&&++m===i&&(d=a),(v=u.nextSibling)!==null)break;u=g,g=u.parentNode}u=v}t=l===-1||d===-1?null:{start:l,end:d}}else t=null}t=t||{start:0,end:0}}else t=null;for(am={focusedElem:n,selectionRange:t},Wd=!1,st=e;st!==null;)if(e=st,n=e.child,(e.subtreeFlags&1028)!==0&&n!==null)n.return=e,st=n;else for(;st!==null;){e=st;try{var w=e.alternate;if(e.flags&1024)switch(e.tag){case 0:case 11:case 15:break;case 1:if(w!==null){var T=w.memoizedProps,M=w.memoizedState,b=e.stateNode,A=b.getSnapshotBeforeUpdate(e.elementType===e.type?T:br(e.type,T),M);b.__reactInternalSnapshotBeforeUpdate=A}break;case 3:var E=e.stateNode.containerInfo;E.nodeType===1?E.textContent="":E.nodeType===9&&E.documentElement&&E.removeChild(E.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(Be(163))}}catch(P){Rn(e,e.return,P)}if(n=e.sibling,n!==null){n.return=e.return,st=n;break}st=e.return}return w=Hx,Hx=!1,w}function ac(n,e,t){var i=e.updateQueue;if(i=i!==null?i.lastEffect:null,i!==null){var r=i=i.next;do{if((r.tag&n)===n){var s=r.destroy;r.destroy=void 0,s!==void 0&&wm(e,t,s)}r=r.next}while(r!==i)}}function Ih(n,e){if(e=e.updateQueue,e=e!==null?e.lastEffect:null,e!==null){var t=e=e.next;do{if((t.tag&n)===n){var i=t.create;t.destroy=i()}t=t.next}while(t!==e)}}function Sm(n){var e=n.ref;if(e!==null){var t=n.stateNode;switch(n.tag){case 5:n=t;break;default:n=t}typeof e=="function"?e(n):e.current=n}}function G1(n){var e=n.alternate;e!==null&&(n.alternate=null,G1(e)),n.child=null,n.deletions=null,n.sibling=null,n.tag===5&&(e=n.stateNode,e!==null&&(delete e[Fr],delete e[Sc],delete e[cm],delete e[GL],delete e[VL])),n.stateNode=null,n.return=null,n.dependencies=null,n.memoizedProps=null,n.memoizedState=null,n.pendingProps=null,n.stateNode=null,n.updateQueue=null}function V1(n){return n.tag===5||n.tag===3||n.tag===4}function Gx(n){e:for(;;){for(;n.sibling===null;){if(n.return===null||V1(n.return))return null;n=n.return}for(n.sibling.return=n.return,n=n.sibling;n.tag!==5&&n.tag!==6&&n.tag!==18;){if(n.flags&2||n.child===null||n.tag===4)continue e;n.child.return=n,n=n.child}if(!(n.flags&2))return n.stateNode}}function Mm(n,e,t){var i=n.tag;if(i===5||i===6)n=n.stateNode,e?t.nodeType===8?t.parentNode.insertBefore(n,e):t.insertBefore(n,e):(t.nodeType===8?(e=t.parentNode,e.insertBefore(n,t)):(e=t,e.appendChild(n)),t=t._reactRootContainer,t!=null||e.onclick!==null||(e.onclick=Yd));else if(i!==4&&(n=n.child,n!==null))for(Mm(n,e,t),n=n.sibling;n!==null;)Mm(n,e,t),n=n.sibling}function Em(n,e,t){var i=n.tag;if(i===5||i===6)n=n.stateNode,e?t.insertBefore(n,e):t.appendChild(n);else if(i!==4&&(n=n.child,n!==null))for(Em(n,e,t),n=n.sibling;n!==null;)Em(n,e,t),n=n.sibling}var ri=null,wr=!1;function ws(n,e,t){for(t=t.child;t!==null;)W1(n,e,t),t=t.sibling}function W1(n,e,t){if(zr&&typeof zr.onCommitFiberUnmount=="function")try{zr.onCommitFiberUnmount(Mh,t)}catch{}switch(t.tag){case 5:pi||So(t,e);case 6:var i=ri,r=wr;ri=null,ws(n,e,t),ri=i,wr=r,ri!==null&&(wr?(n=ri,t=t.stateNode,n.nodeType===8?n.parentNode.removeChild(t):n.removeChild(t)):ri.removeChild(t.stateNode));break;case 18:ri!==null&&(wr?(n=ri,t=t.stateNode,n.nodeType===8?Uf(n.parentNode,t):n.nodeType===1&&Uf(n,t),vc(n)):Uf(ri,t.stateNode));break;case 4:i=ri,r=wr,ri=t.stateNode.containerInfo,wr=!0,ws(n,e,t),ri=i,wr=r;break;case 0:case 11:case 14:case 15:if(!pi&&(i=t.updateQueue,i!==null&&(i=i.lastEffect,i!==null))){r=i=i.next;do{var s=r,a=s.destroy;s=s.tag,a!==void 0&&(s&2||s&4)&&wm(t,e,a),r=r.next}while(r!==i)}ws(n,e,t);break;case 1:if(!pi&&(So(t,e),i=t.stateNode,typeof i.componentWillUnmount=="function"))try{i.props=t.memoizedProps,i.state=t.memoizedState,i.componentWillUnmount()}catch(l){Rn(t,e,l)}ws(n,e,t);break;case 21:ws(n,e,t);break;case 22:t.mode&1?(pi=(i=pi)||t.memoizedState!==null,ws(n,e,t),pi=i):ws(n,e,t);break;default:ws(n,e,t)}}function Vx(n){var e=n.updateQueue;if(e!==null){n.updateQueue=null;var t=n.stateNode;t===null&&(t=n.stateNode=new sI),e.forEach(function(i){var r=mI.bind(null,n,i);t.has(i)||(t.add(i),i.then(r,r))})}}function pr(n,e){var t=e.deletions;if(t!==null)for(var i=0;ir&&(r=a),i&=~s}if(i=r,i=kn()-i,i=(120>i?120:480>i?480:1080>i?1080:1920>i?1920:3e3>i?3e3:4320>i?4320:1960*lI(i/1960))-i,10n?16:n,Ns===null)var i=!1;else{if(n=Ns,Ns=null,ah=0,qt&6)throw Error(Be(331));var r=qt;for(qt|=4,st=n.current;st!==null;){var s=st,a=s.child;if(st.flags&16){var l=s.deletions;if(l!==null){for(var d=0;dkn()-o_?Ea(n,0):a_|=t),Ni(n,e)}function Q1(n,e){e===0&&(n.mode&1?(e=xu,xu<<=1,!(xu&130023424)&&(xu=4194304)):e=1);var t=Mi();n=ps(n,e),n!==null&&(zc(n,e,t),Ni(n,t))}function pI(n){var e=n.memoizedState,t=0;e!==null&&(t=e.retryLane),Q1(n,t)}function mI(n,e){var t=0;switch(n.tag){case 13:var i=n.stateNode,r=n.memoizedState;r!==null&&(t=r.retryLane);break;case 19:i=n.stateNode;break;default:throw Error(Be(314))}i!==null&&i.delete(e),Q1(n,t)}var J1;J1=function(n,e,t){if(n!==null)if(n.memoizedProps!==e.pendingProps||Ui.current)Fi=!0;else{if(!(n.lanes&t)&&!(e.flags&128))return Fi=!1,nI(n,e,t);Fi=!!(n.flags&131072)}else Fi=!1,xn&&e.flags&1048576&&i1(e,Zd,e.index);switch(e.lanes=0,e.tag){case 2:var i=e.type;Ed(n,e),n=e.pendingProps;var r=Xo(e,vi.current);Uo(e,t),r=e_(null,e,i,n,r,t);var s=t_();return e.flags|=1,typeof r=="object"&&r!==null&&typeof r.render=="function"&&r.$$typeof===void 0?(e.tag=1,e.memoizedState=null,e.updateQueue=null,Oi(i)?(s=!0,qd(e)):s=!1,e.memoizedState=r.state!==null&&r.state!==void 0?r.state:null,qg(e),r.updater=Lh,e.stateNode=r,r._reactInternals=e,mm(e,i,n,t),e=vm(null,e,i,!0,s,t)):(e.tag=0,xn&&s&&Gg(e),wi(null,e,r,t),e=e.child),e;case 16:i=e.elementType;e:{switch(Ed(n,e),n=e.pendingProps,r=i._init,i=r(i._payload),e.type=i,r=e.tag=_I(i),n=br(i,n),r){case 0:e=_m(null,e,i,n,t);break e;case 1:e=Nx(null,e,i,n,t);break e;case 11:e=Ux(null,e,i,n,t);break e;case 14:e=Ox(null,e,i,br(i.type,n),t);break e}throw Error(Be(306,i,""))}return e;case 0:return i=e.type,r=e.pendingProps,r=e.elementType===i?r:br(i,r),_m(n,e,i,r,t);case 1:return i=e.type,r=e.pendingProps,r=e.elementType===i?r:br(i,r),Nx(n,e,i,r,t);case 3:e:{if(U1(e),n===null)throw Error(Be(387));i=e.pendingProps,s=e.memoizedState,r=s.element,c1(n,e),eh(e,i,null,t);var a=e.memoizedState;if(i=a.element,s.isDehydrated)if(s={element:i,isDehydrated:!1,cache:a.cache,pendingSuspenseBoundaries:a.pendingSuspenseBoundaries,transitions:a.transitions},e.updateQueue.baseState=s,e.memoizedState=s,e.flags&256){r=Ko(Error(Be(423)),e),e=Bx(n,e,i,t,r);break e}else if(i!==r){r=Ko(Error(Be(424)),e),e=Bx(n,e,i,t,r);break e}else for(Xi=Vs(e.stateNode.containerInfo.firstChild),Yi=e,xn=!0,Sr=null,t=o1(e,null,i,t),e.child=t;t;)t.flags=t.flags&-3|4096,t=t.sibling;else{if(Yo(),i===r){e=ms(n,e,t);break e}wi(n,e,i,t)}e=e.child}return e;case 5:return u1(e),n===null&&hm(e),i=e.type,r=e.pendingProps,s=n!==null?n.memoizedProps:null,a=r.children,om(i,r)?a=null:s!==null&&om(i,s)&&(e.flags|=32),F1(n,e),wi(n,e,a,t),e.child;case 6:return n===null&&hm(e),null;case 13:return O1(n,e,t);case 4:return Kg(e,e.stateNode.containerInfo),i=e.pendingProps,n===null?e.child=$o(e,null,i,t):wi(n,e,i,t),e.child;case 11:return i=e.type,r=e.pendingProps,r=e.elementType===i?r:br(i,r),Ux(n,e,i,r,t);case 7:return wi(n,e,e.pendingProps,t),e.child;case 8:return wi(n,e,e.pendingProps.children,t),e.child;case 12:return wi(n,e,e.pendingProps.children,t),e.child;case 10:e:{if(i=e.type._context,r=e.pendingProps,s=e.memoizedProps,a=r.value,cn(Qd,i._currentValue),i._currentValue=a,s!==null)if(Rr(s.value,a)){if(s.children===r.children&&!Ui.current){e=ms(n,e,t);break e}}else for(s=e.child,s!==null&&(s.return=e);s!==null;){var l=s.dependencies;if(l!==null){a=s.child;for(var d=l.firstContext;d!==null;){if(d.context===i){if(s.tag===1){d=ds(-1,t&-t),d.tag=2;var h=s.updateQueue;if(h!==null){h=h.shared;var m=h.pending;m===null?d.next=d:(d.next=m.next,m.next=d),h.pending=d}}s.lanes|=t,d=s.alternate,d!==null&&(d.lanes|=t),fm(s.return,t,e),l.lanes|=t;break}d=d.next}}else if(s.tag===10)a=s.type===e.type?null:s.child;else if(s.tag===18){if(a=s.return,a===null)throw Error(Be(341));a.lanes|=t,l=a.alternate,l!==null&&(l.lanes|=t),fm(a,t,e),a=s.sibling}else a=s.child;if(a!==null)a.return=s;else for(a=s;a!==null;){if(a===e){a=null;break}if(s=a.sibling,s!==null){s.return=a.return,a=s;break}a=a.return}s=a}wi(n,e,r.children,t),e=e.child}return e;case 9:return r=e.type,i=e.pendingProps.children,Uo(e,t),r=dr(r),i=i(r),e.flags|=1,wi(n,e,i,t),e.child;case 14:return i=e.type,r=br(i,e.pendingProps),r=br(i.type,r),Ox(n,e,i,r,t);case 15:return D1(n,e,e.type,e.pendingProps,t);case 17:return i=e.type,r=e.pendingProps,r=e.elementType===i?r:br(i,r),Ed(n,e),e.tag=1,Oi(i)?(n=!0,qd(e)):n=!1,Uo(e,t),P1(e,i,r),mm(e,i,r,t),vm(null,e,i,!0,n,t);case 19:return N1(n,e,t);case 22:return k1(n,e,t)}throw Error(Be(156,e.tag))};function eE(n,e){return AM(n,e)}function gI(n,e,t,i){this.tag=n,this.key=t,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=e,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=i,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function lr(n,e,t,i){return new gI(n,e,t,i)}function d_(n){return n=n.prototype,!(!n||!n.isReactComponent)}function _I(n){if(typeof n=="function")return d_(n)?1:0;if(n!=null){if(n=n.$$typeof,n===Pg)return 11;if(n===Lg)return 14}return 2}function Ys(n,e){var t=n.alternate;return t===null?(t=lr(n.tag,e,n.key,n.mode),t.elementType=n.elementType,t.type=n.type,t.stateNode=n.stateNode,t.alternate=n,n.alternate=t):(t.pendingProps=e,t.type=n.type,t.flags=0,t.subtreeFlags=0,t.deletions=null),t.flags=n.flags&14680064,t.childLanes=n.childLanes,t.lanes=n.lanes,t.child=n.child,t.memoizedProps=n.memoizedProps,t.memoizedState=n.memoizedState,t.updateQueue=n.updateQueue,e=n.dependencies,t.dependencies=e===null?null:{lanes:e.lanes,firstContext:e.firstContext},t.sibling=n.sibling,t.index=n.index,t.ref=n.ref,t}function Cd(n,e,t,i,r,s){var a=2;if(i=n,typeof n=="function")d_(n)&&(a=1);else if(typeof n=="string")a=5;else e:switch(n){case po:return Ta(t.children,r,s,e);case Rg:a=8,r|=8;break;case Bp:return n=lr(12,t,e,r|2),n.elementType=Bp,n.lanes=s,n;case zp:return n=lr(13,t,e,r),n.elementType=zp,n.lanes=s,n;case Hp:return n=lr(19,t,e,r),n.elementType=Hp,n.lanes=s,n;case uM:return kh(t,r,s,e);default:if(typeof n=="object"&&n!==null)switch(n.$$typeof){case lM:a=10;break e;case cM:a=9;break e;case Pg:a=11;break e;case Lg:a=14;break e;case Ds:a=16,i=null;break e}throw Error(Be(130,n==null?n:typeof n,""))}return e=lr(a,t,e,r),e.elementType=n,e.type=i,e.lanes=s,e}function Ta(n,e,t,i){return n=lr(7,n,i,e),n.lanes=t,n}function kh(n,e,t,i){return n=lr(22,n,i,e),n.elementType=uM,n.lanes=t,n.stateNode={isHidden:!1},n}function Wf(n,e,t){return n=lr(6,n,null,e),n.lanes=t,n}function jf(n,e,t){return e=lr(4,n.children!==null?n.children:[],n.key,e),e.lanes=t,e.stateNode={containerInfo:n.containerInfo,pendingChildren:null,implementation:n.implementation},e}function vI(n,e,t,i,r){this.tag=e,this.containerInfo=n,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=Ef(0),this.expirationTimes=Ef(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=Ef(0),this.identifierPrefix=i,this.onRecoverableError=r,this.mutableSourceEagerHydrationData=null}function h_(n,e,t,i,r,s,a,l,d){return n=new vI(n,e,t,l,d),e===1?(e=1,s===!0&&(e|=8)):e=0,s=lr(3,null,null,e),n.current=s,s.stateNode=n,s.memoizedState={element:i,isDehydrated:t,cache:null,transitions:null,pendingSuspenseBoundaries:null},qg(s),n}function yI(n,e,t){var i=3"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(rE)}catch(n){console.error(n)}}rE(),rM.exports=Ki;var MI=rM.exports,sE,Zx=MI;sE=Zx.createRoot,Zx.hydrateRoot;/**
+ * @license
+ * Copyright 2010-2024 Three.js Authors
+ * SPDX-License-Identifier: MIT
+ */const g_="166",EI=0,Qx=1,TI=2,aE=1,oE=2,ts=3,gs=0,Ei=1,Si=2,Gr=0,No=1,ch=2,Jx=3,ew=4,AI=5,ya=100,CI=101,RI=102,PI=103,LI=104,II=200,DI=201,kI=202,FI=203,Pm=204,Lm=205,UI=206,OI=207,NI=208,BI=209,zI=210,HI=211,GI=212,VI=213,WI=214,jI=0,XI=1,YI=2,uh=3,$I=4,qI=5,KI=6,ZI=7,Bh=0,QI=1,JI=2,$s=0,lE=1,eD=2,tD=3,nD=4,iD=5,rD=6,sD=7,tw="attached",aD="detached",__=300,Qo=301,Jo=302,el=303,Im=304,zh=306,Vr=1e3,ti=1001,dh=1002,Fn=1003,cE=1004,ql=1005,ln=1006,Rd=1007,Er=1008,nw=1008,Bi=1009,uE=1010,dE=1011,Pc=1012,v_=1013,Da=1014,Un=1015,gi=1016,y_=1017,b_=1018,tl=1020,hE=35902,fE=1021,pE=1022,Vn=1023,mE=1024,gE=1025,Bo=1026,nl=1027,Wc=1028,x_=1029,_E=1030,w_=1031,S_=1033,Pd=33776,Ld=33777,Id=33778,Dd=33779,Dm=35840,km=35841,Fm=35842,Um=35843,Om=36196,Nm=37492,Bm=37496,zm=37808,Hm=37809,Gm=37810,Vm=37811,Wm=37812,jm=37813,Xm=37814,Ym=37815,$m=37816,qm=37817,Km=37818,Zm=37819,Qm=37820,Jm=37821,kd=36492,eg=36494,tg=36495,vE=36283,ng=36284,ig=36285,rg=36286,Lc=2300,Ic=2301,Xf=2302,iw=2400,rw=2401,sw=2402,oD=2500,lD=0,yE=1,sg=2,cD=3200,uD=3201,cl=0,dD=1,ss="",on="srgb",Sn="srgb-linear",M_="display-p3",Hh="display-p3-linear",hh="linear",pn="srgb",fh="rec709",ph="p3",ja=7680,aw=519,hD=512,fD=513,pD=514,bE=515,mD=516,gD=517,_D=518,vD=519,ag=35044,ow="300 es",cs=2e3,mh=2001;class ul{addEventListener(e,t){this._listeners===void 0&&(this._listeners={});const i=this._listeners;i[e]===void 0&&(i[e]=[]),i[e].indexOf(t)===-1&&i[e].push(t)}hasEventListener(e,t){if(this._listeners===void 0)return!1;const i=this._listeners;return i[e]!==void 0&&i[e].indexOf(t)!==-1}removeEventListener(e,t){if(this._listeners===void 0)return;const r=this._listeners[e];if(r!==void 0){const s=r.indexOf(t);s!==-1&&r.splice(s,1)}}dispatchEvent(e){if(this._listeners===void 0)return;const i=this._listeners[e.type];if(i!==void 0){e.target=this;const r=i.slice(0);for(let s=0,a=r.length;s>8&255]+hi[n>>16&255]+hi[n>>24&255]+"-"+hi[e&255]+hi[e>>8&255]+"-"+hi[e>>16&15|64]+hi[e>>24&255]+"-"+hi[t&63|128]+hi[t>>8&255]+"-"+hi[t>>16&255]+hi[t>>24&255]+hi[i&255]+hi[i>>8&255]+hi[i>>16&255]+hi[i>>24&255]).toLowerCase()}function Wn(n,e,t){return Math.max(e,Math.min(t,n))}function E_(n,e){return(n%e+e)%e}function yD(n,e,t,i,r){return i+(n-e)*(r-i)/(t-e)}function bD(n,e,t){return n!==e?(t-n)/(e-n):0}function uc(n,e,t){return(1-t)*n+t*e}function xD(n,e,t,i){return uc(n,e,1-Math.exp(-t*i))}function wD(n,e=1){return e-Math.abs(E_(n,e*2)-e)}function SD(n,e,t){return n<=e?0:n>=t?1:(n=(n-e)/(t-e),n*n*(3-2*n))}function MD(n,e,t){return n<=e?0:n>=t?1:(n=(n-e)/(t-e),n*n*n*(n*(n*6-15)+10))}function ED(n,e){return n+Math.floor(Math.random()*(e-n+1))}function TD(n,e){return n+Math.random()*(e-n)}function AD(n){return n*(.5-Math.random())}function CD(n){n!==void 0&&(lw=n);let e=lw+=1831565813;return e=Math.imul(e^e>>>15,e|1),e^=e+Math.imul(e^e>>>7,e|61),((e^e>>>14)>>>0)/4294967296}function RD(n){return n*cc}function PD(n){return n*il}function LD(n){return(n&n-1)===0&&n!==0}function ID(n){return Math.pow(2,Math.ceil(Math.log(n)/Math.LN2))}function DD(n){return Math.pow(2,Math.floor(Math.log(n)/Math.LN2))}function kD(n,e,t,i,r){const s=Math.cos,a=Math.sin,l=s(t/2),d=a(t/2),h=s((e+i)/2),m=a((e+i)/2),u=s((e-i)/2),g=a((e-i)/2),v=s((i-e)/2),w=a((i-e)/2);switch(r){case"XYX":n.set(l*m,d*u,d*g,l*h);break;case"YZY":n.set(d*g,l*m,d*u,l*h);break;case"ZXZ":n.set(d*u,d*g,l*m,l*h);break;case"XZX":n.set(l*m,d*w,d*v,l*h);break;case"YXY":n.set(d*v,l*m,d*w,l*h);break;case"ZYZ":n.set(d*w,d*v,l*m,l*h);break;default:console.warn("THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: "+r)}}function Mr(n,e){switch(e.constructor){case Float32Array:return n;case Uint32Array:return n/4294967295;case Uint16Array:return n/65535;case Uint8Array:return n/255;case Int32Array:return Math.max(n/2147483647,-1);case Int16Array:return Math.max(n/32767,-1);case Int8Array:return Math.max(n/127,-1);default:throw new Error("Invalid component type.")}}function tn(n,e){switch(e.constructor){case Float32Array:return n;case Uint32Array:return Math.round(n*4294967295);case Uint16Array:return Math.round(n*65535);case Uint8Array:return Math.round(n*255);case Int32Array:return Math.round(n*2147483647);case Int16Array:return Math.round(n*32767);case Int8Array:return Math.round(n*127);default:throw new Error("Invalid component type.")}}const bn={DEG2RAD:cc,RAD2DEG:il,generateUUID:Cr,clamp:Wn,euclideanModulo:E_,mapLinear:yD,inverseLerp:bD,lerp:uc,damp:xD,pingpong:wD,smoothstep:SD,smootherstep:MD,randInt:ED,randFloat:TD,randFloatSpread:AD,seededRandom:CD,degToRad:RD,radToDeg:PD,isPowerOfTwo:LD,ceilPowerOfTwo:ID,floorPowerOfTwo:DD,setQuaternionFromProperEuler:kD,normalize:tn,denormalize:Mr};class et{constructor(e=0,t=0){et.prototype.isVector2=!0,this.x=e,this.y=t}get width(){return this.x}set width(e){this.x=e}get height(){return this.y}set height(e){this.y=e}set(e,t){return this.x=e,this.y=t,this}setScalar(e){return this.x=e,this.y=e,this}setX(e){return this.x=e,this}setY(e){return this.y=e,this}setComponent(e,t){switch(e){case 0:this.x=t;break;case 1:this.y=t;break;default:throw new Error("index is out of range: "+e)}return this}getComponent(e){switch(e){case 0:return this.x;case 1:return this.y;default:throw new Error("index is out of range: "+e)}}clone(){return new this.constructor(this.x,this.y)}copy(e){return this.x=e.x,this.y=e.y,this}add(e){return this.x+=e.x,this.y+=e.y,this}addScalar(e){return this.x+=e,this.y+=e,this}addVectors(e,t){return this.x=e.x+t.x,this.y=e.y+t.y,this}addScaledVector(e,t){return this.x+=e.x*t,this.y+=e.y*t,this}sub(e){return this.x-=e.x,this.y-=e.y,this}subScalar(e){return this.x-=e,this.y-=e,this}subVectors(e,t){return this.x=e.x-t.x,this.y=e.y-t.y,this}multiply(e){return this.x*=e.x,this.y*=e.y,this}multiplyScalar(e){return this.x*=e,this.y*=e,this}divide(e){return this.x/=e.x,this.y/=e.y,this}divideScalar(e){return this.multiplyScalar(1/e)}applyMatrix3(e){const t=this.x,i=this.y,r=e.elements;return this.x=r[0]*t+r[3]*i+r[6],this.y=r[1]*t+r[4]*i+r[7],this}min(e){return this.x=Math.min(this.x,e.x),this.y=Math.min(this.y,e.y),this}max(e){return this.x=Math.max(this.x,e.x),this.y=Math.max(this.y,e.y),this}clamp(e,t){return this.x=Math.max(e.x,Math.min(t.x,this.x)),this.y=Math.max(e.y,Math.min(t.y,this.y)),this}clampScalar(e,t){return this.x=Math.max(e,Math.min(t,this.x)),this.y=Math.max(e,Math.min(t,this.y)),this}clampLength(e,t){const i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(e,Math.min(t,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this}negate(){return this.x=-this.x,this.y=-this.y,this}dot(e){return this.x*e.x+this.y*e.y}cross(e){return this.x*e.y-this.y*e.x}lengthSq(){return this.x*this.x+this.y*this.y}length(){return Math.sqrt(this.x*this.x+this.y*this.y)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)}normalize(){return this.divideScalar(this.length()||1)}angle(){return Math.atan2(-this.y,-this.x)+Math.PI}angleTo(e){const t=Math.sqrt(this.lengthSq()*e.lengthSq());if(t===0)return Math.PI/2;const i=this.dot(e)/t;return Math.acos(Wn(i,-1,1))}distanceTo(e){return Math.sqrt(this.distanceToSquared(e))}distanceToSquared(e){const t=this.x-e.x,i=this.y-e.y;return t*t+i*i}manhattanDistanceTo(e){return Math.abs(this.x-e.x)+Math.abs(this.y-e.y)}setLength(e){return this.normalize().multiplyScalar(e)}lerp(e,t){return this.x+=(e.x-this.x)*t,this.y+=(e.y-this.y)*t,this}lerpVectors(e,t,i){return this.x=e.x+(t.x-e.x)*i,this.y=e.y+(t.y-e.y)*i,this}equals(e){return e.x===this.x&&e.y===this.y}fromArray(e,t=0){return this.x=e[t],this.y=e[t+1],this}toArray(e=[],t=0){return e[t]=this.x,e[t+1]=this.y,e}fromBufferAttribute(e,t){return this.x=e.getX(t),this.y=e.getY(t),this}rotateAround(e,t){const i=Math.cos(t),r=Math.sin(t),s=this.x-e.x,a=this.y-e.y;return this.x=s*i-a*r+e.x,this.y=s*r+a*i+e.y,this}random(){return this.x=Math.random(),this.y=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y}}class At{constructor(e,t,i,r,s,a,l,d,h){At.prototype.isMatrix3=!0,this.elements=[1,0,0,0,1,0,0,0,1],e!==void 0&&this.set(e,t,i,r,s,a,l,d,h)}set(e,t,i,r,s,a,l,d,h){const m=this.elements;return m[0]=e,m[1]=r,m[2]=l,m[3]=t,m[4]=s,m[5]=d,m[6]=i,m[7]=a,m[8]=h,this}identity(){return this.set(1,0,0,0,1,0,0,0,1),this}copy(e){const t=this.elements,i=e.elements;return t[0]=i[0],t[1]=i[1],t[2]=i[2],t[3]=i[3],t[4]=i[4],t[5]=i[5],t[6]=i[6],t[7]=i[7],t[8]=i[8],this}extractBasis(e,t,i){return e.setFromMatrix3Column(this,0),t.setFromMatrix3Column(this,1),i.setFromMatrix3Column(this,2),this}setFromMatrix4(e){const t=e.elements;return this.set(t[0],t[4],t[8],t[1],t[5],t[9],t[2],t[6],t[10]),this}multiply(e){return this.multiplyMatrices(this,e)}premultiply(e){return this.multiplyMatrices(e,this)}multiplyMatrices(e,t){const i=e.elements,r=t.elements,s=this.elements,a=i[0],l=i[3],d=i[6],h=i[1],m=i[4],u=i[7],g=i[2],v=i[5],w=i[8],T=r[0],M=r[3],b=r[6],A=r[1],E=r[4],P=r[7],G=r[2],O=r[5],B=r[8];return s[0]=a*T+l*A+d*G,s[3]=a*M+l*E+d*O,s[6]=a*b+l*P+d*B,s[1]=h*T+m*A+u*G,s[4]=h*M+m*E+u*O,s[7]=h*b+m*P+u*B,s[2]=g*T+v*A+w*G,s[5]=g*M+v*E+w*O,s[8]=g*b+v*P+w*B,this}multiplyScalar(e){const t=this.elements;return t[0]*=e,t[3]*=e,t[6]*=e,t[1]*=e,t[4]*=e,t[7]*=e,t[2]*=e,t[5]*=e,t[8]*=e,this}determinant(){const e=this.elements,t=e[0],i=e[1],r=e[2],s=e[3],a=e[4],l=e[5],d=e[6],h=e[7],m=e[8];return t*a*m-t*l*h-i*s*m+i*l*d+r*s*h-r*a*d}invert(){const e=this.elements,t=e[0],i=e[1],r=e[2],s=e[3],a=e[4],l=e[5],d=e[6],h=e[7],m=e[8],u=m*a-l*h,g=l*d-m*s,v=h*s-a*d,w=t*u+i*g+r*v;if(w===0)return this.set(0,0,0,0,0,0,0,0,0);const T=1/w;return e[0]=u*T,e[1]=(r*h-m*i)*T,e[2]=(l*i-r*a)*T,e[3]=g*T,e[4]=(m*t-r*d)*T,e[5]=(r*s-l*t)*T,e[6]=v*T,e[7]=(i*d-h*t)*T,e[8]=(a*t-i*s)*T,this}transpose(){let e;const t=this.elements;return e=t[1],t[1]=t[3],t[3]=e,e=t[2],t[2]=t[6],t[6]=e,e=t[5],t[5]=t[7],t[7]=e,this}getNormalMatrix(e){return this.setFromMatrix4(e).invert().transpose()}transposeIntoArray(e){const t=this.elements;return e[0]=t[0],e[1]=t[3],e[2]=t[6],e[3]=t[1],e[4]=t[4],e[5]=t[7],e[6]=t[2],e[7]=t[5],e[8]=t[8],this}setUvTransform(e,t,i,r,s,a,l){const d=Math.cos(s),h=Math.sin(s);return this.set(i*d,i*h,-i*(d*a+h*l)+a+e,-r*h,r*d,-r*(-h*a+d*l)+l+t,0,0,1),this}scale(e,t){return this.premultiply(Yf.makeScale(e,t)),this}rotate(e){return this.premultiply(Yf.makeRotation(-e)),this}translate(e,t){return this.premultiply(Yf.makeTranslation(e,t)),this}makeTranslation(e,t){return e.isVector2?this.set(1,0,e.x,0,1,e.y,0,0,1):this.set(1,0,e,0,1,t,0,0,1),this}makeRotation(e){const t=Math.cos(e),i=Math.sin(e);return this.set(t,-i,0,i,t,0,0,0,1),this}makeScale(e,t){return this.set(e,0,0,0,t,0,0,0,1),this}equals(e){const t=this.elements,i=e.elements;for(let r=0;r<9;r++)if(t[r]!==i[r])return!1;return!0}fromArray(e,t=0){for(let i=0;i<9;i++)this.elements[i]=e[i+t];return this}toArray(e=[],t=0){const i=this.elements;return e[t]=i[0],e[t+1]=i[1],e[t+2]=i[2],e[t+3]=i[3],e[t+4]=i[4],e[t+5]=i[5],e[t+6]=i[6],e[t+7]=i[7],e[t+8]=i[8],e}clone(){return new this.constructor().fromArray(this.elements)}}const Yf=new At;function xE(n){for(let e=n.length-1;e>=0;--e)if(n[e]>=65535)return!0;return!1}function Dc(n){return document.createElementNS("http://www.w3.org/1999/xhtml",n)}function FD(){const n=Dc("canvas");return n.style.display="block",n}const cw={};function T_(n){n in cw||(cw[n]=!0,console.warn(n))}function UD(n,e,t){return new Promise(function(i,r){function s(){switch(n.clientWaitSync(e,n.SYNC_FLUSH_COMMANDS_BIT,0)){case n.WAIT_FAILED:r();break;case n.TIMEOUT_EXPIRED:setTimeout(s,t);break;default:i()}}setTimeout(s,t)})}const uw=new At().set(.8224621,.177538,0,.0331941,.9668058,0,.0170827,.0723974,.9105199),dw=new At().set(1.2249401,-.2249404,0,-.0420569,1.0420571,0,-.0196376,-.0786361,1.0982735),Du={[Sn]:{transfer:hh,primaries:fh,toReference:n=>n,fromReference:n=>n},[on]:{transfer:pn,primaries:fh,toReference:n=>n.convertSRGBToLinear(),fromReference:n=>n.convertLinearToSRGB()},[Hh]:{transfer:hh,primaries:ph,toReference:n=>n.applyMatrix3(dw),fromReference:n=>n.applyMatrix3(uw)},[M_]:{transfer:pn,primaries:ph,toReference:n=>n.convertSRGBToLinear().applyMatrix3(dw),fromReference:n=>n.applyMatrix3(uw).convertLinearToSRGB()}},OD=new Set([Sn,Hh]),Kt={enabled:!0,_workingColorSpace:Sn,get workingColorSpace(){return this._workingColorSpace},set workingColorSpace(n){if(!OD.has(n))throw new Error(`Unsupported working color space, "${n}".`);this._workingColorSpace=n},convert:function(n,e,t){if(this.enabled===!1||e===t||!e||!t)return n;const i=Du[e].toReference,r=Du[t].fromReference;return r(i(n))},fromWorkingColorSpace:function(n,e){return this.convert(n,this._workingColorSpace,e)},toWorkingColorSpace:function(n,e){return this.convert(n,e,this._workingColorSpace)},getPrimaries:function(n){return Du[n].primaries},getTransfer:function(n){return n===ss?hh:Du[n].transfer}};function zo(n){return n<.04045?n*.0773993808:Math.pow(n*.9478672986+.0521327014,2.4)}function $f(n){return n<.0031308?n*12.92:1.055*Math.pow(n,.41666)-.055}let Xa;class ND{static getDataURL(e){if(/^data:/i.test(e.src)||typeof HTMLCanvasElement>"u")return e.src;let t;if(e instanceof HTMLCanvasElement)t=e;else{Xa===void 0&&(Xa=Dc("canvas")),Xa.width=e.width,Xa.height=e.height;const i=Xa.getContext("2d");e instanceof ImageData?i.putImageData(e,0,0):i.drawImage(e,0,0,e.width,e.height),t=Xa}return t.width>2048||t.height>2048?(console.warn("THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons",e),t.toDataURL("image/jpeg",.6)):t.toDataURL("image/png")}static sRGBToLinear(e){if(typeof HTMLImageElement<"u"&&e instanceof HTMLImageElement||typeof HTMLCanvasElement<"u"&&e instanceof HTMLCanvasElement||typeof ImageBitmap<"u"&&e instanceof ImageBitmap){const t=Dc("canvas");t.width=e.width,t.height=e.height;const i=t.getContext("2d");i.drawImage(e,0,0,e.width,e.height);const r=i.getImageData(0,0,e.width,e.height),s=r.data;for(let a=0;a0&&(i.userData=this.userData),t||(e.textures[this.uuid]=i),i}dispose(){this.dispatchEvent({type:"dispose"})}transformUv(e){if(this.mapping!==__)return e;if(e.applyMatrix3(this.matrix),e.x<0||e.x>1)switch(this.wrapS){case Vr:e.x=e.x-Math.floor(e.x);break;case ti:e.x=e.x<0?0:1;break;case dh:Math.abs(Math.floor(e.x)%2)===1?e.x=Math.ceil(e.x)-e.x:e.x=e.x-Math.floor(e.x);break}if(e.y<0||e.y>1)switch(this.wrapT){case Vr:e.y=e.y-Math.floor(e.y);break;case ti:e.y=e.y<0?0:1;break;case dh:Math.abs(Math.floor(e.y)%2)===1?e.y=Math.ceil(e.y)-e.y:e.y=e.y-Math.floor(e.y);break}return this.flipY&&(e.y=1-e.y),e}set needsUpdate(e){e===!0&&(this.version++,this.source.needsUpdate=!0)}set needsPMREMUpdate(e){e===!0&&this.pmremVersion++}}qn.DEFAULT_IMAGE=null;qn.DEFAULT_MAPPING=__;qn.DEFAULT_ANISOTROPY=1;class $t{constructor(e=0,t=0,i=0,r=1){$t.prototype.isVector4=!0,this.x=e,this.y=t,this.z=i,this.w=r}get width(){return this.z}set width(e){this.z=e}get height(){return this.w}set height(e){this.w=e}set(e,t,i,r){return this.x=e,this.y=t,this.z=i,this.w=r,this}setScalar(e){return this.x=e,this.y=e,this.z=e,this.w=e,this}setX(e){return this.x=e,this}setY(e){return this.y=e,this}setZ(e){return this.z=e,this}setW(e){return this.w=e,this}setComponent(e,t){switch(e){case 0:this.x=t;break;case 1:this.y=t;break;case 2:this.z=t;break;case 3:this.w=t;break;default:throw new Error("index is out of range: "+e)}return this}getComponent(e){switch(e){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("index is out of range: "+e)}}clone(){return new this.constructor(this.x,this.y,this.z,this.w)}copy(e){return this.x=e.x,this.y=e.y,this.z=e.z,this.w=e.w!==void 0?e.w:1,this}add(e){return this.x+=e.x,this.y+=e.y,this.z+=e.z,this.w+=e.w,this}addScalar(e){return this.x+=e,this.y+=e,this.z+=e,this.w+=e,this}addVectors(e,t){return this.x=e.x+t.x,this.y=e.y+t.y,this.z=e.z+t.z,this.w=e.w+t.w,this}addScaledVector(e,t){return this.x+=e.x*t,this.y+=e.y*t,this.z+=e.z*t,this.w+=e.w*t,this}sub(e){return this.x-=e.x,this.y-=e.y,this.z-=e.z,this.w-=e.w,this}subScalar(e){return this.x-=e,this.y-=e,this.z-=e,this.w-=e,this}subVectors(e,t){return this.x=e.x-t.x,this.y=e.y-t.y,this.z=e.z-t.z,this.w=e.w-t.w,this}multiply(e){return this.x*=e.x,this.y*=e.y,this.z*=e.z,this.w*=e.w,this}multiplyScalar(e){return this.x*=e,this.y*=e,this.z*=e,this.w*=e,this}applyMatrix4(e){const t=this.x,i=this.y,r=this.z,s=this.w,a=e.elements;return this.x=a[0]*t+a[4]*i+a[8]*r+a[12]*s,this.y=a[1]*t+a[5]*i+a[9]*r+a[13]*s,this.z=a[2]*t+a[6]*i+a[10]*r+a[14]*s,this.w=a[3]*t+a[7]*i+a[11]*r+a[15]*s,this}divideScalar(e){return this.multiplyScalar(1/e)}setAxisAngleFromQuaternion(e){this.w=2*Math.acos(e.w);const t=Math.sqrt(1-e.w*e.w);return t<1e-4?(this.x=1,this.y=0,this.z=0):(this.x=e.x/t,this.y=e.y/t,this.z=e.z/t),this}setAxisAngleFromRotationMatrix(e){let t,i,r,s;const d=e.elements,h=d[0],m=d[4],u=d[8],g=d[1],v=d[5],w=d[9],T=d[2],M=d[6],b=d[10];if(Math.abs(m-g)<.01&&Math.abs(u-T)<.01&&Math.abs(w-M)<.01){if(Math.abs(m+g)<.1&&Math.abs(u+T)<.1&&Math.abs(w+M)<.1&&Math.abs(h+v+b-3)<.1)return this.set(1,0,0,0),this;t=Math.PI;const E=(h+1)/2,P=(v+1)/2,G=(b+1)/2,O=(m+g)/4,B=(u+T)/4,F=(w+M)/4;return E>P&&E>G?E<.01?(i=0,r=.707106781,s=.707106781):(i=Math.sqrt(E),r=O/i,s=B/i):P>G?P<.01?(i=.707106781,r=0,s=.707106781):(r=Math.sqrt(P),i=O/r,s=F/r):G<.01?(i=.707106781,r=.707106781,s=0):(s=Math.sqrt(G),i=B/s,r=F/s),this.set(i,r,s,t),this}let A=Math.sqrt((M-w)*(M-w)+(u-T)*(u-T)+(g-m)*(g-m));return Math.abs(A)<.001&&(A=1),this.x=(M-w)/A,this.y=(u-T)/A,this.z=(g-m)/A,this.w=Math.acos((h+v+b-1)/2),this}setFromMatrixPosition(e){const t=e.elements;return this.x=t[12],this.y=t[13],this.z=t[14],this.w=t[15],this}min(e){return this.x=Math.min(this.x,e.x),this.y=Math.min(this.y,e.y),this.z=Math.min(this.z,e.z),this.w=Math.min(this.w,e.w),this}max(e){return this.x=Math.max(this.x,e.x),this.y=Math.max(this.y,e.y),this.z=Math.max(this.z,e.z),this.w=Math.max(this.w,e.w),this}clamp(e,t){return this.x=Math.max(e.x,Math.min(t.x,this.x)),this.y=Math.max(e.y,Math.min(t.y,this.y)),this.z=Math.max(e.z,Math.min(t.z,this.z)),this.w=Math.max(e.w,Math.min(t.w,this.w)),this}clampScalar(e,t){return this.x=Math.max(e,Math.min(t,this.x)),this.y=Math.max(e,Math.min(t,this.y)),this.z=Math.max(e,Math.min(t,this.z)),this.w=Math.max(e,Math.min(t,this.w)),this}clampLength(e,t){const i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(e,Math.min(t,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this.w=Math.floor(this.w),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this.w=Math.ceil(this.w),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this.w=Math.round(this.w),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this.z=Math.trunc(this.z),this.w=Math.trunc(this.w),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this}dot(e){return this.x*e.x+this.y*e.y+this.z*e.z+this.w*e.w}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)}normalize(){return this.divideScalar(this.length()||1)}setLength(e){return this.normalize().multiplyScalar(e)}lerp(e,t){return this.x+=(e.x-this.x)*t,this.y+=(e.y-this.y)*t,this.z+=(e.z-this.z)*t,this.w+=(e.w-this.w)*t,this}lerpVectors(e,t,i){return this.x=e.x+(t.x-e.x)*i,this.y=e.y+(t.y-e.y)*i,this.z=e.z+(t.z-e.z)*i,this.w=e.w+(t.w-e.w)*i,this}equals(e){return e.x===this.x&&e.y===this.y&&e.z===this.z&&e.w===this.w}fromArray(e,t=0){return this.x=e[t],this.y=e[t+1],this.z=e[t+2],this.w=e[t+3],this}toArray(e=[],t=0){return e[t]=this.x,e[t+1]=this.y,e[t+2]=this.z,e[t+3]=this.w,e}fromBufferAttribute(e,t){return this.x=e.getX(t),this.y=e.getY(t),this.z=e.getZ(t),this.w=e.getW(t),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this.w=Math.random(),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z,yield this.w}}class HD extends ul{constructor(e=1,t=1,i={}){super(),this.isRenderTarget=!0,this.width=e,this.height=t,this.depth=1,this.scissor=new $t(0,0,e,t),this.scissorTest=!1,this.viewport=new $t(0,0,e,t);const r={width:e,height:t,depth:1};i=Object.assign({generateMipmaps:!1,internalFormat:null,minFilter:ln,depthBuffer:!0,stencilBuffer:!1,resolveDepthBuffer:!0,resolveStencilBuffer:!0,depthTexture:null,samples:0,count:1},i);const s=new qn(r,i.mapping,i.wrapS,i.wrapT,i.magFilter,i.minFilter,i.format,i.type,i.anisotropy,i.colorSpace);s.flipY=!1,s.generateMipmaps=i.generateMipmaps,s.internalFormat=i.internalFormat,this.textures=[];const a=i.count;for(let l=0;l=0?1:-1,E=1-b*b;if(E>Number.EPSILON){const G=Math.sqrt(E),O=Math.atan2(G,b*A);M=Math.sin(M*O)/G,l=Math.sin(l*O)/G}const P=l*A;if(d=d*M+g*P,h=h*M+v*P,m=m*M+w*P,u=u*M+T*P,M===1-l){const G=1/Math.sqrt(d*d+h*h+m*m+u*u);d*=G,h*=G,m*=G,u*=G}}e[t]=d,e[t+1]=h,e[t+2]=m,e[t+3]=u}static multiplyQuaternionsFlat(e,t,i,r,s,a){const l=i[r],d=i[r+1],h=i[r+2],m=i[r+3],u=s[a],g=s[a+1],v=s[a+2],w=s[a+3];return e[t]=l*w+m*u+d*v-h*g,e[t+1]=d*w+m*g+h*u-l*v,e[t+2]=h*w+m*v+l*g-d*u,e[t+3]=m*w-l*u-d*g-h*v,e}get x(){return this._x}set x(e){this._x=e,this._onChangeCallback()}get y(){return this._y}set y(e){this._y=e,this._onChangeCallback()}get z(){return this._z}set z(e){this._z=e,this._onChangeCallback()}get w(){return this._w}set w(e){this._w=e,this._onChangeCallback()}set(e,t,i,r){return this._x=e,this._y=t,this._z=i,this._w=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._w)}copy(e){return this._x=e.x,this._y=e.y,this._z=e.z,this._w=e.w,this._onChangeCallback(),this}setFromEuler(e,t=!0){const i=e._x,r=e._y,s=e._z,a=e._order,l=Math.cos,d=Math.sin,h=l(i/2),m=l(r/2),u=l(s/2),g=d(i/2),v=d(r/2),w=d(s/2);switch(a){case"XYZ":this._x=g*m*u+h*v*w,this._y=h*v*u-g*m*w,this._z=h*m*w+g*v*u,this._w=h*m*u-g*v*w;break;case"YXZ":this._x=g*m*u+h*v*w,this._y=h*v*u-g*m*w,this._z=h*m*w-g*v*u,this._w=h*m*u+g*v*w;break;case"ZXY":this._x=g*m*u-h*v*w,this._y=h*v*u+g*m*w,this._z=h*m*w+g*v*u,this._w=h*m*u-g*v*w;break;case"ZYX":this._x=g*m*u-h*v*w,this._y=h*v*u+g*m*w,this._z=h*m*w-g*v*u,this._w=h*m*u+g*v*w;break;case"YZX":this._x=g*m*u+h*v*w,this._y=h*v*u+g*m*w,this._z=h*m*w-g*v*u,this._w=h*m*u-g*v*w;break;case"XZY":this._x=g*m*u-h*v*w,this._y=h*v*u-g*m*w,this._z=h*m*w+g*v*u,this._w=h*m*u+g*v*w;break;default:console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: "+a)}return t===!0&&this._onChangeCallback(),this}setFromAxisAngle(e,t){const i=t/2,r=Math.sin(i);return this._x=e.x*r,this._y=e.y*r,this._z=e.z*r,this._w=Math.cos(i),this._onChangeCallback(),this}setFromRotationMatrix(e){const t=e.elements,i=t[0],r=t[4],s=t[8],a=t[1],l=t[5],d=t[9],h=t[2],m=t[6],u=t[10],g=i+l+u;if(g>0){const v=.5/Math.sqrt(g+1);this._w=.25/v,this._x=(m-d)*v,this._y=(s-h)*v,this._z=(a-r)*v}else if(i>l&&i>u){const v=2*Math.sqrt(1+i-l-u);this._w=(m-d)/v,this._x=.25*v,this._y=(r+a)/v,this._z=(s+h)/v}else if(l>u){const v=2*Math.sqrt(1+l-i-u);this._w=(s-h)/v,this._x=(r+a)/v,this._y=.25*v,this._z=(d+m)/v}else{const v=2*Math.sqrt(1+u-i-l);this._w=(a-r)/v,this._x=(s+h)/v,this._y=(d+m)/v,this._z=.25*v}return this._onChangeCallback(),this}setFromUnitVectors(e,t){let i=e.dot(t)+1;return iMath.abs(e.z)?(this._x=-e.y,this._y=e.x,this._z=0,this._w=i):(this._x=0,this._y=-e.z,this._z=e.y,this._w=i)):(this._x=e.y*t.z-e.z*t.y,this._y=e.z*t.x-e.x*t.z,this._z=e.x*t.y-e.y*t.x,this._w=i),this.normalize()}angleTo(e){return 2*Math.acos(Math.abs(Wn(this.dot(e),-1,1)))}rotateTowards(e,t){const i=this.angleTo(e);if(i===0)return this;const r=Math.min(1,t/i);return this.slerp(e,r),this}identity(){return this.set(0,0,0,1)}invert(){return this.conjugate()}conjugate(){return this._x*=-1,this._y*=-1,this._z*=-1,this._onChangeCallback(),this}dot(e){return this._x*e._x+this._y*e._y+this._z*e._z+this._w*e._w}lengthSq(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w}length(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w)}normalize(){let e=this.length();return e===0?(this._x=0,this._y=0,this._z=0,this._w=1):(e=1/e,this._x=this._x*e,this._y=this._y*e,this._z=this._z*e,this._w=this._w*e),this._onChangeCallback(),this}multiply(e){return this.multiplyQuaternions(this,e)}premultiply(e){return this.multiplyQuaternions(e,this)}multiplyQuaternions(e,t){const i=e._x,r=e._y,s=e._z,a=e._w,l=t._x,d=t._y,h=t._z,m=t._w;return this._x=i*m+a*l+r*h-s*d,this._y=r*m+a*d+s*l-i*h,this._z=s*m+a*h+i*d-r*l,this._w=a*m-i*l-r*d-s*h,this._onChangeCallback(),this}slerp(e,t){if(t===0)return this;if(t===1)return this.copy(e);const i=this._x,r=this._y,s=this._z,a=this._w;let l=a*e._w+i*e._x+r*e._y+s*e._z;if(l<0?(this._w=-e._w,this._x=-e._x,this._y=-e._y,this._z=-e._z,l=-l):this.copy(e),l>=1)return this._w=a,this._x=i,this._y=r,this._z=s,this;const d=1-l*l;if(d<=Number.EPSILON){const v=1-t;return this._w=v*a+t*this._w,this._x=v*i+t*this._x,this._y=v*r+t*this._y,this._z=v*s+t*this._z,this.normalize(),this}const h=Math.sqrt(d),m=Math.atan2(h,l),u=Math.sin((1-t)*m)/h,g=Math.sin(t*m)/h;return this._w=a*u+this._w*g,this._x=i*u+this._x*g,this._y=r*u+this._y*g,this._z=s*u+this._z*g,this._onChangeCallback(),this}slerpQuaternions(e,t,i){return this.copy(e).slerp(t,i)}random(){const e=2*Math.PI*Math.random(),t=2*Math.PI*Math.random(),i=Math.random(),r=Math.sqrt(1-i),s=Math.sqrt(i);return this.set(r*Math.sin(e),r*Math.cos(e),s*Math.sin(t),s*Math.cos(t))}equals(e){return e._x===this._x&&e._y===this._y&&e._z===this._z&&e._w===this._w}fromArray(e,t=0){return this._x=e[t],this._y=e[t+1],this._z=e[t+2],this._w=e[t+3],this._onChangeCallback(),this}toArray(e=[],t=0){return e[t]=this._x,e[t+1]=this._y,e[t+2]=this._z,e[t+3]=this._w,e}fromBufferAttribute(e,t){return this._x=e.getX(t),this._y=e.getY(t),this._z=e.getZ(t),this._w=e.getW(t),this._onChangeCallback(),this}toJSON(){return this.toArray()}_onChange(e){return this._onChangeCallback=e,this}_onChangeCallback(){}*[Symbol.iterator](){yield this._x,yield this._y,yield this._z,yield this._w}}class j{constructor(e=0,t=0,i=0){j.prototype.isVector3=!0,this.x=e,this.y=t,this.z=i}set(e,t,i){return i===void 0&&(i=this.z),this.x=e,this.y=t,this.z=i,this}setScalar(e){return this.x=e,this.y=e,this.z=e,this}setX(e){return this.x=e,this}setY(e){return this.y=e,this}setZ(e){return this.z=e,this}setComponent(e,t){switch(e){case 0:this.x=t;break;case 1:this.y=t;break;case 2:this.z=t;break;default:throw new Error("index is out of range: "+e)}return this}getComponent(e){switch(e){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw new Error("index is out of range: "+e)}}clone(){return new this.constructor(this.x,this.y,this.z)}copy(e){return this.x=e.x,this.y=e.y,this.z=e.z,this}add(e){return this.x+=e.x,this.y+=e.y,this.z+=e.z,this}addScalar(e){return this.x+=e,this.y+=e,this.z+=e,this}addVectors(e,t){return this.x=e.x+t.x,this.y=e.y+t.y,this.z=e.z+t.z,this}addScaledVector(e,t){return this.x+=e.x*t,this.y+=e.y*t,this.z+=e.z*t,this}sub(e){return this.x-=e.x,this.y-=e.y,this.z-=e.z,this}subScalar(e){return this.x-=e,this.y-=e,this.z-=e,this}subVectors(e,t){return this.x=e.x-t.x,this.y=e.y-t.y,this.z=e.z-t.z,this}multiply(e){return this.x*=e.x,this.y*=e.y,this.z*=e.z,this}multiplyScalar(e){return this.x*=e,this.y*=e,this.z*=e,this}multiplyVectors(e,t){return this.x=e.x*t.x,this.y=e.y*t.y,this.z=e.z*t.z,this}applyEuler(e){return this.applyQuaternion(hw.setFromEuler(e))}applyAxisAngle(e,t){return this.applyQuaternion(hw.setFromAxisAngle(e,t))}applyMatrix3(e){const t=this.x,i=this.y,r=this.z,s=e.elements;return this.x=s[0]*t+s[3]*i+s[6]*r,this.y=s[1]*t+s[4]*i+s[7]*r,this.z=s[2]*t+s[5]*i+s[8]*r,this}applyNormalMatrix(e){return this.applyMatrix3(e).normalize()}applyMatrix4(e){const t=this.x,i=this.y,r=this.z,s=e.elements,a=1/(s[3]*t+s[7]*i+s[11]*r+s[15]);return this.x=(s[0]*t+s[4]*i+s[8]*r+s[12])*a,this.y=(s[1]*t+s[5]*i+s[9]*r+s[13])*a,this.z=(s[2]*t+s[6]*i+s[10]*r+s[14])*a,this}applyQuaternion(e){const t=this.x,i=this.y,r=this.z,s=e.x,a=e.y,l=e.z,d=e.w,h=2*(a*r-l*i),m=2*(l*t-s*r),u=2*(s*i-a*t);return this.x=t+d*h+a*u-l*m,this.y=i+d*m+l*h-s*u,this.z=r+d*u+s*m-a*h,this}project(e){return this.applyMatrix4(e.matrixWorldInverse).applyMatrix4(e.projectionMatrix)}unproject(e){return this.applyMatrix4(e.projectionMatrixInverse).applyMatrix4(e.matrixWorld)}transformDirection(e){const t=this.x,i=this.y,r=this.z,s=e.elements;return this.x=s[0]*t+s[4]*i+s[8]*r,this.y=s[1]*t+s[5]*i+s[9]*r,this.z=s[2]*t+s[6]*i+s[10]*r,this.normalize()}divide(e){return this.x/=e.x,this.y/=e.y,this.z/=e.z,this}divideScalar(e){return this.multiplyScalar(1/e)}min(e){return this.x=Math.min(this.x,e.x),this.y=Math.min(this.y,e.y),this.z=Math.min(this.z,e.z),this}max(e){return this.x=Math.max(this.x,e.x),this.y=Math.max(this.y,e.y),this.z=Math.max(this.z,e.z),this}clamp(e,t){return this.x=Math.max(e.x,Math.min(t.x,this.x)),this.y=Math.max(e.y,Math.min(t.y,this.y)),this.z=Math.max(e.z,Math.min(t.z,this.z)),this}clampScalar(e,t){return this.x=Math.max(e,Math.min(t,this.x)),this.y=Math.max(e,Math.min(t,this.y)),this.z=Math.max(e,Math.min(t,this.z)),this}clampLength(e,t){const i=this.length();return this.divideScalar(i||1).multiplyScalar(Math.max(e,Math.min(t,i)))}floor(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this.z=Math.floor(this.z),this}ceil(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this.z=Math.ceil(this.z),this}round(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this.z=Math.round(this.z),this}roundToZero(){return this.x=Math.trunc(this.x),this.y=Math.trunc(this.y),this.z=Math.trunc(this.z),this}negate(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this}dot(e){return this.x*e.x+this.y*e.y+this.z*e.z}lengthSq(){return this.x*this.x+this.y*this.y+this.z*this.z}length(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)}manhattanLength(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)}normalize(){return this.divideScalar(this.length()||1)}setLength(e){return this.normalize().multiplyScalar(e)}lerp(e,t){return this.x+=(e.x-this.x)*t,this.y+=(e.y-this.y)*t,this.z+=(e.z-this.z)*t,this}lerpVectors(e,t,i){return this.x=e.x+(t.x-e.x)*i,this.y=e.y+(t.y-e.y)*i,this.z=e.z+(t.z-e.z)*i,this}cross(e){return this.crossVectors(this,e)}crossVectors(e,t){const i=e.x,r=e.y,s=e.z,a=t.x,l=t.y,d=t.z;return this.x=r*d-s*l,this.y=s*a-i*d,this.z=i*l-r*a,this}projectOnVector(e){const t=e.lengthSq();if(t===0)return this.set(0,0,0);const i=e.dot(this)/t;return this.copy(e).multiplyScalar(i)}projectOnPlane(e){return Kf.copy(this).projectOnVector(e),this.sub(Kf)}reflect(e){return this.sub(Kf.copy(e).multiplyScalar(2*this.dot(e)))}angleTo(e){const t=Math.sqrt(this.lengthSq()*e.lengthSq());if(t===0)return Math.PI/2;const i=this.dot(e)/t;return Math.acos(Wn(i,-1,1))}distanceTo(e){return Math.sqrt(this.distanceToSquared(e))}distanceToSquared(e){const t=this.x-e.x,i=this.y-e.y,r=this.z-e.z;return t*t+i*i+r*r}manhattanDistanceTo(e){return Math.abs(this.x-e.x)+Math.abs(this.y-e.y)+Math.abs(this.z-e.z)}setFromSpherical(e){return this.setFromSphericalCoords(e.radius,e.phi,e.theta)}setFromSphericalCoords(e,t,i){const r=Math.sin(t)*e;return this.x=r*Math.sin(i),this.y=Math.cos(t)*e,this.z=r*Math.cos(i),this}setFromCylindrical(e){return this.setFromCylindricalCoords(e.radius,e.theta,e.y)}setFromCylindricalCoords(e,t,i){return this.x=e*Math.sin(t),this.y=i,this.z=e*Math.cos(t),this}setFromMatrixPosition(e){const t=e.elements;return this.x=t[12],this.y=t[13],this.z=t[14],this}setFromMatrixScale(e){const t=this.setFromMatrixColumn(e,0).length(),i=this.setFromMatrixColumn(e,1).length(),r=this.setFromMatrixColumn(e,2).length();return this.x=t,this.y=i,this.z=r,this}setFromMatrixColumn(e,t){return this.fromArray(e.elements,t*4)}setFromMatrix3Column(e,t){return this.fromArray(e.elements,t*3)}setFromEuler(e){return this.x=e._x,this.y=e._y,this.z=e._z,this}setFromColor(e){return this.x=e.r,this.y=e.g,this.z=e.b,this}equals(e){return e.x===this.x&&e.y===this.y&&e.z===this.z}fromArray(e,t=0){return this.x=e[t],this.y=e[t+1],this.z=e[t+2],this}toArray(e=[],t=0){return e[t]=this.x,e[t+1]=this.y,e[t+2]=this.z,e}fromBufferAttribute(e,t){return this.x=e.getX(t),this.y=e.getY(t),this.z=e.getZ(t),this}random(){return this.x=Math.random(),this.y=Math.random(),this.z=Math.random(),this}randomDirection(){const e=Math.random()*Math.PI*2,t=Math.random()*2-1,i=Math.sqrt(1-t*t);return this.x=i*Math.cos(e),this.y=t,this.z=i*Math.sin(e),this}*[Symbol.iterator](){yield this.x,yield this.y,yield this.z}}const Kf=new j,hw=new Gn;class Pr{constructor(e=new j(1/0,1/0,1/0),t=new j(-1/0,-1/0,-1/0)){this.isBox3=!0,this.min=e,this.max=t}set(e,t){return this.min.copy(e),this.max.copy(t),this}setFromArray(e){this.makeEmpty();for(let t=0,i=e.length;tthis.max.x||e.ythis.max.y||e.zthis.max.z)}containsBox(e){return this.min.x<=e.min.x&&e.max.x<=this.max.x&&this.min.y<=e.min.y&&e.max.y<=this.max.y&&this.min.z<=e.min.z&&e.max.z<=this.max.z}getParameter(e,t){return t.set((e.x-this.min.x)/(this.max.x-this.min.x),(e.y-this.min.y)/(this.max.y-this.min.y),(e.z-this.min.z)/(this.max.z-this.min.z))}intersectsBox(e){return!(e.max.xthis.max.x||e.max.ythis.max.y||e.max.zthis.max.z)}intersectsSphere(e){return this.clampPoint(e.center,mr),mr.distanceToSquared(e.center)<=e.radius*e.radius}intersectsPlane(e){let t,i;return e.normal.x>0?(t=e.normal.x*this.min.x,i=e.normal.x*this.max.x):(t=e.normal.x*this.max.x,i=e.normal.x*this.min.x),e.normal.y>0?(t+=e.normal.y*this.min.y,i+=e.normal.y*this.max.y):(t+=e.normal.y*this.max.y,i+=e.normal.y*this.min.y),e.normal.z>0?(t+=e.normal.z*this.min.z,i+=e.normal.z*this.max.z):(t+=e.normal.z*this.max.z,i+=e.normal.z*this.min.z),t<=-e.constant&&i>=-e.constant}intersectsTriangle(e){if(this.isEmpty())return!1;this.getCenter(kl),Fu.subVectors(this.max,kl),Ya.subVectors(e.a,kl),$a.subVectors(e.b,kl),qa.subVectors(e.c,kl),Ss.subVectors($a,Ya),Ms.subVectors(qa,$a),oa.subVectors(Ya,qa);let t=[0,-Ss.z,Ss.y,0,-Ms.z,Ms.y,0,-oa.z,oa.y,Ss.z,0,-Ss.x,Ms.z,0,-Ms.x,oa.z,0,-oa.x,-Ss.y,Ss.x,0,-Ms.y,Ms.x,0,-oa.y,oa.x,0];return!Zf(t,Ya,$a,qa,Fu)||(t=[1,0,0,0,1,0,0,0,1],!Zf(t,Ya,$a,qa,Fu))?!1:(Uu.crossVectors(Ss,Ms),t=[Uu.x,Uu.y,Uu.z],Zf(t,Ya,$a,qa,Fu))}clampPoint(e,t){return t.copy(e).clamp(this.min,this.max)}distanceToPoint(e){return this.clampPoint(e,mr).distanceTo(e)}getBoundingSphere(e){return this.isEmpty()?e.makeEmpty():(this.getCenter(e.center),e.radius=this.getSize(mr).length()*.5),e}intersect(e){return this.min.max(e.min),this.max.min(e.max),this.isEmpty()&&this.makeEmpty(),this}union(e){return this.min.min(e.min),this.max.max(e.max),this}applyMatrix4(e){return this.isEmpty()?this:(qr[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(e),qr[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(e),qr[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(e),qr[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(e),qr[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(e),qr[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(e),qr[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(e),qr[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(e),this.setFromPoints(qr),this)}translate(e){return this.min.add(e),this.max.add(e),this}equals(e){return e.min.equals(this.min)&&e.max.equals(this.max)}}const qr=[new j,new j,new j,new j,new j,new j,new j,new j],mr=new j,ku=new Pr,Ya=new j,$a=new j,qa=new j,Ss=new j,Ms=new j,oa=new j,kl=new j,Fu=new j,Uu=new j,la=new j;function Zf(n,e,t,i,r){for(let s=0,a=n.length-3;s<=a;s+=3){la.fromArray(n,s);const l=r.x*Math.abs(la.x)+r.y*Math.abs(la.y)+r.z*Math.abs(la.z),d=e.dot(la),h=t.dot(la),m=i.dot(la);if(Math.max(-Math.max(d,h,m),Math.min(d,h,m))>l)return!1}return!0}const VD=new Pr,Fl=new j,Qf=new j;class Wr{constructor(e=new j,t=-1){this.isSphere=!0,this.center=e,this.radius=t}set(e,t){return this.center.copy(e),this.radius=t,this}setFromPoints(e,t){const i=this.center;t!==void 0?i.copy(t):VD.setFromPoints(e).getCenter(i);let r=0;for(let s=0,a=e.length;sthis.radius*this.radius&&(t.sub(this.center).normalize(),t.multiplyScalar(this.radius).add(this.center)),t}getBoundingBox(e){return this.isEmpty()?(e.makeEmpty(),e):(e.set(this.center,this.center),e.expandByScalar(this.radius),e)}applyMatrix4(e){return this.center.applyMatrix4(e),this.radius=this.radius*e.getMaxScaleOnAxis(),this}translate(e){return this.center.add(e),this}expandByPoint(e){if(this.isEmpty())return this.center.copy(e),this.radius=0,this;Fl.subVectors(e,this.center);const t=Fl.lengthSq();if(t>this.radius*this.radius){const i=Math.sqrt(t),r=(i-this.radius)*.5;this.center.addScaledVector(Fl,r/i),this.radius+=r}return this}union(e){return e.isEmpty()?this:this.isEmpty()?(this.copy(e),this):(this.center.equals(e.center)===!0?this.radius=Math.max(this.radius,e.radius):(Qf.subVectors(e.center,this.center).setLength(e.radius),this.expandByPoint(Fl.copy(e.center).add(Qf)),this.expandByPoint(Fl.copy(e.center).sub(Qf))),this)}equals(e){return e.center.equals(this.center)&&e.radius===this.radius}clone(){return new this.constructor().copy(this)}}const Kr=new j,Jf=new j,Ou=new j,Es=new j,ep=new j,Nu=new j,tp=new j;class jc{constructor(e=new j,t=new j(0,0,-1)){this.origin=e,this.direction=t}set(e,t){return this.origin.copy(e),this.direction.copy(t),this}copy(e){return this.origin.copy(e.origin),this.direction.copy(e.direction),this}at(e,t){return t.copy(this.origin).addScaledVector(this.direction,e)}lookAt(e){return this.direction.copy(e).sub(this.origin).normalize(),this}recast(e){return this.origin.copy(this.at(e,Kr)),this}closestPointToPoint(e,t){t.subVectors(e,this.origin);const i=t.dot(this.direction);return i<0?t.copy(this.origin):t.copy(this.origin).addScaledVector(this.direction,i)}distanceToPoint(e){return Math.sqrt(this.distanceSqToPoint(e))}distanceSqToPoint(e){const t=Kr.subVectors(e,this.origin).dot(this.direction);return t<0?this.origin.distanceToSquared(e):(Kr.copy(this.origin).addScaledVector(this.direction,t),Kr.distanceToSquared(e))}distanceSqToSegment(e,t,i,r){Jf.copy(e).add(t).multiplyScalar(.5),Ou.copy(t).sub(e).normalize(),Es.copy(this.origin).sub(Jf);const s=e.distanceTo(t)*.5,a=-this.direction.dot(Ou),l=Es.dot(this.direction),d=-Es.dot(Ou),h=Es.lengthSq(),m=Math.abs(1-a*a);let u,g,v,w;if(m>0)if(u=a*d-l,g=a*l-d,w=s*m,u>=0)if(g>=-w)if(g<=w){const T=1/m;u*=T,g*=T,v=u*(u+a*g+2*l)+g*(a*u+g+2*d)+h}else g=s,u=Math.max(0,-(a*g+l)),v=-u*u+g*(g+2*d)+h;else g=-s,u=Math.max(0,-(a*g+l)),v=-u*u+g*(g+2*d)+h;else g<=-w?(u=Math.max(0,-(-a*s+l)),g=u>0?-s:Math.min(Math.max(-s,-d),s),v=-u*u+g*(g+2*d)+h):g<=w?(u=0,g=Math.min(Math.max(-s,-d),s),v=g*(g+2*d)+h):(u=Math.max(0,-(a*s+l)),g=u>0?s:Math.min(Math.max(-s,-d),s),v=-u*u+g*(g+2*d)+h);else g=a>0?-s:s,u=Math.max(0,-(a*g+l)),v=-u*u+g*(g+2*d)+h;return i&&i.copy(this.origin).addScaledVector(this.direction,u),r&&r.copy(Jf).addScaledVector(Ou,g),v}intersectSphere(e,t){Kr.subVectors(e.center,this.origin);const i=Kr.dot(this.direction),r=Kr.dot(Kr)-i*i,s=e.radius*e.radius;if(r>s)return null;const a=Math.sqrt(s-r),l=i-a,d=i+a;return d<0?null:l<0?this.at(d,t):this.at(l,t)}intersectsSphere(e){return this.distanceSqToPoint(e.center)<=e.radius*e.radius}distanceToPlane(e){const t=e.normal.dot(this.direction);if(t===0)return e.distanceToPoint(this.origin)===0?0:null;const i=-(this.origin.dot(e.normal)+e.constant)/t;return i>=0?i:null}intersectPlane(e,t){const i=this.distanceToPlane(e);return i===null?null:this.at(i,t)}intersectsPlane(e){const t=e.distanceToPoint(this.origin);return t===0||e.normal.dot(this.direction)*t<0}intersectBox(e,t){let i,r,s,a,l,d;const h=1/this.direction.x,m=1/this.direction.y,u=1/this.direction.z,g=this.origin;return h>=0?(i=(e.min.x-g.x)*h,r=(e.max.x-g.x)*h):(i=(e.max.x-g.x)*h,r=(e.min.x-g.x)*h),m>=0?(s=(e.min.y-g.y)*m,a=(e.max.y-g.y)*m):(s=(e.max.y-g.y)*m,a=(e.min.y-g.y)*m),i>a||s>r||((s>i||isNaN(i))&&(i=s),(a=0?(l=(e.min.z-g.z)*u,d=(e.max.z-g.z)*u):(l=(e.max.z-g.z)*u,d=(e.min.z-g.z)*u),i>d||l>r)||((l>i||i!==i)&&(i=l),(d=0?i:r,t)}intersectsBox(e){return this.intersectBox(e,Kr)!==null}intersectTriangle(e,t,i,r,s){ep.subVectors(t,e),Nu.subVectors(i,e),tp.crossVectors(ep,Nu);let a=this.direction.dot(tp),l;if(a>0){if(r)return null;l=1}else if(a<0)l=-1,a=-a;else return null;Es.subVectors(this.origin,e);const d=l*this.direction.dot(Nu.crossVectors(Es,Nu));if(d<0)return null;const h=l*this.direction.dot(ep.cross(Es));if(h<0||d+h>a)return null;const m=-l*Es.dot(tp);return m<0?null:this.at(m/a,s)}applyMatrix4(e){return this.origin.applyMatrix4(e),this.direction.transformDirection(e),this}equals(e){return e.origin.equals(this.origin)&&e.direction.equals(this.direction)}clone(){return new this.constructor().copy(this)}}class ot{constructor(e,t,i,r,s,a,l,d,h,m,u,g,v,w,T,M){ot.prototype.isMatrix4=!0,this.elements=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],e!==void 0&&this.set(e,t,i,r,s,a,l,d,h,m,u,g,v,w,T,M)}set(e,t,i,r,s,a,l,d,h,m,u,g,v,w,T,M){const b=this.elements;return b[0]=e,b[4]=t,b[8]=i,b[12]=r,b[1]=s,b[5]=a,b[9]=l,b[13]=d,b[2]=h,b[6]=m,b[10]=u,b[14]=g,b[3]=v,b[7]=w,b[11]=T,b[15]=M,this}identity(){return this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1),this}clone(){return new ot().fromArray(this.elements)}copy(e){const t=this.elements,i=e.elements;return t[0]=i[0],t[1]=i[1],t[2]=i[2],t[3]=i[3],t[4]=i[4],t[5]=i[5],t[6]=i[6],t[7]=i[7],t[8]=i[8],t[9]=i[9],t[10]=i[10],t[11]=i[11],t[12]=i[12],t[13]=i[13],t[14]=i[14],t[15]=i[15],this}copyPosition(e){const t=this.elements,i=e.elements;return t[12]=i[12],t[13]=i[13],t[14]=i[14],this}setFromMatrix3(e){const t=e.elements;return this.set(t[0],t[3],t[6],0,t[1],t[4],t[7],0,t[2],t[5],t[8],0,0,0,0,1),this}extractBasis(e,t,i){return e.setFromMatrixColumn(this,0),t.setFromMatrixColumn(this,1),i.setFromMatrixColumn(this,2),this}makeBasis(e,t,i){return this.set(e.x,t.x,i.x,0,e.y,t.y,i.y,0,e.z,t.z,i.z,0,0,0,0,1),this}extractRotation(e){const t=this.elements,i=e.elements,r=1/Ka.setFromMatrixColumn(e,0).length(),s=1/Ka.setFromMatrixColumn(e,1).length(),a=1/Ka.setFromMatrixColumn(e,2).length();return t[0]=i[0]*r,t[1]=i[1]*r,t[2]=i[2]*r,t[3]=0,t[4]=i[4]*s,t[5]=i[5]*s,t[6]=i[6]*s,t[7]=0,t[8]=i[8]*a,t[9]=i[9]*a,t[10]=i[10]*a,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,this}makeRotationFromEuler(e){const t=this.elements,i=e.x,r=e.y,s=e.z,a=Math.cos(i),l=Math.sin(i),d=Math.cos(r),h=Math.sin(r),m=Math.cos(s),u=Math.sin(s);if(e.order==="XYZ"){const g=a*m,v=a*u,w=l*m,T=l*u;t[0]=d*m,t[4]=-d*u,t[8]=h,t[1]=v+w*h,t[5]=g-T*h,t[9]=-l*d,t[2]=T-g*h,t[6]=w+v*h,t[10]=a*d}else if(e.order==="YXZ"){const g=d*m,v=d*u,w=h*m,T=h*u;t[0]=g+T*l,t[4]=w*l-v,t[8]=a*h,t[1]=a*u,t[5]=a*m,t[9]=-l,t[2]=v*l-w,t[6]=T+g*l,t[10]=a*d}else if(e.order==="ZXY"){const g=d*m,v=d*u,w=h*m,T=h*u;t[0]=g-T*l,t[4]=-a*u,t[8]=w+v*l,t[1]=v+w*l,t[5]=a*m,t[9]=T-g*l,t[2]=-a*h,t[6]=l,t[10]=a*d}else if(e.order==="ZYX"){const g=a*m,v=a*u,w=l*m,T=l*u;t[0]=d*m,t[4]=w*h-v,t[8]=g*h+T,t[1]=d*u,t[5]=T*h+g,t[9]=v*h-w,t[2]=-h,t[6]=l*d,t[10]=a*d}else if(e.order==="YZX"){const g=a*d,v=a*h,w=l*d,T=l*h;t[0]=d*m,t[4]=T-g*u,t[8]=w*u+v,t[1]=u,t[5]=a*m,t[9]=-l*m,t[2]=-h*m,t[6]=v*u+w,t[10]=g-T*u}else if(e.order==="XZY"){const g=a*d,v=a*h,w=l*d,T=l*h;t[0]=d*m,t[4]=-u,t[8]=h*m,t[1]=g*u+T,t[5]=a*m,t[9]=v*u-w,t[2]=w*u-v,t[6]=l*m,t[10]=T*u+g}return t[3]=0,t[7]=0,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,this}makeRotationFromQuaternion(e){return this.compose(WD,e,jD)}lookAt(e,t,i){const r=this.elements;return Vi.subVectors(e,t),Vi.lengthSq()===0&&(Vi.z=1),Vi.normalize(),Ts.crossVectors(i,Vi),Ts.lengthSq()===0&&(Math.abs(i.z)===1?Vi.x+=1e-4:Vi.z+=1e-4,Vi.normalize(),Ts.crossVectors(i,Vi)),Ts.normalize(),Bu.crossVectors(Vi,Ts),r[0]=Ts.x,r[4]=Bu.x,r[8]=Vi.x,r[1]=Ts.y,r[5]=Bu.y,r[9]=Vi.y,r[2]=Ts.z,r[6]=Bu.z,r[10]=Vi.z,this}multiply(e){return this.multiplyMatrices(this,e)}premultiply(e){return this.multiplyMatrices(e,this)}multiplyMatrices(e,t){const i=e.elements,r=t.elements,s=this.elements,a=i[0],l=i[4],d=i[8],h=i[12],m=i[1],u=i[5],g=i[9],v=i[13],w=i[2],T=i[6],M=i[10],b=i[14],A=i[3],E=i[7],P=i[11],G=i[15],O=r[0],B=r[4],F=r[8],D=r[12],L=r[1],V=r[5],ie=r[9],re=r[13],de=r[2],me=r[6],$=r[10],ue=r[14],Y=r[3],pe=r[7],_e=r[11],Ae=r[15];return s[0]=a*O+l*L+d*de+h*Y,s[4]=a*B+l*V+d*me+h*pe,s[8]=a*F+l*ie+d*$+h*_e,s[12]=a*D+l*re+d*ue+h*Ae,s[1]=m*O+u*L+g*de+v*Y,s[5]=m*B+u*V+g*me+v*pe,s[9]=m*F+u*ie+g*$+v*_e,s[13]=m*D+u*re+g*ue+v*Ae,s[2]=w*O+T*L+M*de+b*Y,s[6]=w*B+T*V+M*me+b*pe,s[10]=w*F+T*ie+M*$+b*_e,s[14]=w*D+T*re+M*ue+b*Ae,s[3]=A*O+E*L+P*de+G*Y,s[7]=A*B+E*V+P*me+G*pe,s[11]=A*F+E*ie+P*$+G*_e,s[15]=A*D+E*re+P*ue+G*Ae,this}multiplyScalar(e){const t=this.elements;return t[0]*=e,t[4]*=e,t[8]*=e,t[12]*=e,t[1]*=e,t[5]*=e,t[9]*=e,t[13]*=e,t[2]*=e,t[6]*=e,t[10]*=e,t[14]*=e,t[3]*=e,t[7]*=e,t[11]*=e,t[15]*=e,this}determinant(){const e=this.elements,t=e[0],i=e[4],r=e[8],s=e[12],a=e[1],l=e[5],d=e[9],h=e[13],m=e[2],u=e[6],g=e[10],v=e[14],w=e[3],T=e[7],M=e[11],b=e[15];return w*(+s*d*u-r*h*u-s*l*g+i*h*g+r*l*v-i*d*v)+T*(+t*d*v-t*h*g+s*a*g-r*a*v+r*h*m-s*d*m)+M*(+t*h*u-t*l*v-s*a*u+i*a*v+s*l*m-i*h*m)+b*(-r*l*m-t*d*u+t*l*g+r*a*u-i*a*g+i*d*m)}transpose(){const e=this.elements;let t;return t=e[1],e[1]=e[4],e[4]=t,t=e[2],e[2]=e[8],e[8]=t,t=e[6],e[6]=e[9],e[9]=t,t=e[3],e[3]=e[12],e[12]=t,t=e[7],e[7]=e[13],e[13]=t,t=e[11],e[11]=e[14],e[14]=t,this}setPosition(e,t,i){const r=this.elements;return e.isVector3?(r[12]=e.x,r[13]=e.y,r[14]=e.z):(r[12]=e,r[13]=t,r[14]=i),this}invert(){const e=this.elements,t=e[0],i=e[1],r=e[2],s=e[3],a=e[4],l=e[5],d=e[6],h=e[7],m=e[8],u=e[9],g=e[10],v=e[11],w=e[12],T=e[13],M=e[14],b=e[15],A=u*M*h-T*g*h+T*d*v-l*M*v-u*d*b+l*g*b,E=w*g*h-m*M*h-w*d*v+a*M*v+m*d*b-a*g*b,P=m*T*h-w*u*h+w*l*v-a*T*v-m*l*b+a*u*b,G=w*u*d-m*T*d-w*l*g+a*T*g+m*l*M-a*u*M,O=t*A+i*E+r*P+s*G;if(O===0)return this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);const B=1/O;return e[0]=A*B,e[1]=(T*g*s-u*M*s-T*r*v+i*M*v+u*r*b-i*g*b)*B,e[2]=(l*M*s-T*d*s+T*r*h-i*M*h-l*r*b+i*d*b)*B,e[3]=(u*d*s-l*g*s-u*r*h+i*g*h+l*r*v-i*d*v)*B,e[4]=E*B,e[5]=(m*M*s-w*g*s+w*r*v-t*M*v-m*r*b+t*g*b)*B,e[6]=(w*d*s-a*M*s-w*r*h+t*M*h+a*r*b-t*d*b)*B,e[7]=(a*g*s-m*d*s+m*r*h-t*g*h-a*r*v+t*d*v)*B,e[8]=P*B,e[9]=(w*u*s-m*T*s-w*i*v+t*T*v+m*i*b-t*u*b)*B,e[10]=(a*T*s-w*l*s+w*i*h-t*T*h-a*i*b+t*l*b)*B,e[11]=(m*l*s-a*u*s-m*i*h+t*u*h+a*i*v-t*l*v)*B,e[12]=G*B,e[13]=(m*T*r-w*u*r+w*i*g-t*T*g-m*i*M+t*u*M)*B,e[14]=(w*l*r-a*T*r-w*i*d+t*T*d+a*i*M-t*l*M)*B,e[15]=(a*u*r-m*l*r+m*i*d-t*u*d-a*i*g+t*l*g)*B,this}scale(e){const t=this.elements,i=e.x,r=e.y,s=e.z;return t[0]*=i,t[4]*=r,t[8]*=s,t[1]*=i,t[5]*=r,t[9]*=s,t[2]*=i,t[6]*=r,t[10]*=s,t[3]*=i,t[7]*=r,t[11]*=s,this}getMaxScaleOnAxis(){const e=this.elements,t=e[0]*e[0]+e[1]*e[1]+e[2]*e[2],i=e[4]*e[4]+e[5]*e[5]+e[6]*e[6],r=e[8]*e[8]+e[9]*e[9]+e[10]*e[10];return Math.sqrt(Math.max(t,i,r))}makeTranslation(e,t,i){return e.isVector3?this.set(1,0,0,e.x,0,1,0,e.y,0,0,1,e.z,0,0,0,1):this.set(1,0,0,e,0,1,0,t,0,0,1,i,0,0,0,1),this}makeRotationX(e){const t=Math.cos(e),i=Math.sin(e);return this.set(1,0,0,0,0,t,-i,0,0,i,t,0,0,0,0,1),this}makeRotationY(e){const t=Math.cos(e),i=Math.sin(e);return this.set(t,0,i,0,0,1,0,0,-i,0,t,0,0,0,0,1),this}makeRotationZ(e){const t=Math.cos(e),i=Math.sin(e);return this.set(t,-i,0,0,i,t,0,0,0,0,1,0,0,0,0,1),this}makeRotationAxis(e,t){const i=Math.cos(t),r=Math.sin(t),s=1-i,a=e.x,l=e.y,d=e.z,h=s*a,m=s*l;return this.set(h*a+i,h*l-r*d,h*d+r*l,0,h*l+r*d,m*l+i,m*d-r*a,0,h*d-r*l,m*d+r*a,s*d*d+i,0,0,0,0,1),this}makeScale(e,t,i){return this.set(e,0,0,0,0,t,0,0,0,0,i,0,0,0,0,1),this}makeShear(e,t,i,r,s,a){return this.set(1,i,s,0,e,1,a,0,t,r,1,0,0,0,0,1),this}compose(e,t,i){const r=this.elements,s=t._x,a=t._y,l=t._z,d=t._w,h=s+s,m=a+a,u=l+l,g=s*h,v=s*m,w=s*u,T=a*m,M=a*u,b=l*u,A=d*h,E=d*m,P=d*u,G=i.x,O=i.y,B=i.z;return r[0]=(1-(T+b))*G,r[1]=(v+P)*G,r[2]=(w-E)*G,r[3]=0,r[4]=(v-P)*O,r[5]=(1-(g+b))*O,r[6]=(M+A)*O,r[7]=0,r[8]=(w+E)*B,r[9]=(M-A)*B,r[10]=(1-(g+T))*B,r[11]=0,r[12]=e.x,r[13]=e.y,r[14]=e.z,r[15]=1,this}decompose(e,t,i){const r=this.elements;let s=Ka.set(r[0],r[1],r[2]).length();const a=Ka.set(r[4],r[5],r[6]).length(),l=Ka.set(r[8],r[9],r[10]).length();this.determinant()<0&&(s=-s),e.x=r[12],e.y=r[13],e.z=r[14],gr.copy(this);const h=1/s,m=1/a,u=1/l;return gr.elements[0]*=h,gr.elements[1]*=h,gr.elements[2]*=h,gr.elements[4]*=m,gr.elements[5]*=m,gr.elements[6]*=m,gr.elements[8]*=u,gr.elements[9]*=u,gr.elements[10]*=u,t.setFromRotationMatrix(gr),i.x=s,i.y=a,i.z=l,this}makePerspective(e,t,i,r,s,a,l=cs){const d=this.elements,h=2*s/(t-e),m=2*s/(i-r),u=(t+e)/(t-e),g=(i+r)/(i-r);let v,w;if(l===cs)v=-(a+s)/(a-s),w=-2*a*s/(a-s);else if(l===mh)v=-a/(a-s),w=-a*s/(a-s);else throw new Error("THREE.Matrix4.makePerspective(): Invalid coordinate system: "+l);return d[0]=h,d[4]=0,d[8]=u,d[12]=0,d[1]=0,d[5]=m,d[9]=g,d[13]=0,d[2]=0,d[6]=0,d[10]=v,d[14]=w,d[3]=0,d[7]=0,d[11]=-1,d[15]=0,this}makeOrthographic(e,t,i,r,s,a,l=cs){const d=this.elements,h=1/(t-e),m=1/(i-r),u=1/(a-s),g=(t+e)*h,v=(i+r)*m;let w,T;if(l===cs)w=(a+s)*u,T=-2*u;else if(l===mh)w=s*u,T=-1*u;else throw new Error("THREE.Matrix4.makeOrthographic(): Invalid coordinate system: "+l);return d[0]=2*h,d[4]=0,d[8]=0,d[12]=-g,d[1]=0,d[5]=2*m,d[9]=0,d[13]=-v,d[2]=0,d[6]=0,d[10]=T,d[14]=-w,d[3]=0,d[7]=0,d[11]=0,d[15]=1,this}equals(e){const t=this.elements,i=e.elements;for(let r=0;r<16;r++)if(t[r]!==i[r])return!1;return!0}fromArray(e,t=0){for(let i=0;i<16;i++)this.elements[i]=e[i+t];return this}toArray(e=[],t=0){const i=this.elements;return e[t]=i[0],e[t+1]=i[1],e[t+2]=i[2],e[t+3]=i[3],e[t+4]=i[4],e[t+5]=i[5],e[t+6]=i[6],e[t+7]=i[7],e[t+8]=i[8],e[t+9]=i[9],e[t+10]=i[10],e[t+11]=i[11],e[t+12]=i[12],e[t+13]=i[13],e[t+14]=i[14],e[t+15]=i[15],e}}const Ka=new j,gr=new ot,WD=new j(0,0,0),jD=new j(1,1,1),Ts=new j,Bu=new j,Vi=new j,fw=new ot,pw=new Gn;class Pn{constructor(e=0,t=0,i=0,r=Pn.DEFAULT_ORDER){this.isEuler=!0,this._x=e,this._y=t,this._z=i,this._order=r}get x(){return this._x}set x(e){this._x=e,this._onChangeCallback()}get y(){return this._y}set y(e){this._y=e,this._onChangeCallback()}get z(){return this._z}set z(e){this._z=e,this._onChangeCallback()}get order(){return this._order}set order(e){this._order=e,this._onChangeCallback()}set(e,t,i,r=this._order){return this._x=e,this._y=t,this._z=i,this._order=r,this._onChangeCallback(),this}clone(){return new this.constructor(this._x,this._y,this._z,this._order)}copy(e){return this._x=e._x,this._y=e._y,this._z=e._z,this._order=e._order,this._onChangeCallback(),this}setFromRotationMatrix(e,t=this._order,i=!0){const r=e.elements,s=r[0],a=r[4],l=r[8],d=r[1],h=r[5],m=r[9],u=r[2],g=r[6],v=r[10];switch(t){case"XYZ":this._y=Math.asin(Wn(l,-1,1)),Math.abs(l)<.9999999?(this._x=Math.atan2(-m,v),this._z=Math.atan2(-a,s)):(this._x=Math.atan2(g,h),this._z=0);break;case"YXZ":this._x=Math.asin(-Wn(m,-1,1)),Math.abs(m)<.9999999?(this._y=Math.atan2(l,v),this._z=Math.atan2(d,h)):(this._y=Math.atan2(-u,s),this._z=0);break;case"ZXY":this._x=Math.asin(Wn(g,-1,1)),Math.abs(g)<.9999999?(this._y=Math.atan2(-u,v),this._z=Math.atan2(-a,h)):(this._y=0,this._z=Math.atan2(d,s));break;case"ZYX":this._y=Math.asin(-Wn(u,-1,1)),Math.abs(u)<.9999999?(this._x=Math.atan2(g,v),this._z=Math.atan2(d,s)):(this._x=0,this._z=Math.atan2(-a,h));break;case"YZX":this._z=Math.asin(Wn(d,-1,1)),Math.abs(d)<.9999999?(this._x=Math.atan2(-m,h),this._y=Math.atan2(-u,s)):(this._x=0,this._y=Math.atan2(l,v));break;case"XZY":this._z=Math.asin(-Wn(a,-1,1)),Math.abs(a)<.9999999?(this._x=Math.atan2(g,h),this._y=Math.atan2(l,s)):(this._x=Math.atan2(-m,v),this._y=0);break;default:console.warn("THREE.Euler: .setFromRotationMatrix() encountered an unknown order: "+t)}return this._order=t,i===!0&&this._onChangeCallback(),this}setFromQuaternion(e,t,i){return fw.makeRotationFromQuaternion(e),this.setFromRotationMatrix(fw,t,i)}setFromVector3(e,t=this._order){return this.set(e.x,e.y,e.z,t)}reorder(e){return pw.setFromEuler(this),this.setFromQuaternion(pw,e)}equals(e){return e._x===this._x&&e._y===this._y&&e._z===this._z&&e._order===this._order}fromArray(e){return this._x=e[0],this._y=e[1],this._z=e[2],e[3]!==void 0&&(this._order=e[3]),this._onChangeCallback(),this}toArray(e=[],t=0){return e[t]=this._x,e[t+1]=this._y,e[t+2]=this._z,e[t+3]=this._order,e}_onChange(e){return this._onChangeCallback=e,this}_onChangeCallback(){}*[Symbol.iterator](){yield this._x,yield this._y,yield this._z,yield this._order}}Pn.DEFAULT_ORDER="XYZ";class A_{constructor(){this.mask=1}set(e){this.mask=(1<>>0}enable(e){this.mask|=1<1){for(let t=0;t1){for(let i=0;i0&&(r.userData=this.userData),r.layers=this.layers.mask,r.matrix=this.matrix.toArray(),r.up=this.up.toArray(),this.matrixAutoUpdate===!1&&(r.matrixAutoUpdate=!1),this.isInstancedMesh&&(r.type="InstancedMesh",r.count=this.count,r.instanceMatrix=this.instanceMatrix.toJSON(),this.instanceColor!==null&&(r.instanceColor=this.instanceColor.toJSON())),this.isBatchedMesh&&(r.type="BatchedMesh",r.perObjectFrustumCulled=this.perObjectFrustumCulled,r.sortObjects=this.sortObjects,r.drawRanges=this._drawRanges,r.reservedRanges=this._reservedRanges,r.visibility=this._visibility,r.active=this._active,r.bounds=this._bounds.map(l=>({boxInitialized:l.boxInitialized,boxMin:l.box.min.toArray(),boxMax:l.box.max.toArray(),sphereInitialized:l.sphereInitialized,sphereRadius:l.sphere.radius,sphereCenter:l.sphere.center.toArray()})),r.maxInstanceCount=this._maxInstanceCount,r.maxVertexCount=this._maxVertexCount,r.maxIndexCount=this._maxIndexCount,r.geometryInitialized=this._geometryInitialized,r.geometryCount=this._geometryCount,r.matricesTexture=this._matricesTexture.toJSON(e),this._colorsTexture!==null&&(r.colorsTexture=this._colorsTexture.toJSON(e)),this.boundingSphere!==null&&(r.boundingSphere={center:r.boundingSphere.center.toArray(),radius:r.boundingSphere.radius}),this.boundingBox!==null&&(r.boundingBox={min:r.boundingBox.min.toArray(),max:r.boundingBox.max.toArray()}));function s(l,d){return l[d.uuid]===void 0&&(l[d.uuid]=d.toJSON(e)),d.uuid}if(this.isScene)this.background&&(this.background.isColor?r.background=this.background.toJSON():this.background.isTexture&&(r.background=this.background.toJSON(e).uuid)),this.environment&&this.environment.isTexture&&this.environment.isRenderTargetTexture!==!0&&(r.environment=this.environment.toJSON(e).uuid);else if(this.isMesh||this.isLine||this.isPoints){r.geometry=s(e.geometries,this.geometry);const l=this.geometry.parameters;if(l!==void 0&&l.shapes!==void 0){const d=l.shapes;if(Array.isArray(d))for(let h=0,m=d.length;h0){r.children=[];for(let l=0;l0){r.animations=[];for(let l=0;l0&&(i.geometries=l),d.length>0&&(i.materials=d),h.length>0&&(i.textures=h),m.length>0&&(i.images=m),u.length>0&&(i.shapes=u),g.length>0&&(i.skeletons=g),v.length>0&&(i.animations=v),w.length>0&&(i.nodes=w)}return i.object=r,i;function a(l){const d=[];for(const h in l){const m=l[h];delete m.metadata,d.push(m)}return d}}clone(e){return new this.constructor().copy(this,e)}copy(e,t=!0){if(this.name=e.name,this.up.copy(e.up),this.position.copy(e.position),this.rotation.order=e.rotation.order,this.quaternion.copy(e.quaternion),this.scale.copy(e.scale),this.matrix.copy(e.matrix),this.matrixWorld.copy(e.matrixWorld),this.matrixAutoUpdate=e.matrixAutoUpdate,this.matrixWorldAutoUpdate=e.matrixWorldAutoUpdate,this.matrixWorldNeedsUpdate=e.matrixWorldNeedsUpdate,this.layers.mask=e.layers.mask,this.visible=e.visible,this.castShadow=e.castShadow,this.receiveShadow=e.receiveShadow,this.frustumCulled=e.frustumCulled,this.renderOrder=e.renderOrder,this.animations=e.animations.slice(),this.userData=JSON.parse(JSON.stringify(e.userData)),t===!0)for(let i=0;i0?r.multiplyScalar(1/Math.sqrt(s)):r.set(0,0,0)}static getBarycoord(e,t,i,r,s){_r.subVectors(r,t),Qr.subVectors(i,t),ip.subVectors(e,t);const a=_r.dot(_r),l=_r.dot(Qr),d=_r.dot(ip),h=Qr.dot(Qr),m=Qr.dot(ip),u=a*h-l*l;if(u===0)return s.set(0,0,0),null;const g=1/u,v=(h*d-l*m)*g,w=(a*m-l*d)*g;return s.set(1-v-w,w,v)}static containsPoint(e,t,i,r){return this.getBarycoord(e,t,i,r,Jr)===null?!1:Jr.x>=0&&Jr.y>=0&&Jr.x+Jr.y<=1}static getInterpolation(e,t,i,r,s,a,l,d){return this.getBarycoord(e,t,i,r,Jr)===null?(d.x=0,d.y=0,"z"in d&&(d.z=0),"w"in d&&(d.w=0),null):(d.setScalar(0),d.addScaledVector(s,Jr.x),d.addScaledVector(a,Jr.y),d.addScaledVector(l,Jr.z),d)}static isFrontFacing(e,t,i,r){return _r.subVectors(i,t),Qr.subVectors(e,t),_r.cross(Qr).dot(r)<0}set(e,t,i){return this.a.copy(e),this.b.copy(t),this.c.copy(i),this}setFromPointsAndIndices(e,t,i,r){return this.a.copy(e[t]),this.b.copy(e[i]),this.c.copy(e[r]),this}setFromAttributeAndIndices(e,t,i,r){return this.a.fromBufferAttribute(e,t),this.b.fromBufferAttribute(e,i),this.c.fromBufferAttribute(e,r),this}clone(){return new this.constructor().copy(this)}copy(e){return this.a.copy(e.a),this.b.copy(e.b),this.c.copy(e.c),this}getArea(){return _r.subVectors(this.c,this.b),Qr.subVectors(this.a,this.b),_r.cross(Qr).length()*.5}getMidpoint(e){return e.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)}getNormal(e){return Ur.getNormal(this.a,this.b,this.c,e)}getPlane(e){return e.setFromCoplanarPoints(this.a,this.b,this.c)}getBarycoord(e,t){return Ur.getBarycoord(e,this.a,this.b,this.c,t)}getInterpolation(e,t,i,r,s){return Ur.getInterpolation(e,this.a,this.b,this.c,t,i,r,s)}containsPoint(e){return Ur.containsPoint(e,this.a,this.b,this.c)}isFrontFacing(e){return Ur.isFrontFacing(this.a,this.b,this.c,e)}intersectsBox(e){return e.intersectsTriangle(this)}closestPointToPoint(e,t){const i=this.a,r=this.b,s=this.c;let a,l;Ja.subVectors(r,i),eo.subVectors(s,i),rp.subVectors(e,i);const d=Ja.dot(rp),h=eo.dot(rp);if(d<=0&&h<=0)return t.copy(i);sp.subVectors(e,r);const m=Ja.dot(sp),u=eo.dot(sp);if(m>=0&&u<=m)return t.copy(r);const g=d*u-m*h;if(g<=0&&d>=0&&m<=0)return a=d/(d-m),t.copy(i).addScaledVector(Ja,a);ap.subVectors(e,s);const v=Ja.dot(ap),w=eo.dot(ap);if(w>=0&&v<=w)return t.copy(s);const T=v*h-d*w;if(T<=0&&h>=0&&w<=0)return l=h/(h-w),t.copy(i).addScaledVector(eo,l);const M=m*w-v*u;if(M<=0&&u-m>=0&&v-w>=0)return bw.subVectors(s,r),l=(u-m)/(u-m+(v-w)),t.copy(r).addScaledVector(bw,l);const b=1/(M+T+g);return a=T*b,l=g*b,t.copy(i).addScaledVector(Ja,a).addScaledVector(eo,l)}equals(e){return e.a.equals(this.a)&&e.b.equals(this.b)&&e.c.equals(this.c)}}const ME={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074},As={h:0,s:0,l:0},Hu={h:0,s:0,l:0};function op(n,e,t){return t<0&&(t+=1),t>1&&(t-=1),t<1/6?n+(e-n)*6*t:t<1/2?e:t<2/3?n+(e-n)*6*(2/3-t):n}class Je{constructor(e,t,i){return this.isColor=!0,this.r=1,this.g=1,this.b=1,this.set(e,t,i)}set(e,t,i){if(t===void 0&&i===void 0){const r=e;r&&r.isColor?this.copy(r):typeof r=="number"?this.setHex(r):typeof r=="string"&&this.setStyle(r)}else this.setRGB(e,t,i);return this}setScalar(e){return this.r=e,this.g=e,this.b=e,this}setHex(e,t=on){return e=Math.floor(e),this.r=(e>>16&255)/255,this.g=(e>>8&255)/255,this.b=(e&255)/255,Kt.toWorkingColorSpace(this,t),this}setRGB(e,t,i,r=Kt.workingColorSpace){return this.r=e,this.g=t,this.b=i,Kt.toWorkingColorSpace(this,r),this}setHSL(e,t,i,r=Kt.workingColorSpace){if(e=E_(e,1),t=Wn(t,0,1),i=Wn(i,0,1),t===0)this.r=this.g=this.b=i;else{const s=i<=.5?i*(1+t):i+t-i*t,a=2*i-s;this.r=op(a,s,e+1/3),this.g=op(a,s,e),this.b=op(a,s,e-1/3)}return Kt.toWorkingColorSpace(this,r),this}setStyle(e,t=on){function i(s){s!==void 0&&parseFloat(s)<1&&console.warn("THREE.Color: Alpha component of "+e+" will be ignored.")}let r;if(r=/^(\w+)\(([^\)]*)\)/.exec(e)){let s;const a=r[1],l=r[2];switch(a){case"rgb":case"rgba":if(s=/^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(l))return i(s[4]),this.setRGB(Math.min(255,parseInt(s[1],10))/255,Math.min(255,parseInt(s[2],10))/255,Math.min(255,parseInt(s[3],10))/255,t);if(s=/^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(l))return i(s[4]),this.setRGB(Math.min(100,parseInt(s[1],10))/100,Math.min(100,parseInt(s[2],10))/100,Math.min(100,parseInt(s[3],10))/100,t);break;case"hsl":case"hsla":if(s=/^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(l))return i(s[4]),this.setHSL(parseFloat(s[1])/360,parseFloat(s[2])/100,parseFloat(s[3])/100,t);break;default:console.warn("THREE.Color: Unknown color model "+e)}}else if(r=/^\#([A-Fa-f\d]+)$/.exec(e)){const s=r[1],a=s.length;if(a===3)return this.setRGB(parseInt(s.charAt(0),16)/15,parseInt(s.charAt(1),16)/15,parseInt(s.charAt(2),16)/15,t);if(a===6)return this.setHex(parseInt(s,16),t);console.warn("THREE.Color: Invalid hex color "+e)}else if(e&&e.length>0)return this.setColorName(e,t);return this}setColorName(e,t=on){const i=ME[e.toLowerCase()];return i!==void 0?this.setHex(i,t):console.warn("THREE.Color: Unknown color "+e),this}clone(){return new this.constructor(this.r,this.g,this.b)}copy(e){return this.r=e.r,this.g=e.g,this.b=e.b,this}copySRGBToLinear(e){return this.r=zo(e.r),this.g=zo(e.g),this.b=zo(e.b),this}copyLinearToSRGB(e){return this.r=$f(e.r),this.g=$f(e.g),this.b=$f(e.b),this}convertSRGBToLinear(){return this.copySRGBToLinear(this),this}convertLinearToSRGB(){return this.copyLinearToSRGB(this),this}getHex(e=on){return Kt.fromWorkingColorSpace(fi.copy(this),e),Math.round(Wn(fi.r*255,0,255))*65536+Math.round(Wn(fi.g*255,0,255))*256+Math.round(Wn(fi.b*255,0,255))}getHexString(e=on){return("000000"+this.getHex(e).toString(16)).slice(-6)}getHSL(e,t=Kt.workingColorSpace){Kt.fromWorkingColorSpace(fi.copy(this),t);const i=fi.r,r=fi.g,s=fi.b,a=Math.max(i,r,s),l=Math.min(i,r,s);let d,h;const m=(l+a)/2;if(l===a)d=0,h=0;else{const u=a-l;switch(h=m<=.5?u/(a+l):u/(2-a-l),a){case i:d=(r-s)/u+(r0!=e>0&&this.version++,this._alphaTest=e}onBeforeCompile(){}customProgramCacheKey(){return this.onBeforeCompile.toString()}setValues(e){if(e!==void 0)for(const t in e){const i=e[t];if(i===void 0){console.warn(`THREE.Material: parameter '${t}' has value of undefined.`);continue}const r=this[t];if(r===void 0){console.warn(`THREE.Material: '${t}' is not a property of THREE.${this.type}.`);continue}r&&r.isColor?r.set(i):r&&r.isVector3&&i&&i.isVector3?r.copy(i):this[t]=i}}toJSON(e){const t=e===void 0||typeof e=="string";t&&(e={textures:{},images:{}});const i={metadata:{version:4.6,type:"Material",generator:"Material.toJSON"}};i.uuid=this.uuid,i.type=this.type,this.name!==""&&(i.name=this.name),this.color&&this.color.isColor&&(i.color=this.color.getHex()),this.roughness!==void 0&&(i.roughness=this.roughness),this.metalness!==void 0&&(i.metalness=this.metalness),this.sheen!==void 0&&(i.sheen=this.sheen),this.sheenColor&&this.sheenColor.isColor&&(i.sheenColor=this.sheenColor.getHex()),this.sheenRoughness!==void 0&&(i.sheenRoughness=this.sheenRoughness),this.emissive&&this.emissive.isColor&&(i.emissive=this.emissive.getHex()),this.emissiveIntensity!==void 0&&this.emissiveIntensity!==1&&(i.emissiveIntensity=this.emissiveIntensity),this.specular&&this.specular.isColor&&(i.specular=this.specular.getHex()),this.specularIntensity!==void 0&&(i.specularIntensity=this.specularIntensity),this.specularColor&&this.specularColor.isColor&&(i.specularColor=this.specularColor.getHex()),this.shininess!==void 0&&(i.shininess=this.shininess),this.clearcoat!==void 0&&(i.clearcoat=this.clearcoat),this.clearcoatRoughness!==void 0&&(i.clearcoatRoughness=this.clearcoatRoughness),this.clearcoatMap&&this.clearcoatMap.isTexture&&(i.clearcoatMap=this.clearcoatMap.toJSON(e).uuid),this.clearcoatRoughnessMap&&this.clearcoatRoughnessMap.isTexture&&(i.clearcoatRoughnessMap=this.clearcoatRoughnessMap.toJSON(e).uuid),this.clearcoatNormalMap&&this.clearcoatNormalMap.isTexture&&(i.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(e).uuid,i.clearcoatNormalScale=this.clearcoatNormalScale.toArray()),this.dispersion!==void 0&&(i.dispersion=this.dispersion),this.iridescence!==void 0&&(i.iridescence=this.iridescence),this.iridescenceIOR!==void 0&&(i.iridescenceIOR=this.iridescenceIOR),this.iridescenceThicknessRange!==void 0&&(i.iridescenceThicknessRange=this.iridescenceThicknessRange),this.iridescenceMap&&this.iridescenceMap.isTexture&&(i.iridescenceMap=this.iridescenceMap.toJSON(e).uuid),this.iridescenceThicknessMap&&this.iridescenceThicknessMap.isTexture&&(i.iridescenceThicknessMap=this.iridescenceThicknessMap.toJSON(e).uuid),this.anisotropy!==void 0&&(i.anisotropy=this.anisotropy),this.anisotropyRotation!==void 0&&(i.anisotropyRotation=this.anisotropyRotation),this.anisotropyMap&&this.anisotropyMap.isTexture&&(i.anisotropyMap=this.anisotropyMap.toJSON(e).uuid),this.map&&this.map.isTexture&&(i.map=this.map.toJSON(e).uuid),this.matcap&&this.matcap.isTexture&&(i.matcap=this.matcap.toJSON(e).uuid),this.alphaMap&&this.alphaMap.isTexture&&(i.alphaMap=this.alphaMap.toJSON(e).uuid),this.lightMap&&this.lightMap.isTexture&&(i.lightMap=this.lightMap.toJSON(e).uuid,i.lightMapIntensity=this.lightMapIntensity),this.aoMap&&this.aoMap.isTexture&&(i.aoMap=this.aoMap.toJSON(e).uuid,i.aoMapIntensity=this.aoMapIntensity),this.bumpMap&&this.bumpMap.isTexture&&(i.bumpMap=this.bumpMap.toJSON(e).uuid,i.bumpScale=this.bumpScale),this.normalMap&&this.normalMap.isTexture&&(i.normalMap=this.normalMap.toJSON(e).uuid,i.normalMapType=this.normalMapType,i.normalScale=this.normalScale.toArray()),this.displacementMap&&this.displacementMap.isTexture&&(i.displacementMap=this.displacementMap.toJSON(e).uuid,i.displacementScale=this.displacementScale,i.displacementBias=this.displacementBias),this.roughnessMap&&this.roughnessMap.isTexture&&(i.roughnessMap=this.roughnessMap.toJSON(e).uuid),this.metalnessMap&&this.metalnessMap.isTexture&&(i.metalnessMap=this.metalnessMap.toJSON(e).uuid),this.emissiveMap&&this.emissiveMap.isTexture&&(i.emissiveMap=this.emissiveMap.toJSON(e).uuid),this.specularMap&&this.specularMap.isTexture&&(i.specularMap=this.specularMap.toJSON(e).uuid),this.specularIntensityMap&&this.specularIntensityMap.isTexture&&(i.specularIntensityMap=this.specularIntensityMap.toJSON(e).uuid),this.specularColorMap&&this.specularColorMap.isTexture&&(i.specularColorMap=this.specularColorMap.toJSON(e).uuid),this.envMap&&this.envMap.isTexture&&(i.envMap=this.envMap.toJSON(e).uuid,this.combine!==void 0&&(i.combine=this.combine)),this.envMapRotation!==void 0&&(i.envMapRotation=this.envMapRotation.toArray()),this.envMapIntensity!==void 0&&(i.envMapIntensity=this.envMapIntensity),this.reflectivity!==void 0&&(i.reflectivity=this.reflectivity),this.refractionRatio!==void 0&&(i.refractionRatio=this.refractionRatio),this.gradientMap&&this.gradientMap.isTexture&&(i.gradientMap=this.gradientMap.toJSON(e).uuid),this.transmission!==void 0&&(i.transmission=this.transmission),this.transmissionMap&&this.transmissionMap.isTexture&&(i.transmissionMap=this.transmissionMap.toJSON(e).uuid),this.thickness!==void 0&&(i.thickness=this.thickness),this.thicknessMap&&this.thicknessMap.isTexture&&(i.thicknessMap=this.thicknessMap.toJSON(e).uuid),this.attenuationDistance!==void 0&&this.attenuationDistance!==1/0&&(i.attenuationDistance=this.attenuationDistance),this.attenuationColor!==void 0&&(i.attenuationColor=this.attenuationColor.getHex()),this.size!==void 0&&(i.size=this.size),this.shadowSide!==null&&(i.shadowSide=this.shadowSide),this.sizeAttenuation!==void 0&&(i.sizeAttenuation=this.sizeAttenuation),this.blending!==No&&(i.blending=this.blending),this.side!==gs&&(i.side=this.side),this.vertexColors===!0&&(i.vertexColors=!0),this.opacity<1&&(i.opacity=this.opacity),this.transparent===!0&&(i.transparent=!0),this.blendSrc!==Pm&&(i.blendSrc=this.blendSrc),this.blendDst!==Lm&&(i.blendDst=this.blendDst),this.blendEquation!==ya&&(i.blendEquation=this.blendEquation),this.blendSrcAlpha!==null&&(i.blendSrcAlpha=this.blendSrcAlpha),this.blendDstAlpha!==null&&(i.blendDstAlpha=this.blendDstAlpha),this.blendEquationAlpha!==null&&(i.blendEquationAlpha=this.blendEquationAlpha),this.blendColor&&this.blendColor.isColor&&(i.blendColor=this.blendColor.getHex()),this.blendAlpha!==0&&(i.blendAlpha=this.blendAlpha),this.depthFunc!==uh&&(i.depthFunc=this.depthFunc),this.depthTest===!1&&(i.depthTest=this.depthTest),this.depthWrite===!1&&(i.depthWrite=this.depthWrite),this.colorWrite===!1&&(i.colorWrite=this.colorWrite),this.stencilWriteMask!==255&&(i.stencilWriteMask=this.stencilWriteMask),this.stencilFunc!==aw&&(i.stencilFunc=this.stencilFunc),this.stencilRef!==0&&(i.stencilRef=this.stencilRef),this.stencilFuncMask!==255&&(i.stencilFuncMask=this.stencilFuncMask),this.stencilFail!==ja&&(i.stencilFail=this.stencilFail),this.stencilZFail!==ja&&(i.stencilZFail=this.stencilZFail),this.stencilZPass!==ja&&(i.stencilZPass=this.stencilZPass),this.stencilWrite===!0&&(i.stencilWrite=this.stencilWrite),this.rotation!==void 0&&this.rotation!==0&&(i.rotation=this.rotation),this.polygonOffset===!0&&(i.polygonOffset=!0),this.polygonOffsetFactor!==0&&(i.polygonOffsetFactor=this.polygonOffsetFactor),this.polygonOffsetUnits!==0&&(i.polygonOffsetUnits=this.polygonOffsetUnits),this.linewidth!==void 0&&this.linewidth!==1&&(i.linewidth=this.linewidth),this.dashSize!==void 0&&(i.dashSize=this.dashSize),this.gapSize!==void 0&&(i.gapSize=this.gapSize),this.scale!==void 0&&(i.scale=this.scale),this.dithering===!0&&(i.dithering=!0),this.alphaTest>0&&(i.alphaTest=this.alphaTest),this.alphaHash===!0&&(i.alphaHash=!0),this.alphaToCoverage===!0&&(i.alphaToCoverage=!0),this.premultipliedAlpha===!0&&(i.premultipliedAlpha=!0),this.forceSinglePass===!0&&(i.forceSinglePass=!0),this.wireframe===!0&&(i.wireframe=!0),this.wireframeLinewidth>1&&(i.wireframeLinewidth=this.wireframeLinewidth),this.wireframeLinecap!=="round"&&(i.wireframeLinecap=this.wireframeLinecap),this.wireframeLinejoin!=="round"&&(i.wireframeLinejoin=this.wireframeLinejoin),this.flatShading===!0&&(i.flatShading=!0),this.visible===!1&&(i.visible=!1),this.toneMapped===!1&&(i.toneMapped=!1),this.fog===!1&&(i.fog=!1),Object.keys(this.userData).length>0&&(i.userData=this.userData);function r(s){const a=[];for(const l in s){const d=s[l];delete d.metadata,a.push(d)}return a}if(t){const s=r(e.textures),a=r(e.images);s.length>0&&(i.textures=s),a.length>0&&(i.images=a)}return i}clone(){return new this.constructor().copy(this)}copy(e){this.name=e.name,this.blending=e.blending,this.side=e.side,this.vertexColors=e.vertexColors,this.opacity=e.opacity,this.transparent=e.transparent,this.blendSrc=e.blendSrc,this.blendDst=e.blendDst,this.blendEquation=e.blendEquation,this.blendSrcAlpha=e.blendSrcAlpha,this.blendDstAlpha=e.blendDstAlpha,this.blendEquationAlpha=e.blendEquationAlpha,this.blendColor.copy(e.blendColor),this.blendAlpha=e.blendAlpha,this.depthFunc=e.depthFunc,this.depthTest=e.depthTest,this.depthWrite=e.depthWrite,this.stencilWriteMask=e.stencilWriteMask,this.stencilFunc=e.stencilFunc,this.stencilRef=e.stencilRef,this.stencilFuncMask=e.stencilFuncMask,this.stencilFail=e.stencilFail,this.stencilZFail=e.stencilZFail,this.stencilZPass=e.stencilZPass,this.stencilWrite=e.stencilWrite;const t=e.clippingPlanes;let i=null;if(t!==null){const r=t.length;i=new Array(r);for(let s=0;s!==r;++s)i[s]=t[s].clone()}return this.clippingPlanes=i,this.clipIntersection=e.clipIntersection,this.clipShadows=e.clipShadows,this.shadowSide=e.shadowSide,this.colorWrite=e.colorWrite,this.precision=e.precision,this.polygonOffset=e.polygonOffset,this.polygonOffsetFactor=e.polygonOffsetFactor,this.polygonOffsetUnits=e.polygonOffsetUnits,this.dithering=e.dithering,this.alphaTest=e.alphaTest,this.alphaHash=e.alphaHash,this.alphaToCoverage=e.alphaToCoverage,this.premultipliedAlpha=e.premultipliedAlpha,this.forceSinglePass=e.forceSinglePass,this.visible=e.visible,this.toneMapped=e.toneMapped,this.userData=JSON.parse(JSON.stringify(e.userData)),this}dispose(){this.dispatchEvent({type:"dispose"})}set needsUpdate(e){e===!0&&this.version++}onBuild(){console.warn("Material: onBuild() has been removed.")}onBeforeRender(){console.warn("Material: onBeforeRender() has been removed.")}}class Or extends _i{constructor(e){super(),this.isMeshBasicMaterial=!0,this.type="MeshBasicMaterial",this.color=new Je(16777215),this.map=null,this.lightMap=null,this.lightMapIntensity=1,this.aoMap=null,this.aoMapIntensity=1,this.specularMap=null,this.alphaMap=null,this.envMap=null,this.envMapRotation=new Pn,this.combine=Bh,this.reflectivity=1,this.refractionRatio=.98,this.wireframe=!1,this.wireframeLinewidth=1,this.wireframeLinecap="round",this.wireframeLinejoin="round",this.fog=!0,this.setValues(e)}copy(e){return super.copy(e),this.color.copy(e.color),this.map=e.map,this.lightMap=e.lightMap,this.lightMapIntensity=e.lightMapIntensity,this.aoMap=e.aoMap,this.aoMapIntensity=e.aoMapIntensity,this.specularMap=e.specularMap,this.alphaMap=e.alphaMap,this.envMap=e.envMap,this.envMapRotation.copy(e.envMapRotation),this.combine=e.combine,this.reflectivity=e.reflectivity,this.refractionRatio=e.refractionRatio,this.wireframe=e.wireframe,this.wireframeLinewidth=e.wireframeLinewidth,this.wireframeLinecap=e.wireframeLinecap,this.wireframeLinejoin=e.wireframeLinejoin,this.fog=e.fog,this}}const as=ZD();function ZD(){const n=new ArrayBuffer(4),e=new Float32Array(n),t=new Uint32Array(n),i=new Uint32Array(512),r=new Uint32Array(512);for(let d=0;d<256;++d){const h=d-127;h<-27?(i[d]=0,i[d|256]=32768,r[d]=24,r[d|256]=24):h<-14?(i[d]=1024>>-h-14,i[d|256]=1024>>-h-14|32768,r[d]=-h-1,r[d|256]=-h-1):h<=15?(i[d]=h+15<<10,i[d|256]=h+15<<10|32768,r[d]=13,r[d|256]=13):h<128?(i[d]=31744,i[d|256]=64512,r[d]=24,r[d|256]=24):(i[d]=31744,i[d|256]=64512,r[d]=13,r[d|256]=13)}const s=new Uint32Array(2048),a=new Uint32Array(64),l=new Uint32Array(64);for(let d=1;d<1024;++d){let h=d<<13,m=0;for(;!(h&8388608);)h<<=1,m-=8388608;h&=-8388609,m+=947912704,s[d]=h|m}for(let d=1024;d<2048;++d)s[d]=939524096+(d-1024<<13);for(let d=1;d<31;++d)a[d]=d<<23;a[31]=1199570944,a[32]=2147483648;for(let d=33;d<63;++d)a[d]=2147483648+(d-32<<23);a[63]=3347054592;for(let d=1;d<64;++d)d!==32&&(l[d]=1024);return{floatView:e,uint32View:t,baseTable:i,shiftTable:r,mantissaTable:s,exponentTable:a,offsetTable:l}}function QD(n){Math.abs(n)>65504&&console.warn("THREE.DataUtils.toHalfFloat(): Value out of range."),n=Wn(n,-65504,65504),as.floatView[0]=n;const e=as.uint32View[0],t=e>>23&511;return as.baseTable[t]+((e&8388607)>>as.shiftTable[t])}function JD(n){const e=n>>10;return as.uint32View[0]=as.mantissaTable[as.offsetTable[e]+(n&1023)]+as.exponentTable[e],as.floatView[0]}const Eo={toHalfFloat:QD,fromHalfFloat:JD},zn=new j,Gu=new et;class _n{constructor(e,t,i=!1){if(Array.isArray(e))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.isBufferAttribute=!0,this.name="",this.array=e,this.itemSize=t,this.count=e!==void 0?e.length/t:0,this.normalized=i,this.usage=ag,this._updateRange={offset:0,count:-1},this.updateRanges=[],this.gpuType=Un,this.version=0}onUploadCallback(){}set needsUpdate(e){e===!0&&this.version++}get updateRange(){return T_("THREE.BufferAttribute: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead."),this._updateRange}setUsage(e){return this.usage=e,this}addUpdateRange(e,t){this.updateRanges.push({start:e,count:t})}clearUpdateRanges(){this.updateRanges.length=0}copy(e){return this.name=e.name,this.array=new e.array.constructor(e.array),this.itemSize=e.itemSize,this.count=e.count,this.normalized=e.normalized,this.usage=e.usage,this.gpuType=e.gpuType,this}copyAt(e,t,i){e*=this.itemSize,i*=t.itemSize;for(let r=0,s=this.itemSize;r0&&(e.userData=this.userData),this.parameters!==void 0){const d=this.parameters;for(const h in d)d[h]!==void 0&&(e[h]=d[h]);return e}e.data={attributes:{}};const t=this.index;t!==null&&(e.data.index={type:t.array.constructor.name,array:Array.prototype.slice.call(t.array)});const i=this.attributes;for(const d in i){const h=i[d];e.data.attributes[d]=h.toJSON(e.data)}const r={};let s=!1;for(const d in this.morphAttributes){const h=this.morphAttributes[d],m=[];for(let u=0,g=h.length;u0&&(r[d]=m,s=!0)}s&&(e.data.morphAttributes=r,e.data.morphTargetsRelative=this.morphTargetsRelative);const a=this.groups;a.length>0&&(e.data.groups=JSON.parse(JSON.stringify(a)));const l=this.boundingSphere;return l!==null&&(e.data.boundingSphere={center:l.center.toArray(),radius:l.radius}),e}clone(){return new this.constructor().copy(this)}copy(e){this.index=null,this.attributes={},this.morphAttributes={},this.groups=[],this.boundingBox=null,this.boundingSphere=null;const t={};this.name=e.name;const i=e.index;i!==null&&this.setIndex(i.clone(t));const r=e.attributes;for(const h in r){const m=r[h];this.setAttribute(h,m.clone(t))}const s=e.morphAttributes;for(const h in s){const m=[],u=s[h];for(let g=0,v=u.length;g0){const r=t[i[0]];if(r!==void 0){this.morphTargetInfluences=[],this.morphTargetDictionary={};for(let s=0,a=r.length;s(e.far-e.near)**2))&&(xw.copy(s).invert(),ca.copy(e.ray).applyMatrix4(xw),!(i.boundingBox!==null&&ca.intersectsBox(i.boundingBox)===!1)&&this._computeIntersections(e,t,ca)))}_computeIntersections(e,t,i){let r;const s=this.geometry,a=this.material,l=s.index,d=s.attributes.position,h=s.attributes.uv,m=s.attributes.uv1,u=s.attributes.normal,g=s.groups,v=s.drawRange;if(l!==null)if(Array.isArray(a))for(let w=0,T=g.length;wt.far?null:{distance:h,point:qu.clone(),object:n}}function Ku(n,e,t,i,r,s,a,l,d,h){n.getVertexPosition(l,no),n.getVertexPosition(d,io),n.getVertexPosition(h,ro);const m=tk(n,e,t,i,no,io,ro,$u);if(m){r&&(ju.fromBufferAttribute(r,l),Xu.fromBufferAttribute(r,d),Yu.fromBufferAttribute(r,h),m.uv=Ur.getInterpolation($u,no,io,ro,ju,Xu,Yu,new et)),s&&(ju.fromBufferAttribute(s,l),Xu.fromBufferAttribute(s,d),Yu.fromBufferAttribute(s,h),m.uv1=Ur.getInterpolation($u,no,io,ro,ju,Xu,Yu,new et)),a&&(Sw.fromBufferAttribute(a,l),Mw.fromBufferAttribute(a,d),Ew.fromBufferAttribute(a,h),m.normal=Ur.getInterpolation($u,no,io,ro,Sw,Mw,Ew,new j),m.normal.dot(i.direction)>0&&m.normal.multiplyScalar(-1));const u={a:l,b:d,c:h,normal:new j,materialIndex:0};Ur.getNormal(no,io,ro,u.normal),m.face=u}return m}class Xc extends On{constructor(e=1,t=1,i=1,r=1,s=1,a=1){super(),this.type="BoxGeometry",this.parameters={width:e,height:t,depth:i,widthSegments:r,heightSegments:s,depthSegments:a};const l=this;r=Math.floor(r),s=Math.floor(s),a=Math.floor(a);const d=[],h=[],m=[],u=[];let g=0,v=0;w("z","y","x",-1,-1,i,t,e,a,s,0),w("z","y","x",1,-1,i,t,-e,a,s,1),w("x","z","y",1,1,e,i,t,r,a,2),w("x","z","y",1,-1,e,i,-t,r,a,3),w("x","y","z",1,-1,e,t,i,r,s,4),w("x","y","z",-1,-1,e,t,-i,r,s,5),this.setIndex(d),this.setAttribute("position",new nn(h,3)),this.setAttribute("normal",new nn(m,3)),this.setAttribute("uv",new nn(u,2));function w(T,M,b,A,E,P,G,O,B,F,D){const L=P/B,V=G/F,ie=P/2,re=G/2,de=O/2,me=B+1,$=F+1;let ue=0,Y=0;const pe=new j;for(let _e=0;_e<$;_e++){const Ae=_e*V-re;for(let Pe=0;Pe0?1:-1,m.push(pe.x,pe.y,pe.z),u.push(Pe/B),u.push(1-_e/F),ue+=1}}for(let _e=0;_e0&&(t.defines=this.defines),t.vertexShader=this.vertexShader,t.fragmentShader=this.fragmentShader,t.lights=this.lights,t.clipping=this.clipping;const i={};for(const r in this.extensions)this.extensions[r]===!0&&(i[r]=!0);return Object.keys(i).length>0&&(t.extensions=i),t}}let CE=class extends sn{constructor(){super(),this.isCamera=!0,this.type="Camera",this.matrixWorldInverse=new ot,this.projectionMatrix=new ot,this.projectionMatrixInverse=new ot,this.coordinateSystem=cs}copy(e,t){return super.copy(e,t),this.matrixWorldInverse.copy(e.matrixWorldInverse),this.projectionMatrix.copy(e.projectionMatrix),this.projectionMatrixInverse.copy(e.projectionMatrixInverse),this.coordinateSystem=e.coordinateSystem,this}getWorldDirection(e){return super.getWorldDirection(e).negate()}updateMatrixWorld(e){super.updateMatrixWorld(e),this.matrixWorldInverse.copy(this.matrixWorld).invert()}updateWorldMatrix(e,t){super.updateWorldMatrix(e,t),this.matrixWorldInverse.copy(this.matrixWorld).invert()}clone(){return new this.constructor().copy(this)}};const Cs=new j,Tw=new et,Aw=new et;class mi extends CE{constructor(e=50,t=1,i=.1,r=2e3){super(),this.isPerspectiveCamera=!0,this.type="PerspectiveCamera",this.fov=e,this.zoom=1,this.near=i,this.far=r,this.focus=10,this.aspect=t,this.view=null,this.filmGauge=35,this.filmOffset=0,this.updateProjectionMatrix()}copy(e,t){return super.copy(e,t),this.fov=e.fov,this.zoom=e.zoom,this.near=e.near,this.far=e.far,this.focus=e.focus,this.aspect=e.aspect,this.view=e.view===null?null:Object.assign({},e.view),this.filmGauge=e.filmGauge,this.filmOffset=e.filmOffset,this}setFocalLength(e){const t=.5*this.getFilmHeight()/e;this.fov=il*2*Math.atan(t),this.updateProjectionMatrix()}getFocalLength(){const e=Math.tan(cc*.5*this.fov);return .5*this.getFilmHeight()/e}getEffectiveFOV(){return il*2*Math.atan(Math.tan(cc*.5*this.fov)/this.zoom)}getFilmWidth(){return this.filmGauge*Math.min(this.aspect,1)}getFilmHeight(){return this.filmGauge/Math.max(this.aspect,1)}getViewBounds(e,t,i){Cs.set(-1,-1,.5).applyMatrix4(this.projectionMatrixInverse),t.set(Cs.x,Cs.y).multiplyScalar(-e/Cs.z),Cs.set(1,1,.5).applyMatrix4(this.projectionMatrixInverse),i.set(Cs.x,Cs.y).multiplyScalar(-e/Cs.z)}getViewSize(e,t){return this.getViewBounds(e,Tw,Aw),t.subVectors(Aw,Tw)}setViewOffset(e,t,i,r,s,a){this.aspect=e/t,this.view===null&&(this.view={enabled:!0,fullWidth:1,fullHeight:1,offsetX:0,offsetY:0,width:1,height:1}),this.view.enabled=!0,this.view.fullWidth=e,this.view.fullHeight=t,this.view.offsetX=i,this.view.offsetY=r,this.view.width=s,this.view.height=a,this.updateProjectionMatrix()}clearViewOffset(){this.view!==null&&(this.view.enabled=!1),this.updateProjectionMatrix()}updateProjectionMatrix(){const e=this.near;let t=e*Math.tan(cc*.5*this.fov)/this.zoom,i=2*t,r=this.aspect*i,s=-.5*r;const a=this.view;if(this.view!==null&&this.view.enabled){const d=a.fullWidth,h=a.fullHeight;s+=a.offsetX*r/d,t-=a.offsetY*i/h,r*=a.width/d,i*=a.height/h}const l=this.filmOffset;l!==0&&(s+=e*l/this.getFilmWidth()),this.projectionMatrix.makePerspective(s,s+r,t,t-i,e,this.far,this.coordinateSystem),this.projectionMatrixInverse.copy(this.projectionMatrix).invert()}toJSON(e){const t=super.toJSON(e);return t.object.fov=this.fov,t.object.zoom=this.zoom,t.object.near=this.near,t.object.far=this.far,t.object.focus=this.focus,t.object.aspect=this.aspect,this.view!==null&&(t.object.view=Object.assign({},this.view)),t.object.filmGauge=this.filmGauge,t.object.filmOffset=this.filmOffset,t}}const so=-90,ao=1;class RE extends sn{constructor(e,t,i){super(),this.type="CubeCamera",this.renderTarget=i,this.coordinateSystem=null,this.activeMipmapLevel=0;const r=new mi(so,ao,e,t);r.layers=this.layers,this.add(r);const s=new mi(so,ao,e,t);s.layers=this.layers,this.add(s);const a=new mi(so,ao,e,t);a.layers=this.layers,this.add(a);const l=new mi(so,ao,e,t);l.layers=this.layers,this.add(l);const d=new mi(so,ao,e,t);d.layers=this.layers,this.add(d);const h=new mi(so,ao,e,t);h.layers=this.layers,this.add(h)}updateCoordinateSystem(){const e=this.coordinateSystem,t=this.children.concat(),[i,r,s,a,l,d]=t;for(const h of t)this.remove(h);if(e===cs)i.up.set(0,1,0),i.lookAt(1,0,0),r.up.set(0,1,0),r.lookAt(-1,0,0),s.up.set(0,0,-1),s.lookAt(0,1,0),a.up.set(0,0,1),a.lookAt(0,-1,0),l.up.set(0,1,0),l.lookAt(0,0,1),d.up.set(0,1,0),d.lookAt(0,0,-1);else if(e===mh)i.up.set(0,-1,0),i.lookAt(-1,0,0),r.up.set(0,-1,0),r.lookAt(1,0,0),s.up.set(0,0,1),s.lookAt(0,1,0),a.up.set(0,0,-1),a.lookAt(0,-1,0),l.up.set(0,-1,0),l.lookAt(0,0,1),d.up.set(0,-1,0),d.lookAt(0,0,-1);else throw new Error("THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: "+e);for(const h of t)this.add(h),h.updateMatrixWorld()}update(e,t){this.parent===null&&this.updateMatrixWorld();const{renderTarget:i,activeMipmapLevel:r}=this;this.coordinateSystem!==e.coordinateSystem&&(this.coordinateSystem=e.coordinateSystem,this.updateCoordinateSystem());const[s,a,l,d,h,m]=this.children,u=e.getRenderTarget(),g=e.getActiveCubeFace(),v=e.getActiveMipmapLevel(),w=e.xr.enabled;e.xr.enabled=!1;const T=i.texture.generateMipmaps;i.texture.generateMipmaps=!1,e.setRenderTarget(i,0,r),e.render(t,s),e.setRenderTarget(i,1,r),e.render(t,a),e.setRenderTarget(i,2,r),e.render(t,l),e.setRenderTarget(i,3,r),e.render(t,d),e.setRenderTarget(i,4,r),e.render(t,h),i.texture.generateMipmaps=T,e.setRenderTarget(i,5,r),e.render(t,m),e.setRenderTarget(u,g,v),e.xr.enabled=w,i.texture.needsPMREMUpdate=!0}}class PE extends qn{constructor(e,t,i,r,s,a,l,d,h,m){e=e!==void 0?e:[],t=t!==void 0?t:Qo,super(e,t,i,r,s,a,l,d,h,m),this.isCubeTexture=!0,this.flipY=!1}get images(){return this.image}set images(e){this.image=e}}class LE extends Zs{constructor(e=1,t={}){super(e,e,t),this.isWebGLCubeRenderTarget=!0;const i={width:e,height:e,depth:1},r=[i,i,i,i,i,i];this.texture=new PE(r,t.mapping,t.wrapS,t.wrapT,t.magFilter,t.minFilter,t.format,t.type,t.anisotropy,t.colorSpace),this.texture.isRenderTargetTexture=!0,this.texture.generateMipmaps=t.generateMipmaps!==void 0?t.generateMipmaps:!1,this.texture.minFilter=t.minFilter!==void 0?t.minFilter:ln}fromEquirectangularTexture(e,t){this.texture.type=t.type,this.texture.colorSpace=t.colorSpace,this.texture.generateMipmaps=t.generateMipmaps,this.texture.minFilter=t.minFilter,this.texture.magFilter=t.magFilter;const i={uniforms:{tEquirect:{value:null}},vertexShader:`
+
+ varying vec3 vWorldDirection;
+
+ vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
+
+ return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
+
+ }
+
+ void main() {
+
+ vWorldDirection = transformDirection( position, modelMatrix );
+
+ #include
+ #include
+
+ }
+ `,fragmentShader:`
+
+ uniform sampler2D tEquirect;
+
+ varying vec3 vWorldDirection;
+
+ #include
+
+ void main() {
+
+ vec3 direction = normalize( vWorldDirection );
+
+ vec2 sampleUV = equirectUv( direction );
+
+ gl_FragColor = texture2D( tEquirect, sampleUV );
+
+ }
+ `},r=new Xc(5,5,5),s=new zi({name:"CubemapFromEquirect",uniforms:rl(i.uniforms),vertexShader:i.vertexShader,fragmentShader:i.fragmentShader,side:Ei,blending:Gr});s.uniforms.tEquirect.value=t;const a=new wn(r,s),l=t.minFilter;return t.minFilter===Er&&(t.minFilter=ln),new RE(1,10,this).update(e,a),t.minFilter=l,a.geometry.dispose(),a.material.dispose(),this}clear(e,t,i,r){const s=e.getRenderTarget();for(let a=0;a<6;a++)e.setRenderTarget(this,a),e.clear(t,i,r);e.setRenderTarget(s)}}const up=new j,sk=new j,ak=new At;let ga=class{constructor(e=new j(1,0,0),t=0){this.isPlane=!0,this.normal=e,this.constant=t}set(e,t){return this.normal.copy(e),this.constant=t,this}setComponents(e,t,i,r){return this.normal.set(e,t,i),this.constant=r,this}setFromNormalAndCoplanarPoint(e,t){return this.normal.copy(e),this.constant=-t.dot(this.normal),this}setFromCoplanarPoints(e,t,i){const r=up.subVectors(i,t).cross(sk.subVectors(e,t)).normalize();return this.setFromNormalAndCoplanarPoint(r,e),this}copy(e){return this.normal.copy(e.normal),this.constant=e.constant,this}normalize(){const e=1/this.normal.length();return this.normal.multiplyScalar(e),this.constant*=e,this}negate(){return this.constant*=-1,this.normal.negate(),this}distanceToPoint(e){return this.normal.dot(e)+this.constant}distanceToSphere(e){return this.distanceToPoint(e.center)-e.radius}projectPoint(e,t){return t.copy(e).addScaledVector(this.normal,-this.distanceToPoint(e))}intersectLine(e,t){const i=e.delta(up),r=this.normal.dot(i);if(r===0)return this.distanceToPoint(e.start)===0?t.copy(e.start):null;const s=-(e.start.dot(this.normal)+this.constant)/r;return s<0||s>1?null:t.copy(e.start).addScaledVector(i,s)}intersectsLine(e){const t=this.distanceToPoint(e.start),i=this.distanceToPoint(e.end);return t<0&&i>0||i<0&&t>0}intersectsBox(e){return e.intersectsPlane(this)}intersectsSphere(e){return e.intersectsPlane(this)}coplanarPoint(e){return e.copy(this.normal).multiplyScalar(-this.constant)}applyMatrix4(e,t){const i=t||ak.getNormalMatrix(e),r=this.coplanarPoint(up).applyMatrix4(e),s=this.normal.applyMatrix3(i).normalize();return this.constant=-r.dot(s),this}translate(e){return this.constant-=e.dot(this.normal),this}equals(e){return e.normal.equals(this.normal)&&e.constant===this.constant}clone(){return new this.constructor().copy(this)}};const ua=new Wr,Zu=new j;class R_{constructor(e=new ga,t=new ga,i=new ga,r=new ga,s=new ga,a=new ga){this.planes=[e,t,i,r,s,a]}set(e,t,i,r,s,a){const l=this.planes;return l[0].copy(e),l[1].copy(t),l[2].copy(i),l[3].copy(r),l[4].copy(s),l[5].copy(a),this}copy(e){const t=this.planes;for(let i=0;i<6;i++)t[i].copy(e.planes[i]);return this}setFromProjectionMatrix(e,t=cs){const i=this.planes,r=e.elements,s=r[0],a=r[1],l=r[2],d=r[3],h=r[4],m=r[5],u=r[6],g=r[7],v=r[8],w=r[9],T=r[10],M=r[11],b=r[12],A=r[13],E=r[14],P=r[15];if(i[0].setComponents(d-s,g-h,M-v,P-b).normalize(),i[1].setComponents(d+s,g+h,M+v,P+b).normalize(),i[2].setComponents(d+a,g+m,M+w,P+A).normalize(),i[3].setComponents(d-a,g-m,M-w,P-A).normalize(),i[4].setComponents(d-l,g-u,M-T,P-E).normalize(),t===cs)i[5].setComponents(d+l,g+u,M+T,P+E).normalize();else if(t===mh)i[5].setComponents(l,u,T,E).normalize();else throw new Error("THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: "+t);return this}intersectsObject(e){if(e.boundingSphere!==void 0)e.boundingSphere===null&&e.computeBoundingSphere(),ua.copy(e.boundingSphere).applyMatrix4(e.matrixWorld);else{const t=e.geometry;t.boundingSphere===null&&t.computeBoundingSphere(),ua.copy(t.boundingSphere).applyMatrix4(e.matrixWorld)}return this.intersectsSphere(ua)}intersectsSprite(e){return ua.center.set(0,0,0),ua.radius=.7071067811865476,ua.applyMatrix4(e.matrixWorld),this.intersectsSphere(ua)}intersectsSphere(e){const t=this.planes,i=e.center,r=-e.radius;for(let s=0;s<6;s++)if(t[s].distanceToPoint(i)0?e.max.x:e.min.x,Zu.y=r.normal.y>0?e.max.y:e.min.y,Zu.z=r.normal.z>0?e.max.z:e.min.z,r.distanceToPoint(Zu)<0)return!1}return!0}containsPoint(e){const t=this.planes;for(let i=0;i<6;i++)if(t[i].distanceToPoint(e)<0)return!1;return!0}clone(){return new this.constructor().copy(this)}}function IE(){let n=null,e=!1,t=null,i=null;function r(s,a){t(s,a),i=n.requestAnimationFrame(r)}return{start:function(){e!==!0&&t!==null&&(i=n.requestAnimationFrame(r),e=!0)},stop:function(){n.cancelAnimationFrame(i),e=!1},setAnimationLoop:function(s){t=s},setContext:function(s){n=s}}}function ok(n){const e=new WeakMap;function t(l,d){const h=l.array,m=l.usage,u=h.byteLength,g=n.createBuffer();n.bindBuffer(d,g),n.bufferData(d,h,m),l.onUploadCallback();let v;if(h instanceof Float32Array)v=n.FLOAT;else if(h instanceof Uint16Array)l.isFloat16BufferAttribute?v=n.HALF_FLOAT:v=n.UNSIGNED_SHORT;else if(h instanceof Int16Array)v=n.SHORT;else if(h instanceof Uint32Array)v=n.UNSIGNED_INT;else if(h instanceof Int32Array)v=n.INT;else if(h instanceof Int8Array)v=n.BYTE;else if(h instanceof Uint8Array)v=n.UNSIGNED_BYTE;else if(h instanceof Uint8ClampedArray)v=n.UNSIGNED_BYTE;else throw new Error("THREE.WebGLAttributes: Unsupported buffer data format: "+h);return{buffer:g,type:v,bytesPerElement:h.BYTES_PER_ELEMENT,version:l.version,size:u}}function i(l,d,h){const m=d.array,u=d._updateRange,g=d.updateRanges;if(n.bindBuffer(h,l),u.count===-1&&g.length===0&&n.bufferSubData(h,0,m),g.length!==0){for(let v=0,w=g.length;v 0
+ vec4 plane;
+ #ifdef ALPHA_TO_COVERAGE
+ float distanceToPlane, distanceGradient;
+ float clipOpacity = 1.0;
+ #pragma unroll_loop_start
+ for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
+ plane = clippingPlanes[ i ];
+ distanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;
+ distanceGradient = fwidth( distanceToPlane ) / 2.0;
+ clipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );
+ if ( clipOpacity == 0.0 ) discard;
+ }
+ #pragma unroll_loop_end
+ #if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
+ float unionClipOpacity = 1.0;
+ #pragma unroll_loop_start
+ for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
+ plane = clippingPlanes[ i ];
+ distanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;
+ distanceGradient = fwidth( distanceToPlane ) / 2.0;
+ unionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );
+ }
+ #pragma unroll_loop_end
+ clipOpacity *= 1.0 - unionClipOpacity;
+ #endif
+ diffuseColor.a *= clipOpacity;
+ if ( diffuseColor.a == 0.0 ) discard;
+ #else
+ #pragma unroll_loop_start
+ for ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {
+ plane = clippingPlanes[ i ];
+ if ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;
+ }
+ #pragma unroll_loop_end
+ #if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES
+ bool clipped = true;
+ #pragma unroll_loop_start
+ for ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {
+ plane = clippingPlanes[ i ];
+ clipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;
+ }
+ #pragma unroll_loop_end
+ if ( clipped ) discard;
+ #endif
+ #endif
+#endif`,Mk=`#if NUM_CLIPPING_PLANES > 0
+ varying vec3 vClipPosition;
+ uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];
+#endif`,Ek=`#if NUM_CLIPPING_PLANES > 0
+ varying vec3 vClipPosition;
+#endif`,Tk=`#if NUM_CLIPPING_PLANES > 0
+ vClipPosition = - mvPosition.xyz;
+#endif`,Ak=`#if defined( USE_COLOR_ALPHA )
+ diffuseColor *= vColor;
+#elif defined( USE_COLOR )
+ diffuseColor.rgb *= vColor;
+#endif`,Ck=`#if defined( USE_COLOR_ALPHA )
+ varying vec4 vColor;
+#elif defined( USE_COLOR )
+ varying vec3 vColor;
+#endif`,Rk=`#if defined( USE_COLOR_ALPHA )
+ varying vec4 vColor;
+#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )
+ varying vec3 vColor;
+#endif`,Pk=`#if defined( USE_COLOR_ALPHA )
+ vColor = vec4( 1.0 );
+#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )
+ vColor = vec3( 1.0 );
+#endif
+#ifdef USE_COLOR
+ vColor *= color;
+#endif
+#ifdef USE_INSTANCING_COLOR
+ vColor.xyz *= instanceColor.xyz;
+#endif
+#ifdef USE_BATCHING_COLOR
+ vec3 batchingColor = getBatchingColor( getIndirectIndex( gl_DrawID ) );
+ vColor.xyz *= batchingColor.xyz;
+#endif`,Lk=`#define PI 3.141592653589793
+#define PI2 6.283185307179586
+#define PI_HALF 1.5707963267948966
+#define RECIPROCAL_PI 0.3183098861837907
+#define RECIPROCAL_PI2 0.15915494309189535
+#define EPSILON 1e-6
+#ifndef saturate
+#define saturate( a ) clamp( a, 0.0, 1.0 )
+#endif
+#define whiteComplement( a ) ( 1.0 - saturate( a ) )
+float pow2( const in float x ) { return x*x; }
+vec3 pow2( const in vec3 x ) { return x*x; }
+float pow3( const in float x ) { return x*x*x; }
+float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
+float max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }
+float average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }
+highp float rand( const in vec2 uv ) {
+ const highp float a = 12.9898, b = 78.233, c = 43758.5453;
+ highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
+ return fract( sin( sn ) * c );
+}
+#ifdef HIGH_PRECISION
+ float precisionSafeLength( vec3 v ) { return length( v ); }
+#else
+ float precisionSafeLength( vec3 v ) {
+ float maxComponent = max3( abs( v ) );
+ return length( v / maxComponent ) * maxComponent;
+ }
+#endif
+struct IncidentLight {
+ vec3 color;
+ vec3 direction;
+ bool visible;
+};
+struct ReflectedLight {
+ vec3 directDiffuse;
+ vec3 directSpecular;
+ vec3 indirectDiffuse;
+ vec3 indirectSpecular;
+};
+#ifdef USE_ALPHAHASH
+ varying vec3 vPosition;
+#endif
+vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
+ return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
+}
+vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
+ return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
+}
+mat3 transposeMat3( const in mat3 m ) {
+ mat3 tmp;
+ tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
+ tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
+ tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
+ return tmp;
+}
+float luminance( const in vec3 rgb ) {
+ const vec3 weights = vec3( 0.2126729, 0.7151522, 0.0721750 );
+ return dot( weights, rgb );
+}
+bool isPerspectiveMatrix( mat4 m ) {
+ return m[ 2 ][ 3 ] == - 1.0;
+}
+vec2 equirectUv( in vec3 dir ) {
+ float u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;
+ float v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;
+ return vec2( u, v );
+}
+vec3 BRDF_Lambert( const in vec3 diffuseColor ) {
+ return RECIPROCAL_PI * diffuseColor;
+}
+vec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {
+ float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
+ return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
+}
+float F_Schlick( const in float f0, const in float f90, const in float dotVH ) {
+ float fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );
+ return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
+} // validated`,Ik=`#ifdef ENVMAP_TYPE_CUBE_UV
+ #define cubeUV_minMipLevel 4.0
+ #define cubeUV_minTileSize 16.0
+ float getFace( vec3 direction ) {
+ vec3 absDirection = abs( direction );
+ float face = - 1.0;
+ if ( absDirection.x > absDirection.z ) {
+ if ( absDirection.x > absDirection.y )
+ face = direction.x > 0.0 ? 0.0 : 3.0;
+ else
+ face = direction.y > 0.0 ? 1.0 : 4.0;
+ } else {
+ if ( absDirection.z > absDirection.y )
+ face = direction.z > 0.0 ? 2.0 : 5.0;
+ else
+ face = direction.y > 0.0 ? 1.0 : 4.0;
+ }
+ return face;
+ }
+ vec2 getUV( vec3 direction, float face ) {
+ vec2 uv;
+ if ( face == 0.0 ) {
+ uv = vec2( direction.z, direction.y ) / abs( direction.x );
+ } else if ( face == 1.0 ) {
+ uv = vec2( - direction.x, - direction.z ) / abs( direction.y );
+ } else if ( face == 2.0 ) {
+ uv = vec2( - direction.x, direction.y ) / abs( direction.z );
+ } else if ( face == 3.0 ) {
+ uv = vec2( - direction.z, direction.y ) / abs( direction.x );
+ } else if ( face == 4.0 ) {
+ uv = vec2( - direction.x, direction.z ) / abs( direction.y );
+ } else {
+ uv = vec2( direction.x, direction.y ) / abs( direction.z );
+ }
+ return 0.5 * ( uv + 1.0 );
+ }
+ vec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {
+ float face = getFace( direction );
+ float filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );
+ mipInt = max( mipInt, cubeUV_minMipLevel );
+ float faceSize = exp2( mipInt );
+ highp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;
+ if ( face > 2.0 ) {
+ uv.y += faceSize;
+ face -= 3.0;
+ }
+ uv.x += face * faceSize;
+ uv.x += filterInt * 3.0 * cubeUV_minTileSize;
+ uv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );
+ uv.x *= CUBEUV_TEXEL_WIDTH;
+ uv.y *= CUBEUV_TEXEL_HEIGHT;
+ #ifdef texture2DGradEXT
+ return texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;
+ #else
+ return texture2D( envMap, uv ).rgb;
+ #endif
+ }
+ #define cubeUV_r0 1.0
+ #define cubeUV_m0 - 2.0
+ #define cubeUV_r1 0.8
+ #define cubeUV_m1 - 1.0
+ #define cubeUV_r4 0.4
+ #define cubeUV_m4 2.0
+ #define cubeUV_r5 0.305
+ #define cubeUV_m5 3.0
+ #define cubeUV_r6 0.21
+ #define cubeUV_m6 4.0
+ float roughnessToMip( float roughness ) {
+ float mip = 0.0;
+ if ( roughness >= cubeUV_r1 ) {
+ mip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;
+ } else if ( roughness >= cubeUV_r4 ) {
+ mip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;
+ } else if ( roughness >= cubeUV_r5 ) {
+ mip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;
+ } else if ( roughness >= cubeUV_r6 ) {
+ mip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;
+ } else {
+ mip = - 2.0 * log2( 1.16 * roughness ); }
+ return mip;
+ }
+ vec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {
+ float mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );
+ float mipF = fract( mip );
+ float mipInt = floor( mip );
+ vec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );
+ if ( mipF == 0.0 ) {
+ return vec4( color0, 1.0 );
+ } else {
+ vec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );
+ return vec4( mix( color0, color1, mipF ), 1.0 );
+ }
+ }
+#endif`,Dk=`vec3 transformedNormal = objectNormal;
+#ifdef USE_TANGENT
+ vec3 transformedTangent = objectTangent;
+#endif
+#ifdef USE_BATCHING
+ mat3 bm = mat3( batchingMatrix );
+ transformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );
+ transformedNormal = bm * transformedNormal;
+ #ifdef USE_TANGENT
+ transformedTangent = bm * transformedTangent;
+ #endif
+#endif
+#ifdef USE_INSTANCING
+ mat3 im = mat3( instanceMatrix );
+ transformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );
+ transformedNormal = im * transformedNormal;
+ #ifdef USE_TANGENT
+ transformedTangent = im * transformedTangent;
+ #endif
+#endif
+transformedNormal = normalMatrix * transformedNormal;
+#ifdef FLIP_SIDED
+ transformedNormal = - transformedNormal;
+#endif
+#ifdef USE_TANGENT
+ transformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;
+ #ifdef FLIP_SIDED
+ transformedTangent = - transformedTangent;
+ #endif
+#endif`,kk=`#ifdef USE_DISPLACEMENTMAP
+ uniform sampler2D displacementMap;
+ uniform float displacementScale;
+ uniform float displacementBias;
+#endif`,Fk=`#ifdef USE_DISPLACEMENTMAP
+ transformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );
+#endif`,Uk=`#ifdef USE_EMISSIVEMAP
+ vec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );
+ totalEmissiveRadiance *= emissiveColor.rgb;
+#endif`,Ok=`#ifdef USE_EMISSIVEMAP
+ uniform sampler2D emissiveMap;
+#endif`,Nk="gl_FragColor = linearToOutputTexel( gl_FragColor );",Bk=`
+const mat3 LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = mat3(
+ vec3( 0.8224621, 0.177538, 0.0 ),
+ vec3( 0.0331941, 0.9668058, 0.0 ),
+ vec3( 0.0170827, 0.0723974, 0.9105199 )
+);
+const mat3 LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = mat3(
+ vec3( 1.2249401, - 0.2249404, 0.0 ),
+ vec3( - 0.0420569, 1.0420571, 0.0 ),
+ vec3( - 0.0196376, - 0.0786361, 1.0982735 )
+);
+vec4 LinearSRGBToLinearDisplayP3( in vec4 value ) {
+ return vec4( value.rgb * LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, value.a );
+}
+vec4 LinearDisplayP3ToLinearSRGB( in vec4 value ) {
+ return vec4( value.rgb * LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, value.a );
+}
+vec4 LinearTransferOETF( in vec4 value ) {
+ return value;
+}
+vec4 sRGBTransferOETF( in vec4 value ) {
+ return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
+}
+vec4 LinearToLinear( in vec4 value ) {
+ return value;
+}
+vec4 LinearTosRGB( in vec4 value ) {
+ return sRGBTransferOETF( value );
+}`,zk=`#ifdef USE_ENVMAP
+ #ifdef ENV_WORLDPOS
+ vec3 cameraToFrag;
+ if ( isOrthographic ) {
+ cameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
+ } else {
+ cameraToFrag = normalize( vWorldPosition - cameraPosition );
+ }
+ vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+ #ifdef ENVMAP_MODE_REFLECTION
+ vec3 reflectVec = reflect( cameraToFrag, worldNormal );
+ #else
+ vec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );
+ #endif
+ #else
+ vec3 reflectVec = vReflect;
+ #endif
+ #ifdef ENVMAP_TYPE_CUBE
+ vec4 envColor = textureCube( envMap, envMapRotation * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
+ #else
+ vec4 envColor = vec4( 0.0 );
+ #endif
+ #ifdef ENVMAP_BLENDING_MULTIPLY
+ outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
+ #elif defined( ENVMAP_BLENDING_MIX )
+ outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
+ #elif defined( ENVMAP_BLENDING_ADD )
+ outgoingLight += envColor.xyz * specularStrength * reflectivity;
+ #endif
+#endif`,Hk=`#ifdef USE_ENVMAP
+ uniform float envMapIntensity;
+ uniform float flipEnvMap;
+ uniform mat3 envMapRotation;
+ #ifdef ENVMAP_TYPE_CUBE
+ uniform samplerCube envMap;
+ #else
+ uniform sampler2D envMap;
+ #endif
+
+#endif`,Gk=`#ifdef USE_ENVMAP
+ uniform float reflectivity;
+ #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )
+ #define ENV_WORLDPOS
+ #endif
+ #ifdef ENV_WORLDPOS
+ varying vec3 vWorldPosition;
+ uniform float refractionRatio;
+ #else
+ varying vec3 vReflect;
+ #endif
+#endif`,Vk=`#ifdef USE_ENVMAP
+ #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )
+ #define ENV_WORLDPOS
+ #endif
+ #ifdef ENV_WORLDPOS
+
+ varying vec3 vWorldPosition;
+ #else
+ varying vec3 vReflect;
+ uniform float refractionRatio;
+ #endif
+#endif`,Wk=`#ifdef USE_ENVMAP
+ #ifdef ENV_WORLDPOS
+ vWorldPosition = worldPosition.xyz;
+ #else
+ vec3 cameraToVertex;
+ if ( isOrthographic ) {
+ cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
+ } else {
+ cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
+ }
+ vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
+ #ifdef ENVMAP_MODE_REFLECTION
+ vReflect = reflect( cameraToVertex, worldNormal );
+ #else
+ vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
+ #endif
+ #endif
+#endif`,jk=`#ifdef USE_FOG
+ vFogDepth = - mvPosition.z;
+#endif`,Xk=`#ifdef USE_FOG
+ varying float vFogDepth;
+#endif`,Yk=`#ifdef USE_FOG
+ #ifdef FOG_EXP2
+ float fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );
+ #else
+ float fogFactor = smoothstep( fogNear, fogFar, vFogDepth );
+ #endif
+ gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
+#endif`,$k=`#ifdef USE_FOG
+ uniform vec3 fogColor;
+ varying float vFogDepth;
+ #ifdef FOG_EXP2
+ uniform float fogDensity;
+ #else
+ uniform float fogNear;
+ uniform float fogFar;
+ #endif
+#endif`,qk=`#ifdef USE_GRADIENTMAP
+ uniform sampler2D gradientMap;
+#endif
+vec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {
+ float dotNL = dot( normal, lightDirection );
+ vec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );
+ #ifdef USE_GRADIENTMAP
+ return vec3( texture2D( gradientMap, coord ).r );
+ #else
+ vec2 fw = fwidth( coord ) * 0.5;
+ return mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );
+ #endif
+}`,Kk=`#ifdef USE_LIGHTMAP
+ uniform sampler2D lightMap;
+ uniform float lightMapIntensity;
+#endif`,Zk=`LambertMaterial material;
+material.diffuseColor = diffuseColor.rgb;
+material.specularStrength = specularStrength;`,Qk=`varying vec3 vViewPosition;
+struct LambertMaterial {
+ vec3 diffuseColor;
+ float specularStrength;
+};
+void RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+ float dotNL = saturate( dot( geometryNormal, directLight.direction ) );
+ vec3 irradiance = dotNL * directLight.color;
+ reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+void RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {
+ reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+#define RE_Direct RE_Direct_Lambert
+#define RE_IndirectDiffuse RE_IndirectDiffuse_Lambert`,Jk=`uniform bool receiveShadow;
+uniform vec3 ambientLightColor;
+#if defined( USE_LIGHT_PROBES )
+ uniform vec3 lightProbe[ 9 ];
+#endif
+vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+ float x = normal.x, y = normal.y, z = normal.z;
+ vec3 result = shCoefficients[ 0 ] * 0.886227;
+ result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
+ result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
+ result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
+ result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
+ result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
+ result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
+ result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
+ result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
+ return result;
+}
+vec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
+ vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+ vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
+ return irradiance;
+}
+vec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {
+ vec3 irradiance = ambientLightColor;
+ return irradiance;
+}
+float getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {
+ float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );
+ if ( cutoffDistance > 0.0 ) {
+ distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );
+ }
+ return distanceFalloff;
+}
+float getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {
+ return smoothstep( coneCosine, penumbraCosine, angleCosine );
+}
+#if NUM_DIR_LIGHTS > 0
+ struct DirectionalLight {
+ vec3 direction;
+ vec3 color;
+ };
+ uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];
+ void getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {
+ light.color = directionalLight.color;
+ light.direction = directionalLight.direction;
+ light.visible = true;
+ }
+#endif
+#if NUM_POINT_LIGHTS > 0
+ struct PointLight {
+ vec3 position;
+ vec3 color;
+ float distance;
+ float decay;
+ };
+ uniform PointLight pointLights[ NUM_POINT_LIGHTS ];
+ void getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {
+ vec3 lVector = pointLight.position - geometryPosition;
+ light.direction = normalize( lVector );
+ float lightDistance = length( lVector );
+ light.color = pointLight.color;
+ light.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );
+ light.visible = ( light.color != vec3( 0.0 ) );
+ }
+#endif
+#if NUM_SPOT_LIGHTS > 0
+ struct SpotLight {
+ vec3 position;
+ vec3 direction;
+ vec3 color;
+ float distance;
+ float decay;
+ float coneCos;
+ float penumbraCos;
+ };
+ uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];
+ void getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {
+ vec3 lVector = spotLight.position - geometryPosition;
+ light.direction = normalize( lVector );
+ float angleCos = dot( light.direction, spotLight.direction );
+ float spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );
+ if ( spotAttenuation > 0.0 ) {
+ float lightDistance = length( lVector );
+ light.color = spotLight.color * spotAttenuation;
+ light.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );
+ light.visible = ( light.color != vec3( 0.0 ) );
+ } else {
+ light.color = vec3( 0.0 );
+ light.visible = false;
+ }
+ }
+#endif
+#if NUM_RECT_AREA_LIGHTS > 0
+ struct RectAreaLight {
+ vec3 color;
+ vec3 position;
+ vec3 halfWidth;
+ vec3 halfHeight;
+ };
+ uniform sampler2D ltc_1; uniform sampler2D ltc_2;
+ uniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];
+#endif
+#if NUM_HEMI_LIGHTS > 0
+ struct HemisphereLight {
+ vec3 direction;
+ vec3 skyColor;
+ vec3 groundColor;
+ };
+ uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];
+ vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {
+ float dotNL = dot( normal, hemiLight.direction );
+ float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
+ vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
+ return irradiance;
+ }
+#endif`,e3=`#ifdef USE_ENVMAP
+ vec3 getIBLIrradiance( const in vec3 normal ) {
+ #ifdef ENVMAP_TYPE_CUBE_UV
+ vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+ vec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );
+ return PI * envMapColor.rgb * envMapIntensity;
+ #else
+ return vec3( 0.0 );
+ #endif
+ }
+ vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
+ #ifdef ENVMAP_TYPE_CUBE_UV
+ vec3 reflectVec = reflect( - viewDir, normal );
+ reflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );
+ reflectVec = inverseTransformDirection( reflectVec, viewMatrix );
+ vec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );
+ return envMapColor.rgb * envMapIntensity;
+ #else
+ return vec3( 0.0 );
+ #endif
+ }
+ #ifdef USE_ANISOTROPY
+ vec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {
+ #ifdef ENVMAP_TYPE_CUBE_UV
+ vec3 bentNormal = cross( bitangent, viewDir );
+ bentNormal = normalize( cross( bentNormal, bitangent ) );
+ bentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );
+ return getIBLRadiance( viewDir, bentNormal, roughness );
+ #else
+ return vec3( 0.0 );
+ #endif
+ }
+ #endif
+#endif`,t3=`ToonMaterial material;
+material.diffuseColor = diffuseColor.rgb;`,n3=`varying vec3 vViewPosition;
+struct ToonMaterial {
+ vec3 diffuseColor;
+};
+void RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
+ vec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;
+ reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+void RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {
+ reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+#define RE_Direct RE_Direct_Toon
+#define RE_IndirectDiffuse RE_IndirectDiffuse_Toon`,i3=`BlinnPhongMaterial material;
+material.diffuseColor = diffuseColor.rgb;
+material.specularColor = specular;
+material.specularShininess = shininess;
+material.specularStrength = specularStrength;`,r3=`varying vec3 vViewPosition;
+struct BlinnPhongMaterial {
+ vec3 diffuseColor;
+ vec3 specularColor;
+ float specularShininess;
+ float specularStrength;
+};
+void RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
+ float dotNL = saturate( dot( geometryNormal, directLight.direction ) );
+ vec3 irradiance = dotNL * directLight.color;
+ reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+ reflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;
+}
+void RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {
+ reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+#define RE_Direct RE_Direct_BlinnPhong
+#define RE_IndirectDiffuse RE_IndirectDiffuse_BlinnPhong`,s3=`PhysicalMaterial material;
+material.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );
+vec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );
+float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
+material.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;
+material.roughness = min( material.roughness, 1.0 );
+#ifdef IOR
+ material.ior = ior;
+ #ifdef USE_SPECULAR
+ float specularIntensityFactor = specularIntensity;
+ vec3 specularColorFactor = specularColor;
+ #ifdef USE_SPECULAR_COLORMAP
+ specularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;
+ #endif
+ #ifdef USE_SPECULAR_INTENSITYMAP
+ specularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;
+ #endif
+ material.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );
+ #else
+ float specularIntensityFactor = 1.0;
+ vec3 specularColorFactor = vec3( 1.0 );
+ material.specularF90 = 1.0;
+ #endif
+ material.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
+#else
+ material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );
+ material.specularF90 = 1.0;
+#endif
+#ifdef USE_CLEARCOAT
+ material.clearcoat = clearcoat;
+ material.clearcoatRoughness = clearcoatRoughness;
+ material.clearcoatF0 = vec3( 0.04 );
+ material.clearcoatF90 = 1.0;
+ #ifdef USE_CLEARCOATMAP
+ material.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;
+ #endif
+ #ifdef USE_CLEARCOAT_ROUGHNESSMAP
+ material.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;
+ #endif
+ material.clearcoat = saturate( material.clearcoat ); material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
+ material.clearcoatRoughness += geometryRoughness;
+ material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );
+#endif
+#ifdef USE_DISPERSION
+ material.dispersion = dispersion;
+#endif
+#ifdef USE_IRIDESCENCE
+ material.iridescence = iridescence;
+ material.iridescenceIOR = iridescenceIOR;
+ #ifdef USE_IRIDESCENCEMAP
+ material.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;
+ #endif
+ #ifdef USE_IRIDESCENCE_THICKNESSMAP
+ material.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;
+ #else
+ material.iridescenceThickness = iridescenceThicknessMaximum;
+ #endif
+#endif
+#ifdef USE_SHEEN
+ material.sheenColor = sheenColor;
+ #ifdef USE_SHEEN_COLORMAP
+ material.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;
+ #endif
+ material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
+ #ifdef USE_SHEEN_ROUGHNESSMAP
+ material.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;
+ #endif
+#endif
+#ifdef USE_ANISOTROPY
+ #ifdef USE_ANISOTROPYMAP
+ mat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );
+ vec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;
+ vec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;
+ #else
+ vec2 anisotropyV = anisotropyVector;
+ #endif
+ material.anisotropy = length( anisotropyV );
+ if( material.anisotropy == 0.0 ) {
+ anisotropyV = vec2( 1.0, 0.0 );
+ } else {
+ anisotropyV /= material.anisotropy;
+ material.anisotropy = saturate( material.anisotropy );
+ }
+ material.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );
+ material.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;
+ material.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;
+#endif`,a3=`struct PhysicalMaterial {
+ vec3 diffuseColor;
+ float roughness;
+ vec3 specularColor;
+ float specularF90;
+ float dispersion;
+ #ifdef USE_CLEARCOAT
+ float clearcoat;
+ float clearcoatRoughness;
+ vec3 clearcoatF0;
+ float clearcoatF90;
+ #endif
+ #ifdef USE_IRIDESCENCE
+ float iridescence;
+ float iridescenceIOR;
+ float iridescenceThickness;
+ vec3 iridescenceFresnel;
+ vec3 iridescenceF0;
+ #endif
+ #ifdef USE_SHEEN
+ vec3 sheenColor;
+ float sheenRoughness;
+ #endif
+ #ifdef IOR
+ float ior;
+ #endif
+ #ifdef USE_TRANSMISSION
+ float transmission;
+ float transmissionAlpha;
+ float thickness;
+ float attenuationDistance;
+ vec3 attenuationColor;
+ #endif
+ #ifdef USE_ANISOTROPY
+ float anisotropy;
+ float alphaT;
+ vec3 anisotropyT;
+ vec3 anisotropyB;
+ #endif
+};
+vec3 clearcoatSpecularDirect = vec3( 0.0 );
+vec3 clearcoatSpecularIndirect = vec3( 0.0 );
+vec3 sheenSpecularDirect = vec3( 0.0 );
+vec3 sheenSpecularIndirect = vec3(0.0 );
+vec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {
+ float x = clamp( 1.0 - dotVH, 0.0, 1.0 );
+ float x2 = x * x;
+ float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );
+ return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );
+}
+float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
+ float a2 = pow2( alpha );
+ float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );
+ float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );
+ return 0.5 / max( gv + gl, EPSILON );
+}
+float D_GGX( const in float alpha, const in float dotNH ) {
+ float a2 = pow2( alpha );
+ float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;
+ return RECIPROCAL_PI * a2 / pow2( denom );
+}
+#ifdef USE_ANISOTROPY
+ float V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {
+ float gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );
+ float gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );
+ float v = 0.5 / ( gv + gl );
+ return saturate(v);
+ }
+ float D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {
+ float a2 = alphaT * alphaB;
+ highp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );
+ highp float v2 = dot( v, v );
+ float w2 = a2 / v2;
+ return RECIPROCAL_PI * a2 * pow2 ( w2 );
+ }
+#endif
+#ifdef USE_CLEARCOAT
+ vec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {
+ vec3 f0 = material.clearcoatF0;
+ float f90 = material.clearcoatF90;
+ float roughness = material.clearcoatRoughness;
+ float alpha = pow2( roughness );
+ vec3 halfDir = normalize( lightDir + viewDir );
+ float dotNL = saturate( dot( normal, lightDir ) );
+ float dotNV = saturate( dot( normal, viewDir ) );
+ float dotNH = saturate( dot( normal, halfDir ) );
+ float dotVH = saturate( dot( viewDir, halfDir ) );
+ vec3 F = F_Schlick( f0, f90, dotVH );
+ float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
+ float D = D_GGX( alpha, dotNH );
+ return F * ( V * D );
+ }
+#endif
+vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {
+ vec3 f0 = material.specularColor;
+ float f90 = material.specularF90;
+ float roughness = material.roughness;
+ float alpha = pow2( roughness );
+ vec3 halfDir = normalize( lightDir + viewDir );
+ float dotNL = saturate( dot( normal, lightDir ) );
+ float dotNV = saturate( dot( normal, viewDir ) );
+ float dotNH = saturate( dot( normal, halfDir ) );
+ float dotVH = saturate( dot( viewDir, halfDir ) );
+ vec3 F = F_Schlick( f0, f90, dotVH );
+ #ifdef USE_IRIDESCENCE
+ F = mix( F, material.iridescenceFresnel, material.iridescence );
+ #endif
+ #ifdef USE_ANISOTROPY
+ float dotTL = dot( material.anisotropyT, lightDir );
+ float dotTV = dot( material.anisotropyT, viewDir );
+ float dotTH = dot( material.anisotropyT, halfDir );
+ float dotBL = dot( material.anisotropyB, lightDir );
+ float dotBV = dot( material.anisotropyB, viewDir );
+ float dotBH = dot( material.anisotropyB, halfDir );
+ float V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );
+ float D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );
+ #else
+ float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
+ float D = D_GGX( alpha, dotNH );
+ #endif
+ return F * ( V * D );
+}
+vec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {
+ const float LUT_SIZE = 64.0;
+ const float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;
+ const float LUT_BIAS = 0.5 / LUT_SIZE;
+ float dotNV = saturate( dot( N, V ) );
+ vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
+ uv = uv * LUT_SCALE + LUT_BIAS;
+ return uv;
+}
+float LTC_ClippedSphereFormFactor( const in vec3 f ) {
+ float l = length( f );
+ return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
+}
+vec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
+ float x = dot( v1, v2 );
+ float y = abs( x );
+ float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
+ float b = 3.4175940 + ( 4.1616724 + y ) * y;
+ float v = a / b;
+ float theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
+ return cross( v1, v2 ) * theta_sintheta;
+}
+vec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
+ vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
+ vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
+ vec3 lightNormal = cross( v1, v2 );
+ if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
+ vec3 T1, T2;
+ T1 = normalize( V - N * dot( V, N ) );
+ T2 = - cross( N, T1 );
+ mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
+ vec3 coords[ 4 ];
+ coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
+ coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
+ coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
+ coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
+ coords[ 0 ] = normalize( coords[ 0 ] );
+ coords[ 1 ] = normalize( coords[ 1 ] );
+ coords[ 2 ] = normalize( coords[ 2 ] );
+ coords[ 3 ] = normalize( coords[ 3 ] );
+ vec3 vectorFormFactor = vec3( 0.0 );
+ vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
+ vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
+ vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
+ vectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
+ float result = LTC_ClippedSphereFormFactor( vectorFormFactor );
+ return vec3( result );
+}
+#if defined( USE_SHEEN )
+float D_Charlie( float roughness, float dotNH ) {
+ float alpha = pow2( roughness );
+ float invAlpha = 1.0 / alpha;
+ float cos2h = dotNH * dotNH;
+ float sin2h = max( 1.0 - cos2h, 0.0078125 );
+ return ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );
+}
+float V_Neubelt( float dotNV, float dotNL ) {
+ return saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );
+}
+vec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {
+ vec3 halfDir = normalize( lightDir + viewDir );
+ float dotNL = saturate( dot( normal, lightDir ) );
+ float dotNV = saturate( dot( normal, viewDir ) );
+ float dotNH = saturate( dot( normal, halfDir ) );
+ float D = D_Charlie( sheenRoughness, dotNH );
+ float V = V_Neubelt( dotNV, dotNL );
+ return sheenColor * ( D * V );
+}
+#endif
+float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
+ float dotNV = saturate( dot( normal, viewDir ) );
+ float r2 = roughness * roughness;
+ float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
+ float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
+ float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
+ return saturate( DG * RECIPROCAL_PI );
+}
+vec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {
+ float dotNV = saturate( dot( normal, viewDir ) );
+ const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
+ const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
+ vec4 r = roughness * c0 + c1;
+ float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
+ vec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;
+ return fab;
+}
+vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {
+ vec2 fab = DFGApprox( normal, viewDir, roughness );
+ return specularColor * fab.x + specularF90 * fab.y;
+}
+#ifdef USE_IRIDESCENCE
+void computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
+#else
+void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
+#endif
+ vec2 fab = DFGApprox( normal, viewDir, roughness );
+ #ifdef USE_IRIDESCENCE
+ vec3 Fr = mix( specularColor, iridescenceF0, iridescence );
+ #else
+ vec3 Fr = specularColor;
+ #endif
+ vec3 FssEss = Fr * fab.x + specularF90 * fab.y;
+ float Ess = fab.x + fab.y;
+ float Ems = 1.0 - Ess;
+ vec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619; vec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );
+ singleScatter += FssEss;
+ multiScatter += Fms * Ems;
+}
+#if NUM_RECT_AREA_LIGHTS > 0
+ void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
+ vec3 normal = geometryNormal;
+ vec3 viewDir = geometryViewDir;
+ vec3 position = geometryPosition;
+ vec3 lightPos = rectAreaLight.position;
+ vec3 halfWidth = rectAreaLight.halfWidth;
+ vec3 halfHeight = rectAreaLight.halfHeight;
+ vec3 lightColor = rectAreaLight.color;
+ float roughness = material.roughness;
+ vec3 rectCoords[ 4 ];
+ rectCoords[ 0 ] = lightPos + halfWidth - halfHeight; rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
+ rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
+ rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
+ vec2 uv = LTC_Uv( normal, viewDir, roughness );
+ vec4 t1 = texture2D( ltc_1, uv );
+ vec4 t2 = texture2D( ltc_2, uv );
+ mat3 mInv = mat3(
+ vec3( t1.x, 0, t1.y ),
+ vec3( 0, 1, 0 ),
+ vec3( t1.z, 0, t1.w )
+ );
+ vec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );
+ reflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );
+ reflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
+ }
+#endif
+void RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
+ float dotNL = saturate( dot( geometryNormal, directLight.direction ) );
+ vec3 irradiance = dotNL * directLight.color;
+ #ifdef USE_CLEARCOAT
+ float dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );
+ vec3 ccIrradiance = dotNLcc * directLight.color;
+ clearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );
+ #endif
+ #ifdef USE_SHEEN
+ sheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );
+ #endif
+ reflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );
+ reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
+ reflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );
+}
+void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {
+ #ifdef USE_CLEARCOAT
+ clearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );
+ #endif
+ #ifdef USE_SHEEN
+ sheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );
+ #endif
+ vec3 singleScattering = vec3( 0.0 );
+ vec3 multiScattering = vec3( 0.0 );
+ vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
+ #ifdef USE_IRIDESCENCE
+ computeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );
+ #else
+ computeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );
+ #endif
+ vec3 totalScattering = singleScattering + multiScattering;
+ vec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );
+ reflectedLight.indirectSpecular += radiance * singleScattering;
+ reflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;
+ reflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;
+}
+#define RE_Direct RE_Direct_Physical
+#define RE_Direct_RectArea RE_Direct_RectArea_Physical
+#define RE_IndirectDiffuse RE_IndirectDiffuse_Physical
+#define RE_IndirectSpecular RE_IndirectSpecular_Physical
+float computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {
+ return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );
+}`,o3=`
+vec3 geometryPosition = - vViewPosition;
+vec3 geometryNormal = normal;
+vec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
+vec3 geometryClearcoatNormal = vec3( 0.0 );
+#ifdef USE_CLEARCOAT
+ geometryClearcoatNormal = clearcoatNormal;
+#endif
+#ifdef USE_IRIDESCENCE
+ float dotNVi = saturate( dot( normal, geometryViewDir ) );
+ if ( material.iridescenceThickness == 0.0 ) {
+ material.iridescence = 0.0;
+ } else {
+ material.iridescence = saturate( material.iridescence );
+ }
+ if ( material.iridescence > 0.0 ) {
+ material.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );
+ material.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );
+ }
+#endif
+IncidentLight directLight;
+#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
+ PointLight pointLight;
+ #if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
+ PointLightShadow pointLightShadow;
+ #endif
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
+ pointLight = pointLights[ i ];
+ getPointLightInfo( pointLight, geometryPosition, directLight );
+ #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
+ pointLightShadow = pointLightShadows[ i ];
+ directLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
+ #endif
+ RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+ }
+ #pragma unroll_loop_end
+#endif
+#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
+ SpotLight spotLight;
+ vec4 spotColor;
+ vec3 spotLightCoord;
+ bool inSpotLightMap;
+ #if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
+ SpotLightShadow spotLightShadow;
+ #endif
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
+ spotLight = spotLights[ i ];
+ getSpotLightInfo( spotLight, geometryPosition, directLight );
+ #if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )
+ #define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX
+ #elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
+ #define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS
+ #else
+ #define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )
+ #endif
+ #if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )
+ spotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;
+ inSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );
+ spotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );
+ directLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;
+ #endif
+ #undef SPOT_LIGHT_MAP_INDEX
+ #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
+ spotLightShadow = spotLightShadows[ i ];
+ directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
+ #endif
+ RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+ }
+ #pragma unroll_loop_end
+#endif
+#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
+ DirectionalLight directionalLight;
+ #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
+ DirectionalLightShadow directionalLightShadow;
+ #endif
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
+ directionalLight = directionalLights[ i ];
+ getDirectionalLightInfo( directionalLight, directLight );
+ #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
+ directionalLightShadow = directionalLightShadows[ i ];
+ directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+ #endif
+ RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+ }
+ #pragma unroll_loop_end
+#endif
+#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
+ RectAreaLight rectAreaLight;
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
+ rectAreaLight = rectAreaLights[ i ];
+ RE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+ }
+ #pragma unroll_loop_end
+#endif
+#if defined( RE_IndirectDiffuse )
+ vec3 iblIrradiance = vec3( 0.0 );
+ vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
+ #if defined( USE_LIGHT_PROBES )
+ irradiance += getLightProbeIrradiance( lightProbe, geometryNormal );
+ #endif
+ #if ( NUM_HEMI_LIGHTS > 0 )
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
+ irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );
+ }
+ #pragma unroll_loop_end
+ #endif
+#endif
+#if defined( RE_IndirectSpecular )
+ vec3 radiance = vec3( 0.0 );
+ vec3 clearcoatRadiance = vec3( 0.0 );
+#endif`,l3=`#if defined( RE_IndirectDiffuse )
+ #ifdef USE_LIGHTMAP
+ vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );
+ vec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;
+ irradiance += lightMapIrradiance;
+ #endif
+ #if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )
+ iblIrradiance += getIBLIrradiance( geometryNormal );
+ #endif
+#endif
+#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )
+ #ifdef USE_ANISOTROPY
+ radiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );
+ #else
+ radiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );
+ #endif
+ #ifdef USE_CLEARCOAT
+ clearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );
+ #endif
+#endif`,c3=`#if defined( RE_IndirectDiffuse )
+ RE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+#endif
+#if defined( RE_IndirectSpecular )
+ RE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+#endif`,u3=`#if defined( USE_LOGDEPTHBUF )
+ gl_FragDepth = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;
+#endif`,d3=`#if defined( USE_LOGDEPTHBUF )
+ uniform float logDepthBufFC;
+ varying float vFragDepth;
+ varying float vIsPerspective;
+#endif`,h3=`#ifdef USE_LOGDEPTHBUF
+ varying float vFragDepth;
+ varying float vIsPerspective;
+#endif`,f3=`#ifdef USE_LOGDEPTHBUF
+ vFragDepth = 1.0 + gl_Position.w;
+ vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
+#endif`,p3=`#ifdef USE_MAP
+ vec4 sampledDiffuseColor = texture2D( map, vMapUv );
+ #ifdef DECODE_VIDEO_TEXTURE
+ sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
+
+ #endif
+ diffuseColor *= sampledDiffuseColor;
+#endif`,m3=`#ifdef USE_MAP
+ uniform sampler2D map;
+#endif`,g3=`#if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+ #if defined( USE_POINTS_UV )
+ vec2 uv = vUv;
+ #else
+ vec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;
+ #endif
+#endif
+#ifdef USE_MAP
+ diffuseColor *= texture2D( map, uv );
+#endif
+#ifdef USE_ALPHAMAP
+ diffuseColor.a *= texture2D( alphaMap, uv ).g;
+#endif`,_3=`#if defined( USE_POINTS_UV )
+ varying vec2 vUv;
+#else
+ #if defined( USE_MAP ) || defined( USE_ALPHAMAP )
+ uniform mat3 uvTransform;
+ #endif
+#endif
+#ifdef USE_MAP
+ uniform sampler2D map;
+#endif
+#ifdef USE_ALPHAMAP
+ uniform sampler2D alphaMap;
+#endif`,v3=`float metalnessFactor = metalness;
+#ifdef USE_METALNESSMAP
+ vec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );
+ metalnessFactor *= texelMetalness.b;
+#endif`,y3=`#ifdef USE_METALNESSMAP
+ uniform sampler2D metalnessMap;
+#endif`,b3=`#ifdef USE_INSTANCING_MORPH
+ float morphTargetInfluences[ MORPHTARGETS_COUNT ];
+ float morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;
+ for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+ morphTargetInfluences[i] = texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;
+ }
+#endif`,x3=`#if defined( USE_MORPHCOLORS )
+ vColor *= morphTargetBaseInfluence;
+ for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+ #if defined( USE_COLOR_ALPHA )
+ if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];
+ #elif defined( USE_COLOR )
+ if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];
+ #endif
+ }
+#endif`,w3=`#ifdef USE_MORPHNORMALS
+ objectNormal *= morphTargetBaseInfluence;
+ for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+ if ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];
+ }
+#endif`,S3=`#ifdef USE_MORPHTARGETS
+ #ifndef USE_INSTANCING_MORPH
+ uniform float morphTargetBaseInfluence;
+ uniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];
+ #endif
+ uniform sampler2DArray morphTargetsTexture;
+ uniform ivec2 morphTargetsTextureSize;
+ vec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {
+ int texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;
+ int y = texelIndex / morphTargetsTextureSize.x;
+ int x = texelIndex - y * morphTargetsTextureSize.x;
+ ivec3 morphUV = ivec3( x, y, morphTargetIndex );
+ return texelFetch( morphTargetsTexture, morphUV, 0 );
+ }
+#endif`,M3=`#ifdef USE_MORPHTARGETS
+ transformed *= morphTargetBaseInfluence;
+ for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
+ if ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];
+ }
+#endif`,E3=`float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
+#ifdef FLAT_SHADED
+ vec3 fdx = dFdx( vViewPosition );
+ vec3 fdy = dFdy( vViewPosition );
+ vec3 normal = normalize( cross( fdx, fdy ) );
+#else
+ vec3 normal = normalize( vNormal );
+ #ifdef DOUBLE_SIDED
+ normal *= faceDirection;
+ #endif
+#endif
+#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )
+ #ifdef USE_TANGENT
+ mat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
+ #else
+ mat3 tbn = getTangentFrame( - vViewPosition, normal,
+ #if defined( USE_NORMALMAP )
+ vNormalMapUv
+ #elif defined( USE_CLEARCOAT_NORMALMAP )
+ vClearcoatNormalMapUv
+ #else
+ vUv
+ #endif
+ );
+ #endif
+ #if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )
+ tbn[0] *= faceDirection;
+ tbn[1] *= faceDirection;
+ #endif
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+ #ifdef USE_TANGENT
+ mat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
+ #else
+ mat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );
+ #endif
+ #if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )
+ tbn2[0] *= faceDirection;
+ tbn2[1] *= faceDirection;
+ #endif
+#endif
+vec3 nonPerturbedNormal = normal;`,T3=`#ifdef USE_NORMALMAP_OBJECTSPACE
+ normal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;
+ #ifdef FLIP_SIDED
+ normal = - normal;
+ #endif
+ #ifdef DOUBLE_SIDED
+ normal = normal * faceDirection;
+ #endif
+ normal = normalize( normalMatrix * normal );
+#elif defined( USE_NORMALMAP_TANGENTSPACE )
+ vec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;
+ mapN.xy *= normalScale;
+ normal = normalize( tbn * mapN );
+#elif defined( USE_BUMPMAP )
+ normal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );
+#endif`,A3=`#ifndef FLAT_SHADED
+ varying vec3 vNormal;
+ #ifdef USE_TANGENT
+ varying vec3 vTangent;
+ varying vec3 vBitangent;
+ #endif
+#endif`,C3=`#ifndef FLAT_SHADED
+ varying vec3 vNormal;
+ #ifdef USE_TANGENT
+ varying vec3 vTangent;
+ varying vec3 vBitangent;
+ #endif
+#endif`,R3=`#ifndef FLAT_SHADED
+ vNormal = normalize( transformedNormal );
+ #ifdef USE_TANGENT
+ vTangent = normalize( transformedTangent );
+ vBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );
+ #endif
+#endif`,P3=`#ifdef USE_NORMALMAP
+ uniform sampler2D normalMap;
+ uniform vec2 normalScale;
+#endif
+#ifdef USE_NORMALMAP_OBJECTSPACE
+ uniform mat3 normalMatrix;
+#endif
+#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )
+ mat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {
+ vec3 q0 = dFdx( eye_pos.xyz );
+ vec3 q1 = dFdy( eye_pos.xyz );
+ vec2 st0 = dFdx( uv.st );
+ vec2 st1 = dFdy( uv.st );
+ vec3 N = surf_norm;
+ vec3 q1perp = cross( q1, N );
+ vec3 q0perp = cross( N, q0 );
+ vec3 T = q1perp * st0.x + q0perp * st1.x;
+ vec3 B = q1perp * st0.y + q0perp * st1.y;
+ float det = max( dot( T, T ), dot( B, B ) );
+ float scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );
+ return mat3( T * scale, B * scale, N );
+ }
+#endif`,L3=`#ifdef USE_CLEARCOAT
+ vec3 clearcoatNormal = nonPerturbedNormal;
+#endif`,I3=`#ifdef USE_CLEARCOAT_NORMALMAP
+ vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;
+ clearcoatMapN.xy *= clearcoatNormalScale;
+ clearcoatNormal = normalize( tbn2 * clearcoatMapN );
+#endif`,D3=`#ifdef USE_CLEARCOATMAP
+ uniform sampler2D clearcoatMap;
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+ uniform sampler2D clearcoatNormalMap;
+ uniform vec2 clearcoatNormalScale;
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+ uniform sampler2D clearcoatRoughnessMap;
+#endif`,k3=`#ifdef USE_IRIDESCENCEMAP
+ uniform sampler2D iridescenceMap;
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+ uniform sampler2D iridescenceThicknessMap;
+#endif`,F3=`#ifdef OPAQUE
+diffuseColor.a = 1.0;
+#endif
+#ifdef USE_TRANSMISSION
+diffuseColor.a *= material.transmissionAlpha;
+#endif
+gl_FragColor = vec4( outgoingLight, diffuseColor.a );`,U3=`vec3 packNormalToRGB( const in vec3 normal ) {
+ return normalize( normal ) * 0.5 + 0.5;
+}
+vec3 unpackRGBToNormal( const in vec3 rgb ) {
+ return 2.0 * rgb.xyz - 1.0;
+}
+const float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;
+const vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );
+const vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );
+const float ShiftRight8 = 1. / 256.;
+vec4 packDepthToRGBA( const in float v ) {
+ vec4 r = vec4( fract( v * PackFactors ), v );
+ r.yzw -= r.xyz * ShiftRight8; return r * PackUpscale;
+}
+float unpackRGBAToDepth( const in vec4 v ) {
+ return dot( v, UnpackFactors );
+}
+vec2 packDepthToRG( in highp float v ) {
+ return packDepthToRGBA( v ).yx;
+}
+float unpackRGToDepth( const in highp vec2 v ) {
+ return unpackRGBAToDepth( vec4( v.xy, 0.0, 0.0 ) );
+}
+vec4 pack2HalfToRGBA( vec2 v ) {
+ vec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );
+ return vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );
+}
+vec2 unpackRGBATo2Half( vec4 v ) {
+ return vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );
+}
+float viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {
+ return ( viewZ + near ) / ( near - far );
+}
+float orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {
+ return depth * ( near - far ) - near;
+}
+float viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {
+ return ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );
+}
+float perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {
+ return ( near * far ) / ( ( far - near ) * depth - far );
+}`,O3=`#ifdef PREMULTIPLIED_ALPHA
+ gl_FragColor.rgb *= gl_FragColor.a;
+#endif`,N3=`vec4 mvPosition = vec4( transformed, 1.0 );
+#ifdef USE_BATCHING
+ mvPosition = batchingMatrix * mvPosition;
+#endif
+#ifdef USE_INSTANCING
+ mvPosition = instanceMatrix * mvPosition;
+#endif
+mvPosition = modelViewMatrix * mvPosition;
+gl_Position = projectionMatrix * mvPosition;`,B3=`#ifdef DITHERING
+ gl_FragColor.rgb = dithering( gl_FragColor.rgb );
+#endif`,z3=`#ifdef DITHERING
+ vec3 dithering( vec3 color ) {
+ float grid_position = rand( gl_FragCoord.xy );
+ vec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );
+ dither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );
+ return color + dither_shift_RGB;
+ }
+#endif`,H3=`float roughnessFactor = roughness;
+#ifdef USE_ROUGHNESSMAP
+ vec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );
+ roughnessFactor *= texelRoughness.g;
+#endif`,G3=`#ifdef USE_ROUGHNESSMAP
+ uniform sampler2D roughnessMap;
+#endif`,V3=`#if NUM_SPOT_LIGHT_COORDS > 0
+ varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];
+#endif
+#if NUM_SPOT_LIGHT_MAPS > 0
+ uniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];
+#endif
+#ifdef USE_SHADOWMAP
+ #if NUM_DIR_LIGHT_SHADOWS > 0
+ uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];
+ varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
+ struct DirectionalLightShadow {
+ float shadowIntensity;
+ float shadowBias;
+ float shadowNormalBias;
+ float shadowRadius;
+ vec2 shadowMapSize;
+ };
+ uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
+ #endif
+ #if NUM_SPOT_LIGHT_SHADOWS > 0
+ uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];
+ struct SpotLightShadow {
+ float shadowIntensity;
+ float shadowBias;
+ float shadowNormalBias;
+ float shadowRadius;
+ vec2 shadowMapSize;
+ };
+ uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
+ #endif
+ #if NUM_POINT_LIGHT_SHADOWS > 0
+ uniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];
+ varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
+ struct PointLightShadow {
+ float shadowIntensity;
+ float shadowBias;
+ float shadowNormalBias;
+ float shadowRadius;
+ vec2 shadowMapSize;
+ float shadowCameraNear;
+ float shadowCameraFar;
+ };
+ uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
+ #endif
+ float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {
+ return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );
+ }
+ vec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {
+ return unpackRGBATo2Half( texture2D( shadow, uv ) );
+ }
+ float VSMShadow (sampler2D shadow, vec2 uv, float compare ){
+ float occlusion = 1.0;
+ vec2 distribution = texture2DDistribution( shadow, uv );
+ float hard_shadow = step( compare , distribution.x );
+ if (hard_shadow != 1.0 ) {
+ float distance = compare - distribution.x ;
+ float variance = max( 0.00000, distribution.y * distribution.y );
+ float softness_probability = variance / (variance + distance * distance ); softness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 ); occlusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );
+ }
+ return occlusion;
+ }
+ float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {
+ float shadow = 1.0;
+ shadowCoord.xyz /= shadowCoord.w;
+ shadowCoord.z += shadowBias;
+ bool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;
+ bool frustumTest = inFrustum && shadowCoord.z <= 1.0;
+ if ( frustumTest ) {
+ #if defined( SHADOWMAP_TYPE_PCF )
+ vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
+ float dx0 = - texelSize.x * shadowRadius;
+ float dy0 = - texelSize.y * shadowRadius;
+ float dx1 = + texelSize.x * shadowRadius;
+ float dy1 = + texelSize.y * shadowRadius;
+ float dx2 = dx0 / 2.0;
+ float dy2 = dy0 / 2.0;
+ float dx3 = dx1 / 2.0;
+ float dy3 = dy1 / 2.0;
+ shadow = (
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )
+ ) * ( 1.0 / 17.0 );
+ #elif defined( SHADOWMAP_TYPE_PCF_SOFT )
+ vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
+ float dx = texelSize.x;
+ float dy = texelSize.y;
+ vec2 uv = shadowCoord.xy;
+ vec2 f = fract( uv * shadowMapSize + 0.5 );
+ uv -= f * texelSize;
+ shadow = (
+ texture2DCompare( shadowMap, uv, shadowCoord.z ) +
+ texture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +
+ texture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +
+ mix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),
+ texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),
+ f.x ) +
+ mix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),
+ texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),
+ f.x ) +
+ mix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),
+ texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),
+ f.y ) +
+ mix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),
+ texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),
+ f.y ) +
+ mix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),
+ texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),
+ f.x ),
+ mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),
+ texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),
+ f.x ),
+ f.y )
+ ) * ( 1.0 / 9.0 );
+ #elif defined( SHADOWMAP_TYPE_VSM )
+ shadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );
+ #else
+ shadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );
+ #endif
+ }
+ return mix( 1.0, shadow, shadowIntensity );
+ }
+ vec2 cubeToUV( vec3 v, float texelSizeY ) {
+ vec3 absV = abs( v );
+ float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );
+ absV *= scaleToCube;
+ v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );
+ vec2 planar = v.xy;
+ float almostATexel = 1.5 * texelSizeY;
+ float almostOne = 1.0 - almostATexel;
+ if ( absV.z >= almostOne ) {
+ if ( v.z > 0.0 )
+ planar.x = 4.0 - v.x;
+ } else if ( absV.x >= almostOne ) {
+ float signX = sign( v.x );
+ planar.x = v.z * signX + 2.0 * signX;
+ } else if ( absV.y >= almostOne ) {
+ float signY = sign( v.y );
+ planar.x = v.x + 2.0 * signY + 2.0;
+ planar.y = v.z * signY - 2.0;
+ }
+ return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );
+ }
+ float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {
+ float shadow = 1.0;
+ vec3 lightToPosition = shadowCoord.xyz;
+
+ float lightToPositionLength = length( lightToPosition );
+ if ( lightToPositionLength - shadowCameraFar <= 0.0 && lightToPositionLength - shadowCameraNear >= 0.0 ) {
+ float dp = ( lightToPositionLength - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear ); dp += shadowBias;
+ vec3 bd3D = normalize( lightToPosition );
+ vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );
+ #if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )
+ vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;
+ shadow = (
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +
+ texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )
+ ) * ( 1.0 / 9.0 );
+ #else
+ shadow = texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );
+ #endif
+ }
+ return mix( 1.0, shadow, shadowIntensity );
+ }
+#endif`,W3=`#if NUM_SPOT_LIGHT_COORDS > 0
+ uniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];
+ varying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];
+#endif
+#ifdef USE_SHADOWMAP
+ #if NUM_DIR_LIGHT_SHADOWS > 0
+ uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];
+ varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];
+ struct DirectionalLightShadow {
+ float shadowIntensity;
+ float shadowBias;
+ float shadowNormalBias;
+ float shadowRadius;
+ vec2 shadowMapSize;
+ };
+ uniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];
+ #endif
+ #if NUM_SPOT_LIGHT_SHADOWS > 0
+ struct SpotLightShadow {
+ float shadowIntensity;
+ float shadowBias;
+ float shadowNormalBias;
+ float shadowRadius;
+ vec2 shadowMapSize;
+ };
+ uniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];
+ #endif
+ #if NUM_POINT_LIGHT_SHADOWS > 0
+ uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];
+ varying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];
+ struct PointLightShadow {
+ float shadowIntensity;
+ float shadowBias;
+ float shadowNormalBias;
+ float shadowRadius;
+ vec2 shadowMapSize;
+ float shadowCameraNear;
+ float shadowCameraFar;
+ };
+ uniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];
+ #endif
+#endif`,j3=`#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )
+ vec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
+ vec4 shadowWorldPosition;
+#endif
+#if defined( USE_SHADOWMAP )
+ #if NUM_DIR_LIGHT_SHADOWS > 0
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
+ shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );
+ vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;
+ }
+ #pragma unroll_loop_end
+ #endif
+ #if NUM_POINT_LIGHT_SHADOWS > 0
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
+ shadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );
+ vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;
+ }
+ #pragma unroll_loop_end
+ #endif
+#endif
+#if NUM_SPOT_LIGHT_COORDS > 0
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {
+ shadowWorldPosition = worldPosition;
+ #if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
+ shadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;
+ #endif
+ vSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;
+ }
+ #pragma unroll_loop_end
+#endif`,X3=`float getShadowMask() {
+ float shadow = 1.0;
+ #ifdef USE_SHADOWMAP
+ #if NUM_DIR_LIGHT_SHADOWS > 0
+ DirectionalLightShadow directionalLight;
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {
+ directionalLight = directionalLightShadows[ i ];
+ shadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowIntensity, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+ }
+ #pragma unroll_loop_end
+ #endif
+ #if NUM_SPOT_LIGHT_SHADOWS > 0
+ SpotLightShadow spotLight;
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {
+ spotLight = spotLightShadows[ i ];
+ shadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowIntensity, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
+ }
+ #pragma unroll_loop_end
+ #endif
+ #if NUM_POINT_LIGHT_SHADOWS > 0
+ PointLightShadow pointLight;
+ #pragma unroll_loop_start
+ for ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {
+ pointLight = pointLightShadows[ i ];
+ shadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowIntensity, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;
+ }
+ #pragma unroll_loop_end
+ #endif
+ #endif
+ return shadow;
+}`,Y3=`#ifdef USE_SKINNING
+ mat4 boneMatX = getBoneMatrix( skinIndex.x );
+ mat4 boneMatY = getBoneMatrix( skinIndex.y );
+ mat4 boneMatZ = getBoneMatrix( skinIndex.z );
+ mat4 boneMatW = getBoneMatrix( skinIndex.w );
+#endif`,$3=`#ifdef USE_SKINNING
+ uniform mat4 bindMatrix;
+ uniform mat4 bindMatrixInverse;
+ uniform highp sampler2D boneTexture;
+ mat4 getBoneMatrix( const in float i ) {
+ int size = textureSize( boneTexture, 0 ).x;
+ int j = int( i ) * 4;
+ int x = j % size;
+ int y = j / size;
+ vec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );
+ vec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );
+ vec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );
+ vec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );
+ return mat4( v1, v2, v3, v4 );
+ }
+#endif`,q3=`#ifdef USE_SKINNING
+ vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
+ vec4 skinned = vec4( 0.0 );
+ skinned += boneMatX * skinVertex * skinWeight.x;
+ skinned += boneMatY * skinVertex * skinWeight.y;
+ skinned += boneMatZ * skinVertex * skinWeight.z;
+ skinned += boneMatW * skinVertex * skinWeight.w;
+ transformed = ( bindMatrixInverse * skinned ).xyz;
+#endif`,K3=`#ifdef USE_SKINNING
+ mat4 skinMatrix = mat4( 0.0 );
+ skinMatrix += skinWeight.x * boneMatX;
+ skinMatrix += skinWeight.y * boneMatY;
+ skinMatrix += skinWeight.z * boneMatZ;
+ skinMatrix += skinWeight.w * boneMatW;
+ skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
+ objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
+ #ifdef USE_TANGENT
+ objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
+ #endif
+#endif`,Z3=`float specularStrength;
+#ifdef USE_SPECULARMAP
+ vec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );
+ specularStrength = texelSpecular.r;
+#else
+ specularStrength = 1.0;
+#endif`,Q3=`#ifdef USE_SPECULARMAP
+ uniform sampler2D specularMap;
+#endif`,J3=`#if defined( TONE_MAPPING )
+ gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
+#endif`,eF=`#ifndef saturate
+#define saturate( a ) clamp( a, 0.0, 1.0 )
+#endif
+uniform float toneMappingExposure;
+vec3 LinearToneMapping( vec3 color ) {
+ return saturate( toneMappingExposure * color );
+}
+vec3 ReinhardToneMapping( vec3 color ) {
+ color *= toneMappingExposure;
+ return saturate( color / ( vec3( 1.0 ) + color ) );
+}
+vec3 OptimizedCineonToneMapping( vec3 color ) {
+ color *= toneMappingExposure;
+ color = max( vec3( 0.0 ), color - 0.004 );
+ return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );
+}
+vec3 RRTAndODTFit( vec3 v ) {
+ vec3 a = v * ( v + 0.0245786 ) - 0.000090537;
+ vec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;
+ return a / b;
+}
+vec3 ACESFilmicToneMapping( vec3 color ) {
+ const mat3 ACESInputMat = mat3(
+ vec3( 0.59719, 0.07600, 0.02840 ), vec3( 0.35458, 0.90834, 0.13383 ),
+ vec3( 0.04823, 0.01566, 0.83777 )
+ );
+ const mat3 ACESOutputMat = mat3(
+ vec3( 1.60475, -0.10208, -0.00327 ), vec3( -0.53108, 1.10813, -0.07276 ),
+ vec3( -0.07367, -0.00605, 1.07602 )
+ );
+ color *= toneMappingExposure / 0.6;
+ color = ACESInputMat * color;
+ color = RRTAndODTFit( color );
+ color = ACESOutputMat * color;
+ return saturate( color );
+}
+const mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(
+ vec3( 1.6605, - 0.1246, - 0.0182 ),
+ vec3( - 0.5876, 1.1329, - 0.1006 ),
+ vec3( - 0.0728, - 0.0083, 1.1187 )
+);
+const mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(
+ vec3( 0.6274, 0.0691, 0.0164 ),
+ vec3( 0.3293, 0.9195, 0.0880 ),
+ vec3( 0.0433, 0.0113, 0.8956 )
+);
+vec3 agxDefaultContrastApprox( vec3 x ) {
+ vec3 x2 = x * x;
+ vec3 x4 = x2 * x2;
+ return + 15.5 * x4 * x2
+ - 40.14 * x4 * x
+ + 31.96 * x4
+ - 6.868 * x2 * x
+ + 0.4298 * x2
+ + 0.1191 * x
+ - 0.00232;
+}
+vec3 AgXToneMapping( vec3 color ) {
+ const mat3 AgXInsetMatrix = mat3(
+ vec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),
+ vec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),
+ vec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )
+ );
+ const mat3 AgXOutsetMatrix = mat3(
+ vec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),
+ vec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),
+ vec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )
+ );
+ const float AgxMinEv = - 12.47393; const float AgxMaxEv = 4.026069;
+ color *= toneMappingExposure;
+ color = LINEAR_SRGB_TO_LINEAR_REC2020 * color;
+ color = AgXInsetMatrix * color;
+ color = max( color, 1e-10 ); color = log2( color );
+ color = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );
+ color = clamp( color, 0.0, 1.0 );
+ color = agxDefaultContrastApprox( color );
+ color = AgXOutsetMatrix * color;
+ color = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );
+ color = LINEAR_REC2020_TO_LINEAR_SRGB * color;
+ color = clamp( color, 0.0, 1.0 );
+ return color;
+}
+vec3 NeutralToneMapping( vec3 color ) {
+ const float StartCompression = 0.8 - 0.04;
+ const float Desaturation = 0.15;
+ color *= toneMappingExposure;
+ float x = min( color.r, min( color.g, color.b ) );
+ float offset = x < 0.08 ? x - 6.25 * x * x : 0.04;
+ color -= offset;
+ float peak = max( color.r, max( color.g, color.b ) );
+ if ( peak < StartCompression ) return color;
+ float d = 1. - StartCompression;
+ float newPeak = 1. - d * d / ( peak + d - StartCompression );
+ color *= newPeak / peak;
+ float g = 1. - 1. / ( Desaturation * ( peak - newPeak ) + 1. );
+ return mix( color, vec3( newPeak ), g );
+}
+vec3 CustomToneMapping( vec3 color ) { return color; }`,tF=`#ifdef USE_TRANSMISSION
+ material.transmission = transmission;
+ material.transmissionAlpha = 1.0;
+ material.thickness = thickness;
+ material.attenuationDistance = attenuationDistance;
+ material.attenuationColor = attenuationColor;
+ #ifdef USE_TRANSMISSIONMAP
+ material.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;
+ #endif
+ #ifdef USE_THICKNESSMAP
+ material.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;
+ #endif
+ vec3 pos = vWorldPosition;
+ vec3 v = normalize( cameraPosition - pos );
+ vec3 n = inverseTransformDirection( normal, viewMatrix );
+ vec4 transmitted = getIBLVolumeRefraction(
+ n, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,
+ pos, modelMatrix, viewMatrix, projectionMatrix, material.dispersion, material.ior, material.thickness,
+ material.attenuationColor, material.attenuationDistance );
+ material.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );
+ totalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );
+#endif`,nF=`#ifdef USE_TRANSMISSION
+ uniform float transmission;
+ uniform float thickness;
+ uniform float attenuationDistance;
+ uniform vec3 attenuationColor;
+ #ifdef USE_TRANSMISSIONMAP
+ uniform sampler2D transmissionMap;
+ #endif
+ #ifdef USE_THICKNESSMAP
+ uniform sampler2D thicknessMap;
+ #endif
+ uniform vec2 transmissionSamplerSize;
+ uniform sampler2D transmissionSamplerMap;
+ uniform mat4 modelMatrix;
+ uniform mat4 projectionMatrix;
+ varying vec3 vWorldPosition;
+ float w0( float a ) {
+ return ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );
+ }
+ float w1( float a ) {
+ return ( 1.0 / 6.0 ) * ( a * a * ( 3.0 * a - 6.0 ) + 4.0 );
+ }
+ float w2( float a ){
+ return ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );
+ }
+ float w3( float a ) {
+ return ( 1.0 / 6.0 ) * ( a * a * a );
+ }
+ float g0( float a ) {
+ return w0( a ) + w1( a );
+ }
+ float g1( float a ) {
+ return w2( a ) + w3( a );
+ }
+ float h0( float a ) {
+ return - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );
+ }
+ float h1( float a ) {
+ return 1.0 + w3( a ) / ( w2( a ) + w3( a ) );
+ }
+ vec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {
+ uv = uv * texelSize.zw + 0.5;
+ vec2 iuv = floor( uv );
+ vec2 fuv = fract( uv );
+ float g0x = g0( fuv.x );
+ float g1x = g1( fuv.x );
+ float h0x = h0( fuv.x );
+ float h1x = h1( fuv.x );
+ float h0y = h0( fuv.y );
+ float h1y = h1( fuv.y );
+ vec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+ vec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+ vec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+ vec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+ return g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +
+ g1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );
+ }
+ vec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {
+ vec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );
+ vec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );
+ vec2 fLodSizeInv = 1.0 / fLodSize;
+ vec2 cLodSizeInv = 1.0 / cLodSize;
+ vec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );
+ vec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );
+ return mix( fSample, cSample, fract( lod ) );
+ }
+ vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
+ vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
+ vec3 modelScale;
+ modelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );
+ modelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );
+ modelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );
+ return normalize( refractionVector ) * thickness * modelScale;
+ }
+ float applyIorToRoughness( const in float roughness, const in float ior ) {
+ return roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );
+ }
+ vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
+ float lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
+ return textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );
+ }
+ vec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
+ if ( isinf( attenuationDistance ) ) {
+ return vec3( 1.0 );
+ } else {
+ vec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;
+ vec3 transmittance = exp( - attenuationCoefficient * transmissionDistance ); return transmittance;
+ }
+ }
+ vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
+ const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
+ const in mat4 viewMatrix, const in mat4 projMatrix, const in float dispersion, const in float ior, const in float thickness,
+ const in vec3 attenuationColor, const in float attenuationDistance ) {
+ vec4 transmittedLight;
+ vec3 transmittance;
+ #ifdef USE_DISPERSION
+ float halfSpread = ( ior - 1.0 ) * 0.025 * dispersion;
+ vec3 iors = vec3( ior - halfSpread, ior, ior + halfSpread );
+ for ( int i = 0; i < 3; i ++ ) {
+ vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, iors[ i ], modelMatrix );
+ vec3 refractedRayExit = position + transmissionRay;
+
+ vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
+ vec2 refractionCoords = ndcPos.xy / ndcPos.w;
+ refractionCoords += 1.0;
+ refractionCoords /= 2.0;
+
+ vec4 transmissionSample = getTransmissionSample( refractionCoords, roughness, iors[ i ] );
+ transmittedLight[ i ] = transmissionSample[ i ];
+ transmittedLight.a += transmissionSample.a;
+ transmittance[ i ] = diffuseColor[ i ] * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance )[ i ];
+ }
+ transmittedLight.a /= 3.0;
+
+ #else
+
+ vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
+ vec3 refractedRayExit = position + transmissionRay;
+ vec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );
+ vec2 refractionCoords = ndcPos.xy / ndcPos.w;
+ refractionCoords += 1.0;
+ refractionCoords /= 2.0;
+ transmittedLight = getTransmissionSample( refractionCoords, roughness, ior );
+ transmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );
+
+ #endif
+ vec3 attenuatedColor = transmittance * transmittedLight.rgb;
+ vec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );
+ float transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;
+ return vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );
+ }
+#endif`,iF=`#if defined( USE_UV ) || defined( USE_ANISOTROPY )
+ varying vec2 vUv;
+#endif
+#ifdef USE_MAP
+ varying vec2 vMapUv;
+#endif
+#ifdef USE_ALPHAMAP
+ varying vec2 vAlphaMapUv;
+#endif
+#ifdef USE_LIGHTMAP
+ varying vec2 vLightMapUv;
+#endif
+#ifdef USE_AOMAP
+ varying vec2 vAoMapUv;
+#endif
+#ifdef USE_BUMPMAP
+ varying vec2 vBumpMapUv;
+#endif
+#ifdef USE_NORMALMAP
+ varying vec2 vNormalMapUv;
+#endif
+#ifdef USE_EMISSIVEMAP
+ varying vec2 vEmissiveMapUv;
+#endif
+#ifdef USE_METALNESSMAP
+ varying vec2 vMetalnessMapUv;
+#endif
+#ifdef USE_ROUGHNESSMAP
+ varying vec2 vRoughnessMapUv;
+#endif
+#ifdef USE_ANISOTROPYMAP
+ varying vec2 vAnisotropyMapUv;
+#endif
+#ifdef USE_CLEARCOATMAP
+ varying vec2 vClearcoatMapUv;
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+ varying vec2 vClearcoatNormalMapUv;
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+ varying vec2 vClearcoatRoughnessMapUv;
+#endif
+#ifdef USE_IRIDESCENCEMAP
+ varying vec2 vIridescenceMapUv;
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+ varying vec2 vIridescenceThicknessMapUv;
+#endif
+#ifdef USE_SHEEN_COLORMAP
+ varying vec2 vSheenColorMapUv;
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+ varying vec2 vSheenRoughnessMapUv;
+#endif
+#ifdef USE_SPECULARMAP
+ varying vec2 vSpecularMapUv;
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+ varying vec2 vSpecularColorMapUv;
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+ varying vec2 vSpecularIntensityMapUv;
+#endif
+#ifdef USE_TRANSMISSIONMAP
+ uniform mat3 transmissionMapTransform;
+ varying vec2 vTransmissionMapUv;
+#endif
+#ifdef USE_THICKNESSMAP
+ uniform mat3 thicknessMapTransform;
+ varying vec2 vThicknessMapUv;
+#endif`,rF=`#if defined( USE_UV ) || defined( USE_ANISOTROPY )
+ varying vec2 vUv;
+#endif
+#ifdef USE_MAP
+ uniform mat3 mapTransform;
+ varying vec2 vMapUv;
+#endif
+#ifdef USE_ALPHAMAP
+ uniform mat3 alphaMapTransform;
+ varying vec2 vAlphaMapUv;
+#endif
+#ifdef USE_LIGHTMAP
+ uniform mat3 lightMapTransform;
+ varying vec2 vLightMapUv;
+#endif
+#ifdef USE_AOMAP
+ uniform mat3 aoMapTransform;
+ varying vec2 vAoMapUv;
+#endif
+#ifdef USE_BUMPMAP
+ uniform mat3 bumpMapTransform;
+ varying vec2 vBumpMapUv;
+#endif
+#ifdef USE_NORMALMAP
+ uniform mat3 normalMapTransform;
+ varying vec2 vNormalMapUv;
+#endif
+#ifdef USE_DISPLACEMENTMAP
+ uniform mat3 displacementMapTransform;
+ varying vec2 vDisplacementMapUv;
+#endif
+#ifdef USE_EMISSIVEMAP
+ uniform mat3 emissiveMapTransform;
+ varying vec2 vEmissiveMapUv;
+#endif
+#ifdef USE_METALNESSMAP
+ uniform mat3 metalnessMapTransform;
+ varying vec2 vMetalnessMapUv;
+#endif
+#ifdef USE_ROUGHNESSMAP
+ uniform mat3 roughnessMapTransform;
+ varying vec2 vRoughnessMapUv;
+#endif
+#ifdef USE_ANISOTROPYMAP
+ uniform mat3 anisotropyMapTransform;
+ varying vec2 vAnisotropyMapUv;
+#endif
+#ifdef USE_CLEARCOATMAP
+ uniform mat3 clearcoatMapTransform;
+ varying vec2 vClearcoatMapUv;
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+ uniform mat3 clearcoatNormalMapTransform;
+ varying vec2 vClearcoatNormalMapUv;
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+ uniform mat3 clearcoatRoughnessMapTransform;
+ varying vec2 vClearcoatRoughnessMapUv;
+#endif
+#ifdef USE_SHEEN_COLORMAP
+ uniform mat3 sheenColorMapTransform;
+ varying vec2 vSheenColorMapUv;
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+ uniform mat3 sheenRoughnessMapTransform;
+ varying vec2 vSheenRoughnessMapUv;
+#endif
+#ifdef USE_IRIDESCENCEMAP
+ uniform mat3 iridescenceMapTransform;
+ varying vec2 vIridescenceMapUv;
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+ uniform mat3 iridescenceThicknessMapTransform;
+ varying vec2 vIridescenceThicknessMapUv;
+#endif
+#ifdef USE_SPECULARMAP
+ uniform mat3 specularMapTransform;
+ varying vec2 vSpecularMapUv;
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+ uniform mat3 specularColorMapTransform;
+ varying vec2 vSpecularColorMapUv;
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+ uniform mat3 specularIntensityMapTransform;
+ varying vec2 vSpecularIntensityMapUv;
+#endif
+#ifdef USE_TRANSMISSIONMAP
+ uniform mat3 transmissionMapTransform;
+ varying vec2 vTransmissionMapUv;
+#endif
+#ifdef USE_THICKNESSMAP
+ uniform mat3 thicknessMapTransform;
+ varying vec2 vThicknessMapUv;
+#endif`,sF=`#if defined( USE_UV ) || defined( USE_ANISOTROPY )
+ vUv = vec3( uv, 1 ).xy;
+#endif
+#ifdef USE_MAP
+ vMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_ALPHAMAP
+ vAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_LIGHTMAP
+ vLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_AOMAP
+ vAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_BUMPMAP
+ vBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_NORMALMAP
+ vNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_DISPLACEMENTMAP
+ vDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_EMISSIVEMAP
+ vEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_METALNESSMAP
+ vMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_ROUGHNESSMAP
+ vRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_ANISOTROPYMAP
+ vAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_CLEARCOATMAP
+ vClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+ vClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+ vClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_IRIDESCENCEMAP
+ vIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+ vIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_SHEEN_COLORMAP
+ vSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+ vSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_SPECULARMAP
+ vSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+ vSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+ vSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_TRANSMISSIONMAP
+ vTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;
+#endif
+#ifdef USE_THICKNESSMAP
+ vThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;
+#endif`,aF=`#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0
+ vec4 worldPosition = vec4( transformed, 1.0 );
+ #ifdef USE_BATCHING
+ worldPosition = batchingMatrix * worldPosition;
+ #endif
+ #ifdef USE_INSTANCING
+ worldPosition = instanceMatrix * worldPosition;
+ #endif
+ worldPosition = modelMatrix * worldPosition;
+#endif`;const oF=`varying vec2 vUv;
+uniform mat3 uvTransform;
+void main() {
+ vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
+ gl_Position = vec4( position.xy, 1.0, 1.0 );
+}`,lF=`uniform sampler2D t2D;
+uniform float backgroundIntensity;
+varying vec2 vUv;
+void main() {
+ vec4 texColor = texture2D( t2D, vUv );
+ #ifdef DECODE_VIDEO_TEXTURE
+ texColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );
+ #endif
+ texColor.rgb *= backgroundIntensity;
+ gl_FragColor = texColor;
+ #include
+ #include
+}`,cF=`varying vec3 vWorldDirection;
+#include
+void main() {
+ vWorldDirection = transformDirection( position, modelMatrix );
+ #include
+ #include
+ gl_Position.z = gl_Position.w;
+}`,uF=`#ifdef ENVMAP_TYPE_CUBE
+ uniform samplerCube envMap;
+#elif defined( ENVMAP_TYPE_CUBE_UV )
+ uniform sampler2D envMap;
+#endif
+uniform float flipEnvMap;
+uniform float backgroundBlurriness;
+uniform float backgroundIntensity;
+uniform mat3 backgroundRotation;
+varying vec3 vWorldDirection;
+#include
+void main() {
+ #ifdef ENVMAP_TYPE_CUBE
+ vec4 texColor = textureCube( envMap, backgroundRotation * vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );
+ #elif defined( ENVMAP_TYPE_CUBE_UV )
+ vec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );
+ #else
+ vec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );
+ #endif
+ texColor.rgb *= backgroundIntensity;
+ gl_FragColor = texColor;
+ #include
+ #include
+}`,dF=`varying vec3 vWorldDirection;
+#include
+void main() {
+ vWorldDirection = transformDirection( position, modelMatrix );
+ #include
+ #include
+ gl_Position.z = gl_Position.w;
+}`,hF=`uniform samplerCube tCube;
+uniform float tFlip;
+uniform float opacity;
+varying vec3 vWorldDirection;
+void main() {
+ vec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );
+ gl_FragColor = texColor;
+ gl_FragColor.a *= opacity;
+ #include
+ #include
+}`,fF=`#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+varying vec2 vHighPrecisionZW;
+void main() {
+ #include
+ #include
+ #include
+ #include
+ #ifdef USE_DISPLACEMENTMAP
+ #include
+ #include
+ #include
+ #endif
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ vHighPrecisionZW = gl_Position.zw;
+}`,pF=`#if DEPTH_PACKING == 3200
+ uniform float opacity;
+#endif
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+varying vec2 vHighPrecisionZW;
+void main() {
+ vec4 diffuseColor = vec4( 1.0 );
+ #include
+ #if DEPTH_PACKING == 3200
+ diffuseColor.a = opacity;
+ #endif
+ #include
+ #include
+ #include
+ #include
+ #include
+ float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
+ #if DEPTH_PACKING == 3200
+ gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
+ #elif DEPTH_PACKING == 3201
+ gl_FragColor = packDepthToRGBA( fragCoordZ );
+ #endif
+}`,mF=`#define DISTANCE
+varying vec3 vWorldPosition;
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+void main() {
+ #include
+ #include
+ #include
+ #include
+ #ifdef USE_DISPLACEMENTMAP
+ #include
+ #include
+ #include
+ #endif
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ vWorldPosition = worldPosition.xyz;
+}`,gF=`#define DISTANCE
+uniform vec3 referencePosition;
+uniform float nearDistance;
+uniform float farDistance;
+varying vec3 vWorldPosition;
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+void main () {
+ vec4 diffuseColor = vec4( 1.0 );
+ #include
+ #include
+ #include
+ #include
+ #include
+ float dist = length( vWorldPosition - referencePosition );
+ dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
+ dist = saturate( dist );
+ gl_FragColor = packDepthToRGBA( dist );
+}`,_F=`varying vec3 vWorldDirection;
+#include
+void main() {
+ vWorldDirection = transformDirection( position, modelMatrix );
+ #include
+ #include
+}`,vF=`uniform sampler2D tEquirect;
+varying vec3 vWorldDirection;
+#include
+void main() {
+ vec3 direction = normalize( vWorldDirection );
+ vec2 sampleUV = equirectUv( direction );
+ gl_FragColor = texture2D( tEquirect, sampleUV );
+ #include
+ #include
+}`,yF=`uniform float scale;
+attribute float lineDistance;
+varying float vLineDistance;
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+void main() {
+ vLineDistance = scale * lineDistance;
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+}`,bF=`uniform vec3 diffuse;
+uniform float opacity;
+uniform float dashSize;
+uniform float totalSize;
+varying float vLineDistance;
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+void main() {
+ vec4 diffuseColor = vec4( diffuse, opacity );
+ #include
+ if ( mod( vLineDistance, totalSize ) > dashSize ) {
+ discard;
+ }
+ vec3 outgoingLight = vec3( 0.0 );
+ #include
+ #include
+ #include
+ outgoingLight = diffuseColor.rgb;
+ #include
+ #include
+ #include
+ #include
+ #include
+}`,xF=`#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+void main() {
+ #include
+ #include
+ #include
+ #include
+ #include
+ #if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
+ #include
+ #include