=B", "boolean"], ["A<=B", "boolean"]];
+ };
+ LiteGraph.registerNodeType("math/compare", r);
+ t.values = "> < == != <= >=".split(" ");
+ t["@OP"] = {type:"enum", title:"operation", values:t.values};
+ t.title = "Condition";
+ t.desc = "evaluates condition between A and B";
+ t.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ void 0 === a ? a = this.properties.A : this.properties.A = a;
+ var b = this.getInputData(1);
+ void 0 === b ? b = this.properties.B : this.properties.B = b;
+ var d = !0;
+ switch(this.properties.OP) {
+ case ">":
+ d = a > b;
+ break;
+ case "<":
+ d = a < b;
+ break;
+ case "==":
+ d = a == b;
+ break;
+ case "!=":
+ d = a != b;
+ break;
+ case "<=":
+ d = a <= b;
+ break;
+ case ">=":
+ d = a >= b;
+ }
+ this.setOutputData(0, d);
+ };
+ LiteGraph.registerNodeType("math/condition", t);
+ p.title = "Accumulate";
+ p.desc = "Increments a value every time";
+ p.prototype.onExecute = function() {
+ null === this.properties.value && (this.properties.value = 0);
+ var a = this.getInputData(0);
+ this.properties.value = null !== a ? this.properties.value + a : this.properties.value + this.properties.increment;
+ this.setOutputData(0, this.properties.value);
+ };
+ LiteGraph.registerNodeType("math/accumulate", p);
+ q.title = "Trigonometry";
+ q.desc = "Sin Cos Tan";
+ q.filter = "shader";
+ q.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null == a && (a = 0);
+ var b = this.properties.amplitude, d = this.findInputSlot("amplitude");
+ -1 != d && (b = this.getInputData(d));
+ var c = this.properties.offset;
+ d = this.findInputSlot("offset");
+ -1 != d && (c = this.getInputData(d));
+ d = 0;
+ for (var e = this.outputs.length; d < e; ++d) {
+ switch(this.outputs[d].name) {
+ case "sin":
+ value = Math.sin(a);
+ break;
+ case "cos":
+ value = Math.cos(a);
+ break;
+ case "tan":
+ value = Math.tan(a);
+ break;
+ case "asin":
+ value = Math.asin(a);
+ break;
+ case "acos":
+ value = Math.acos(a);
+ break;
+ case "atan":
+ value = Math.atan(a);
+ }
+ this.setOutputData(d, b * value + c);
+ }
+ };
+ q.prototype.onGetInputs = function() {
+ return [["v", "number"], ["amplitude", "number"], ["offset", "number"]];
+ };
+ q.prototype.onGetOutputs = function() {
+ return [["sin", "number"], ["cos", "number"], ["tan", "number"], ["asin", "number"], ["acos", "number"], ["atan", "number"]];
+ };
+ LiteGraph.registerNodeType("math/trigonometry", q);
+ if (window.math) {
+ var x = function() {
+ this.addInputs("x", "number");
+ this.addInputs("y", "number");
+ this.addOutputs("", "number");
+ this.properties = {x:1.0, y:1.0, formula:"x+y"};
+ };
+ x.title = "Formula";
+ x.desc = "Compute safe formula";
+ x.prototype.onExecute = function() {
+ var a = this.getInputData(0), b = this.getInputData(1);
+ null != a ? this.properties.x = a : a = this.properties.x;
+ null != b ? this.properties.y = b : b = this.properties.y;
+ a = math.eval(this.properties.formula, {x:a, y:b, T:this.graph.globaltime});
+ this.setOutputData(0, a);
+ };
+ x.prototype.onDrawBackground = function() {
+ this.outputs[0].label = this.properties.formula;
+ };
+ x.prototype.onGetOutputs = function() {
+ return [["A-B", "number"], ["A*B", "number"], ["A/B", "number"]];
+ };
+ LiteGraph.registerNodeType("math/formula", x);
+ }
+ w.title = "Vec2->XY";
+ w.desc = "vector 2 to components";
+ w.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null != a && (this.setOutputData(0, a[0]), this.setOutputData(1, a[1]));
+ };
+ LiteGraph.registerNodeType("math3d/vec2-to-xyz", w);
+ y.title = "XY->Vec2";
+ y.desc = "components to vector2";
+ y.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null == a && (a = this.properties.x);
+ var b = this.getInputData(1);
+ null == b && (b = this.properties.y);
+ var d = this._data;
+ d[0] = a;
+ d[1] = b;
+ this.setOutputData(0, d);
+ };
+ LiteGraph.registerNodeType("math3d/xy-to-vec2", y);
+ z.title = "Vec3->XYZ";
+ z.desc = "vector 3 to components";
+ z.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null != a && (this.setOutputData(0, a[0]), this.setOutputData(1, a[1]), this.setOutputData(2, a[2]));
+ };
+ LiteGraph.registerNodeType("math3d/vec3-to-xyz", z);
+ A.title = "XYZ->Vec3";
+ A.desc = "components to vector3";
+ A.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null == a && (a = this.properties.x);
+ var b = this.getInputData(1);
+ null == b && (b = this.properties.y);
+ var d = this.getInputData(2);
+ null == d && (d = this.properties.z);
+ var c = this._data;
+ c[0] = a;
+ c[1] = b;
+ c[2] = d;
+ this.setOutputData(0, c);
+ };
+ LiteGraph.registerNodeType("math3d/xyz-to-vec3", A);
+ B.title = "Vec4->XYZW";
+ B.desc = "vector 4 to components";
+ B.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null != a && (this.setOutputData(0, a[0]), this.setOutputData(1, a[1]), this.setOutputData(2, a[2]), this.setOutputData(3, a[3]));
+ };
+ LiteGraph.registerNodeType("math3d/vec4-to-xyzw", B);
+ C.title = "XYZW->Vec4";
+ C.desc = "components to vector4";
+ C.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null == a && (a = this.properties.x);
+ var b = this.getInputData(1);
+ null == b && (b = this.properties.y);
+ var d = this.getInputData(2);
+ null == d && (d = this.properties.z);
+ var c = this.getInputData(3);
+ null == c && (c = this.properties.w);
+ var e = this._data;
+ e[0] = a;
+ e[1] = b;
+ e[2] = d;
+ e[3] = c;
+ this.setOutputData(0, e);
+ };
+ LiteGraph.registerNodeType("math3d/xyzw-to-vec4", C);
+ if (window.glMatrix) {
+ x = function() {
+ this.addInputs([["A", "quat"], ["B", "quat"], ["factor", "number"]]);
+ this.addOutput("slerp", "quat");
+ this.addProperty("factor", 0.5);
+ this._value = quat.create();
+ };
+ var D = function() {
+ this.addInputs([["A", "quat"], ["B", "quat"]]);
+ this.addOutput("A*B", "quat");
+ this._value = quat.create();
+ }, E = function() {
+ this.addInputs([["vec3", "vec3"], ["quat", "quat"]]);
+ this.addOutput("result", "vec3");
+ this.properties = {vec:[0, 0, 1]};
+ }, F = function() {
+ this.addInputs([["degrees", "number"], ["axis", "vec3"]]);
+ this.addOutput("quat", "quat");
+ this.properties = {angle:90.0, axis:vec3.fromValues(0, 1, 0)};
+ this._value = quat.create();
+ }, G = function() {
+ this.addOutput("quat", "quat");
+ this.properties = {x:0, y:0, z:0, w:1};
+ this._value = quat.create();
+ };
+ G.title = "Quaternion";
+ G.desc = "quaternion";
+ G.prototype.onExecute = function() {
+ this._value[0] = this.properties.x;
+ this._value[1] = this.properties.y;
+ this._value[2] = this.properties.z;
+ this._value[3] = this.properties.w;
+ this.setOutputData(0, this._value);
+ };
+ LiteGraph.registerNodeType("math3d/quaternion", G);
+ F.title = "Rotation";
+ F.desc = "quaternion rotation";
+ F.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null == a && (a = this.properties.angle);
+ var b = this.getInputData(1);
+ null == b && (b = this.properties.axis);
+ a = quat.setAxisAngle(this._value, b, 0.0174532925 * a);
+ this.setOutputData(0, a);
+ };
+ LiteGraph.registerNodeType("math3d/rotation", F);
+ E.title = "Rot. Vec3";
+ E.desc = "rotate a point";
+ E.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ null == a && (a = this.properties.vec);
+ var b = this.getInputData(1);
+ null == b ? this.setOutputData(a) : this.setOutputData(0, vec3.transformQuat(vec3.create(), a, b));
+ };
+ LiteGraph.registerNodeType("math3d/rotate_vec3", E);
+ D.title = "Mult. Quat";
+ D.desc = "rotate quaternion";
+ D.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ if (null != a) {
+ var b = this.getInputData(1);
+ null != b && (a = quat.multiply(this._value, a, b), this.setOutputData(0, a));
+ }
+ };
+ LiteGraph.registerNodeType("math3d/mult-quat", D);
+ x.title = "Quat Slerp";
+ x.desc = "quaternion spherical interpolation";
+ x.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ if (null != a) {
+ var b = this.getInputData(1);
+ if (null != b) {
+ var d = this.properties.factor;
+ null != this.getInputData(2) && (d = this.getInputData(2));
+ a = quat.slerp(this._value, a, b, d);
+ this.setOutputData(0, a);
+ }
+ }
+ };
+ LiteGraph.registerNodeType("math3d/quat-slerp", x);
+ }
+})();
+function Selector() {
+ this.addInput("sel", "boolean");
+ this.addOutput("value", "number");
+ this.properties = {A:0, B:1};
+ this.size = [60, 20];
+}
+Selector.title = "Selector";
+Selector.desc = "outputs A if selector is true, B if selector is false";
+Selector.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (void 0 !== c) {
+ for (var e = 1; e < this.inputs.length; e++) {
+ var f = this.inputs[e], g = this.getInputData(e);
+ void 0 !== g && (this.properties[f.name] = g);
+ }
+ e = this.properties.A;
+ f = this.properties.B;
+ this.setOutputData(0, c ? e : f);
+ }
+};
+Selector.prototype.onGetInputs = function() {
+ return [["A", 0], ["B", 0]];
+};
+LiteGraph.registerNodeType("logic/selector", Selector);
+(function() {
+ function c() {
+ this.inputs = [];
+ this.addOutput("frame", "image");
+ this.properties = {url:""};
+ }
+ function e() {
+ this.addInput("f", "number");
+ this.addOutput("Color", "color");
+ this.properties = {colorA:"#444444", colorB:"#44AAFF", colorC:"#44FFAA", colorD:"#FFFFFF"};
+ }
+ function f() {
+ this.addInput("", "image");
+ this.size = [200, 200];
+ }
+ function g() {
+ this.addInputs([["img1", "image"], ["img2", "image"], ["fade", "number"]]);
+ this.addInput("", "image");
+ this.properties = {fade:0.5, width:512, height:512};
+ }
+ function l() {
+ this.addInput("", "image");
+ this.addOutput("", "image");
+ this.properties = {width:256, height:256, x:0, y:0, scale:1.0};
+ this.size = [50, 20];
+ }
+ function k() {
+ this.addInput("t", "number");
+ this.addOutputs([["frame", "image"], ["t", "number"], ["d", "number"]]);
+ this.properties = {url:""};
+ }
+ function a() {
+ this.addOutput("Webcam", "image");
+ this.properties = {};
+ }
+ c.title = "Image";
+ c.desc = "Image loader";
+ c.widgets = [{name:"load", text:"Load", type:"button"}];
+ c.supported_extensions = ["jpg", "jpeg", "png", "gif"];
+ c.prototype.onAdded = function() {
+ "" != this.properties.url && null == this.img && this.loadImage(this.properties.url);
+ };
+ c.prototype.onDrawBackground = function(a) {
+ this.img && 5 < this.size[0] && 5 < this.size[1] && a.drawImage(this.img, 0, 0, this.size[0], this.size[1]);
+ };
+ c.prototype.onExecute = function() {
+ this.img || (this.boxcolor = "#000");
+ this.img && this.img.width ? this.setOutputData(0, this.img) : this.setOutputData(0, null);
+ this.img && this.img.dirty && (this.img.dirty = !1);
+ };
+ c.prototype.onPropertyChanged = function(a, d) {
+ this.properties[a] = d;
+ "url" == a && "" != d && this.loadImage(d);
+ return !0;
+ };
+ c.prototype.loadImage = function(a, d) {
+ if ("" == a) {
+ this.img = null;
+ } else {
+ this.img = document.createElement("img");
+ "http://" == a.substr(0, 7) && LiteGraph.proxy && (a = LiteGraph.proxy + a.substr(7));
+ this.img.src = a;
+ this.boxcolor = "#F95";
+ var b = this;
+ this.img.onload = function() {
+ d && d(this);
+ b.trace("Image loaded, size: " + b.img.width + "x" + b.img.height);
+ this.dirty = !0;
+ b.boxcolor = "#9F9";
+ b.setDirtyCanvas(!0);
+ };
+ }
+ };
+ c.prototype.onWidget = function(a, d) {
+ "load" == d.name && this.loadImage(this.properties.url);
+ };
+ c.prototype.onDropFile = function(a) {
+ var b = this;
+ this._url && URL.revokeObjectURL(this._url);
+ this._url = URL.createObjectURL(a);
+ this.properties.url = this._url;
+ this.loadImage(this._url, function(a) {
+ b.size[1] = a.height / a.width * b.size[0];
+ });
+ };
+ LiteGraph.registerNodeType("graphics/image", c);
+ e.title = "Palette";
+ e.desc = "Generates a color";
+ e.prototype.onExecute = function() {
+ var a = [];
+ null != this.properties.colorA && a.push(hex2num(this.properties.colorA));
+ null != this.properties.colorB && a.push(hex2num(this.properties.colorB));
+ null != this.properties.colorC && a.push(hex2num(this.properties.colorC));
+ null != this.properties.colorD && a.push(hex2num(this.properties.colorD));
+ var d = this.getInputData(0);
+ null == d && (d = 0.5);
+ 1.0 < d ? d = 1.0 : 0.0 > d && (d = 0.0);
+ if (0 != a.length) {
+ var c = [0, 0, 0];
+ if (0 == d) {
+ c = a[0];
+ } else {
+ if (1 == d) {
+ c = a[a.length - 1];
+ } else {
+ var e = (a.length - 1) * d;
+ d = a[Math.floor(e)];
+ a = a[Math.floor(e) + 1];
+ e -= Math.floor(e);
+ c[0] = d[0] * (1 - e) + a[0] * e;
+ c[1] = d[1] * (1 - e) + a[1] * e;
+ c[2] = d[2] * (1 - e) + a[2] * e;
+ }
+ }
+ for (var f in c) {
+ c[f] /= 255;
+ }
+ this.boxcolor = colorToString(c);
+ this.setOutputData(0, c);
+ }
+ };
+ LiteGraph.registerNodeType("color/palette", e);
+ f.title = "Frame";
+ f.desc = "Frame viewerew";
+ f.widgets = [{name:"resize", text:"Resize box", type:"button"}, {name:"view", text:"View Image", type:"button"}];
+ f.prototype.onDrawBackground = function(a) {
+ this.frame && a.drawImage(this.frame, 0, 0, this.size[0], this.size[1]);
+ };
+ f.prototype.onExecute = function() {
+ this.frame = this.getInputData(0);
+ this.setDirtyCanvas(!0);
+ };
+ f.prototype.onWidget = function(a, d) {
+ "resize" == d.name && this.frame ? (a = this.frame.width, d = this.frame.height, a || null == this.frame.videoWidth || (a = this.frame.videoWidth, d = this.frame.videoHeight), a && d && (this.size = [a, d]), this.setDirtyCanvas(!0, !0)) : "view" == d.name && this.show();
+ };
+ f.prototype.show = function() {
+ showElement && this.frame && showElement(this.frame);
+ };
+ LiteGraph.registerNodeType("graphics/frame", f);
+ g.title = "Image fade";
+ g.desc = "Fades between images";
+ g.widgets = [{name:"resizeA", text:"Resize to A", type:"button"}, {name:"resizeB", text:"Resize to B", type:"button"}];
+ g.prototype.onAdded = function() {
+ this.createCanvas();
+ var a = this.canvas.getContext("2d");
+ a.fillStyle = "#000";
+ a.fillRect(0, 0, this.properties.width, this.properties.height);
+ };
+ g.prototype.createCanvas = function() {
+ this.canvas = document.createElement("canvas");
+ this.canvas.width = this.properties.width;
+ this.canvas.height = this.properties.height;
+ };
+ g.prototype.onExecute = function() {
+ var a = this.canvas.getContext("2d");
+ this.canvas.width = this.canvas.width;
+ var d = this.getInputData(0);
+ null != d && a.drawImage(d, 0, 0, this.canvas.width, this.canvas.height);
+ d = this.getInputData(2);
+ null == d ? d = this.properties.fade : this.properties.fade = d;
+ a.globalAlpha = d;
+ d = this.getInputData(1);
+ null != d && a.drawImage(d, 0, 0, this.canvas.width, this.canvas.height);
+ a.globalAlpha = 1.0;
+ this.setOutputData(0, this.canvas);
+ this.setDirtyCanvas(!0);
+ };
+ LiteGraph.registerNodeType("graphics/imagefade", g);
+ l.title = "Crop";
+ l.desc = "Crop Image";
+ l.prototype.onAdded = function() {
+ this.createCanvas();
+ };
+ l.prototype.createCanvas = function() {
+ this.canvas = document.createElement("canvas");
+ this.canvas.width = this.properties.width;
+ this.canvas.height = this.properties.height;
+ };
+ l.prototype.onExecute = function() {
+ var a = this.getInputData(0);
+ a && (a.width ? (this.canvas.getContext("2d").drawImage(a, -this.properties.x, -this.properties.y, a.width * this.properties.scale, a.height * this.properties.scale), this.setOutputData(0, this.canvas)) : this.setOutputData(0, null));
+ };
+ l.prototype.onDrawBackground = function(a) {
+ this.flags.collapsed || this.canvas && a.drawImage(this.canvas, 0, 0, this.canvas.width, this.canvas.height, 0, 0, this.size[0], this.size[1]);
+ };
+ l.prototype.onPropertyChanged = function(a, d) {
+ this.properties[a] = d;
+ "scale" == a ? (this.properties[a] = parseFloat(d), 0 == this.properties[a] && (this.trace("Error in scale"), this.properties[a] = 1.0)) : this.properties[a] = parseInt(d);
+ this.createCanvas();
+ return !0;
+ };
+ LiteGraph.registerNodeType("graphics/cropImage", l);
+ k.title = "Video";
+ k.desc = "Video playback";
+ k.widgets = [{name:"play", text:"PLAY", type:"minibutton"}, {name:"stop", text:"STOP", type:"minibutton"}, {name:"demo", text:"Demo video", type:"button"}, {name:"mute", text:"Mute video", type:"button"}];
+ k.prototype.onExecute = function() {
+ if (this.properties.url && (this.properties.url != this._video_url && this.loadVideo(this.properties.url), this._video && 0 != this._video.width)) {
+ var a = this.getInputData(0);
+ a && 0 <= a && 1.0 >= a && (this._video.currentTime = a * this._video.duration, this._video.pause());
+ this._video.dirty = !0;
+ this.setOutputData(0, this._video);
+ this.setOutputData(1, this._video.currentTime);
+ this.setOutputData(2, this._video.duration);
+ this.setDirtyCanvas(!0);
+ }
+ };
+ k.prototype.onStart = function() {
+ this.play();
+ };
+ k.prototype.onStop = function() {
+ this.stop();
+ };
+ k.prototype.loadVideo = function(a) {
+ this._video_url = a;
+ this._video = document.createElement("video");
+ this._video.src = a;
+ this._video.type = "type=video/mp4";
+ this._video.muted = !0;
+ this._video.autoplay = !0;
+ var b = this;
+ this._video.addEventListener("loadedmetadata", function(a) {
+ b.trace("Duration: " + this.duration + " seconds");
+ b.trace("Size: " + this.videoWidth + "," + this.videoHeight);
+ b.setDirtyCanvas(!0);
+ this.width = this.videoWidth;
+ this.height = this.videoHeight;
+ });
+ this._video.addEventListener("progress", function(a) {
+ });
+ this._video.addEventListener("error", function(a) {
+ console.log("Error loading video: " + this.src);
+ b.trace("Error loading video: " + this.src);
+ if (this.error) {
+ switch(this.error.code) {
+ case this.error.MEDIA_ERR_ABORTED:
+ b.trace("You stopped the video.");
+ break;
+ case this.error.MEDIA_ERR_NETWORK:
+ b.trace("Network error - please try again later.");
+ break;
+ case this.error.MEDIA_ERR_DECODE:
+ b.trace("Video is broken..");
+ break;
+ case this.error.MEDIA_ERR_SRC_NOT_SUPPORTED:
+ b.trace("Sorry, your browser can't play this video.");
+ }
+ }
+ });
+ this._video.addEventListener("ended", function(a) {
+ b.trace("Ended.");
+ this.play();
+ });
+ };
+ k.prototype.onPropertyChanged = function(a, d) {
+ this.properties[a] = d;
+ "url" == a && "" != d && this.loadVideo(d);
+ return !0;
+ };
+ k.prototype.play = function() {
+ this._video && this._video.play();
+ };
+ k.prototype.playPause = function() {
+ this._video && (this._video.paused ? this.play() : this.pause());
+ };
+ k.prototype.stop = function() {
+ this._video && (this._video.pause(), this._video.currentTime = 0);
+ };
+ k.prototype.pause = function() {
+ this._video && (this.trace("Video paused"), this._video.pause());
+ };
+ k.prototype.onWidget = function(a, d) {
+ };
+ LiteGraph.registerNodeType("graphics/video", k);
+ a.title = "Webcam";
+ a.desc = "Webcam image";
+ a.prototype.openStream = function() {
+ navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia;
+ window.URL = window.URL || window.webkitURL;
+ if (navigator.getUserMedia) {
+ this._waiting_confirmation = !0;
+ navigator.getUserMedia({video:!0}, this.streamReady.bind(this), function(b) {
+ console.log("Webcam rejected", b);
+ a._webcam_stream = !1;
+ a.box_color = "red";
+ });
+ var a = this;
+ }
+ };
+ a.prototype.onRemoved = function() {
+ this._webcam_stream && (this._webcam_stream.stop(), this._video = this._webcam_stream = null);
+ };
+ a.prototype.streamReady = function(a) {
+ this._webcam_stream = a;
+ var b = this._video;
+ b || (b = document.createElement("video"), b.autoplay = !0, b.src = window.URL.createObjectURL(a), this._video = b, b.onloadedmetadata = function(a) {
+ console.log(a);
+ });
+ };
+ a.prototype.onExecute = function() {
+ null != this._webcam_stream || this._waiting_confirmation || this.openStream();
+ this._video && this._video.videoWidth && (this._video.width = this._video.videoWidth, this._video.height = this._video.videoHeight, this.setOutputData(0, this._video));
+ };
+ a.prototype.getExtraMenuOptions = function(a) {
+ var b = this;
+ return [{content:b.properties.show ? "Hide Frame" : "Show Frame", callback:function() {
+ b.properties.show = !b.properties.show;
+ }}];
+ };
+ a.prototype.onDrawBackground = function(a) {
+ this.flags.collapsed || 20 >= this.size[1] || !this.properties.show || !this._video || (a.save(), a.drawImage(this._video, 0, 0, this.size[0], this.size[1]), a.restore());
+ };
+ LiteGraph.registerNodeType("graphics/webcam", a);
+})();
+var LGraphTexture;
+if ("undefined" != typeof LiteGraph) {
+ var LGraphCubemap = function() {
+ this.addOutput("Cubemap", "Cubemap");
+ this.properties = {name:""};
+ this.size = [LGraphTexture.image_preview_size, LGraphTexture.image_preview_size];
+ }, LGraphTextureMatte = function() {
+ this.addInput("in", "Texture");
+ this.addOutput("out", "Texture");
+ this.properties = {key_color:vec3.fromValues(0., 1., 0.), threshold:0.8, slope:0.2, precision:LGraphTexture.DEFAULT};
+ LGraphTextureMatte._shader || (LGraphTextureMatte._shader = new GL.Shader(GL.Shader.SCREEN_VERTEX_SHADER, LGraphTextureMatte.pixel_shader));
+ }, LGraphTextureWebcam = function() {
+ this.addOutput("Webcam", "Texture");
+ this.properties = {texture_name:""};
+ }, LGraphTextureKuwaharaFilter = function() {
+ this.addInput("Texture", "Texture");
+ this.addOutput("Filtered", "Texture");
+ this.properties = {intensity:1, radius:5};
+ }, LGraphTextureBlur = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("Iterations", "number");
+ this.addInput("Intensity", "number");
+ this.addOutput("Blurred", "Texture");
+ this.properties = {intensity:1, iterations:1, preserve_aspect:!1, scale:[1, 1]};
+ }, LGraphTextureDepthRange = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("Distance", "number");
+ this.addInput("Range", "number");
+ this.addOutput("Texture", "Texture");
+ this.properties = {distance:100, range:50, high_precision:!1};
+ }, LGraphTextureEdges = function() {
+ this.addInput("Tex.", "Texture");
+ this.addOutput("Edges", "Texture");
+ this.properties = {invert:!0, factor:1, precision:LGraphTexture.DEFAULT};
+ LGraphTextureEdges._shader || (LGraphTextureEdges._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureEdges.pixel_shader));
+ }, LGraphTextureMix = function() {
+ this.addInput("A", "Texture");
+ this.addInput("B", "Texture");
+ this.addInput("Mixer", "Texture");
+ this.addOutput("Texture", "Texture");
+ this.properties = {precision:LGraphTexture.DEFAULT};
+ LGraphTextureMix._shader || (LGraphTextureMix._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureMix.pixel_shader));
+ }, LGraphTextureGradient = function() {
+ this.addInput("A", "color");
+ this.addInput("B", "color");
+ this.addOutput("Texture", "Texture");
+ this.properties = {angle:0, scale:1, A:[0, 0, 0], B:[1, 1, 1], texture_size:32};
+ LGraphTextureGradient._shader || (LGraphTextureGradient._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureGradient.pixel_shader));
+ this._uniforms = {u_angle:0, u_colorA:vec3.create(), u_colorB:vec3.create()};
+ }, LGraphChannelsTexture = function() {
+ this.addInput("R", "Texture");
+ this.addInput("G", "Texture");
+ this.addInput("B", "Texture");
+ this.addInput("A", "Texture");
+ this.addOutput("Texture", "Texture");
+ this.properties = {};
+ LGraphChannelsTexture._shader || (LGraphChannelsTexture._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphChannelsTexture.pixel_shader));
+ }, LGraphTextureChannels = function() {
+ this.addInput("Texture", "Texture");
+ this.addOutput("R", "Texture");
+ this.addOutput("G", "Texture");
+ this.addOutput("B", "Texture");
+ this.addOutput("A", "Texture");
+ this.properties = {};
+ LGraphTextureChannels._shader || (LGraphTextureChannels._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureChannels.pixel_shader));
+ }, LGraphTextureLUT = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("LUT", "Texture");
+ this.addInput("Intensity", "number");
+ this.addOutput("", "Texture");
+ this.properties = {intensity:1, precision:LGraphTexture.DEFAULT, texture:null};
+ LGraphTextureLUT._shader || (LGraphTextureLUT._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureLUT.pixel_shader));
+ }, LGraphImageToTexture = function() {
+ this.addInput("Image", "image");
+ this.addOutput("", "Texture");
+ this.properties = {};
+ }, LGraphTextureAverage = function() {
+ this.addInput("Texture", "Texture");
+ this.addOutput("", "Texture");
+ this.properties = {mipmap_offset:0, low_precision:!1};
+ this._uniforms = {u_texture:0, u_mipmap_offset:this.properties.mipmap_offset};
+ }, LGraphTextureDownsample = function() {
+ this.addInput("Texture", "Texture");
+ this.addOutput("", "Texture");
+ this.properties = {iterations:1, generate_mipmaps:!1, precision:LGraphTexture.DEFAULT};
+ }, LGraphTextureCopy = function() {
+ this.addInput("Texture", "Texture");
+ this.addOutput("", "Texture");
+ this.properties = {size:0, generate_mipmaps:!1, precision:LGraphTexture.DEFAULT};
+ }, LGraphTextureToViewport = function() {
+ this.addInput("Texture", "Texture");
+ this.properties = {additive:!1, antialiasing:!1, filter:!0, disable_alpha:!1, gamma:1.0};
+ this.size[0] = 130;
+ }, LGraphTextureWarp = function() {
+ this.addInput("in", "Texture");
+ this.addInput("warp", "Texture");
+ this.addInput("factor", "number");
+ this.addOutput("out", "Texture");
+ this.properties = {factor:0.01, precision:LGraphTexture.DEFAULT};
+ }, LGraphTextureScaleOffset = function() {
+ this.addInput("in", "Texture");
+ this.addInput("scale", "vec2");
+ this.addInput("offset", "vec2");
+ this.addOutput("out", "Texture");
+ this.properties = {offset:vec2.fromValues(0, 0), scale:vec2.fromValues(1, 1), precision:LGraphTexture.DEFAULT};
+ }, LGraphTextureShader = function() {
+ this.addOutput("Texture", "Texture");
+ this.properties = {code:"", width:512, height:512};
+ this.properties.code = "\nvoid main() {\n vec2 uv = v_coord;\n vec3 color = vec3(0.0);\n//your code here\n\ngl_FragColor = vec4(color, 1.0);\n}\n";
+ }, LGraphTextureOperation = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("TextureB", "Texture");
+ this.addInput("value", "number");
+ this.addOutput("Texture", "Texture");
+ this.help = "pixelcode must be vec3
\r\n\t\t\tuvcode must be vec2, is optional
\r\n\t\t\tuv: tex. coords
color: texture
colorB: textureB
time: scene time
value: input value
";
+ this.properties = {value:1, uvcode:"", pixelcode:"color + colorB * value", precision:LGraphTexture.DEFAULT};
+ }, LGraphTextureSave = function() {
+ this.addInput("Texture", "Texture");
+ this.addOutput("", "Texture");
+ this.properties = {name:""};
+ }, LGraphTexturePreview = function() {
+ this.addInput("Texture", "Texture");
+ this.properties = {flipY:!1};
+ this.size = [LGraphTexture.image_preview_size, LGraphTexture.image_preview_size];
+ };
+ LGraphTexture = function() {
+ this.addOutput("Texture", "Texture");
+ this.properties = {name:"", filter:!0};
+ this.size = [LGraphTexture.image_preview_size, LGraphTexture.image_preview_size];
+ };
+ LGraphTexture.title = "Texture";
+ LGraphTexture.desc = "Texture";
+ LGraphTexture.widgets_info = {name:{widget:"texture"}, filter:{widget:"checkbox"}};
+ LGraphTexture.loadTextureCallback = null;
+ LGraphTexture.image_preview_size = 256;
+ LGraphTexture.PASS_THROUGH = 1;
+ LGraphTexture.COPY = 2;
+ LGraphTexture.LOW = 3;
+ LGraphTexture.HIGH = 4;
+ LGraphTexture.REUSE = 5;
+ LGraphTexture.DEFAULT = 2;
+ LGraphTexture.MODE_VALUES = {"pass through":LGraphTexture.PASS_THROUGH, copy:LGraphTexture.COPY, low:LGraphTexture.LOW, high:LGraphTexture.HIGH, reuse:LGraphTexture.REUSE, "default":LGraphTexture.DEFAULT};
+ LGraphTexture.getTexturesContainer = function() {
+ return gl.textures;
+ };
+ LGraphTexture.loadTexture = function(c, e) {
+ e = e || {};
+ var f = c;
+ "http://" == f.substr(0, 7) && LiteGraph.proxy && (f = LiteGraph.proxy + f.substr(7));
+ return LGraphTexture.getTexturesContainer()[c] = GL.Texture.fromURL(f, e);
+ };
+ LGraphTexture.getTexture = function(c) {
+ var e = this.getTexturesContainer();
+ if (!e) {
+ throw "Cannot load texture, container of textures not found";
+ }
+ e = e[c];
+ return !e && c && ":" != c[0] ? this.loadTexture(c) : e;
+ };
+ LGraphTexture.getTargetTexture = function(c, e, f) {
+ if (!c) {
+ throw "LGraphTexture.getTargetTexture expects a reference texture";
+ }
+ switch(f) {
+ case LGraphTexture.LOW:
+ f = gl.UNSIGNED_BYTE;
+ break;
+ case LGraphTexture.HIGH:
+ f = gl.HIGH_PRECISION_FORMAT;
+ break;
+ case LGraphTexture.REUSE:
+ return c;
+ default:
+ f = c ? c.type : gl.UNSIGNED_BYTE;
+ }
+ e && e.width == c.width && e.height == c.height && e.type == f || (e = new GL.Texture(c.width, c.height, {type:f, format:gl.RGBA, filter:gl.LINEAR}));
+ return e;
+ };
+ LGraphTexture.getNoiseTexture = function() {
+ if (this._noise_texture) {
+ return this._noise_texture;
+ }
+ for (var c = new Uint8Array(1048576), e = 0; 1048576 > e; ++e) {
+ c[e] = 255 * Math.random();
+ }
+ return this._noise_texture = c = GL.Texture.fromMemory(512, 512, c, {format:gl.RGBA, wrap:gl.REPEAT, filter:gl.NEAREST});
+ };
+ LGraphTexture.prototype.onDropFile = function(c, e, f) {
+ c ? ("string" == typeof c ? c = GL.Texture.fromURL(c) : -1 != e.toLowerCase().indexOf(".dds") ? c = GL.Texture.fromDDSInMemory(c) : (c = new Blob([f]), c = URL.createObjectURL(c), c = GL.Texture.fromURL(c)), this._drop_texture = c, this.properties.name = e) : (this._drop_texture = null, this.properties.name = "");
+ };
+ LGraphTexture.prototype.getExtraMenuOptions = function(c) {
+ var e = this;
+ if (this._drop_texture) {
+ return [{content:"Clear", callback:function() {
+ e._drop_texture = null;
+ e.properties.name = "";
+ }}];
+ }
+ };
+ LGraphTexture.prototype.onExecute = function() {
+ var c = null;
+ this.isOutputConnected(1) && (c = this.getInputData(0));
+ !c && this._drop_texture && (c = this._drop_texture);
+ !c && this.properties.name && (c = LGraphTexture.getTexture(this.properties.name));
+ if (c) {
+ this._last_tex = c;
+ !1 === this.properties.filter ? c.setParameter(gl.TEXTURE_MAG_FILTER, gl.NEAREST) : c.setParameter(gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+ this.setOutputData(0, c);
+ for (var e = 1; e < this.outputs.length; e++) {
+ var f = this.outputs[e];
+ if (f) {
+ var g = null;
+ "width" == f.name ? g = c.width : "height" == f.name ? g = c.height : "aspect" == f.name && (g = c.width / c.height);
+ this.setOutputData(e, g);
+ }
+ }
+ }
+ };
+ LGraphTexture.prototype.onResourceRenamed = function(c, e) {
+ this.properties.name == c && (this.properties.name = e);
+ };
+ LGraphTexture.prototype.onDrawBackground = function(c) {
+ if (!(this.flags.collapsed || 20 >= this.size[1])) {
+ if (this._drop_texture && c.webgl) {
+ c.drawImage(this._drop_texture, 0, 0, this.size[0], this.size[1]);
+ } else {
+ if (this._last_preview_tex != this._last_tex) {
+ if (c.webgl) {
+ this._canvas = this._last_tex;
+ } else {
+ var e = LGraphTexture.generateLowResTexturePreview(this._last_tex);
+ if (!e) {
+ return;
+ }
+ this._last_preview_tex = this._last_tex;
+ this._canvas = cloneCanvas(e);
+ }
+ }
+ this._canvas && (c.save(), c.webgl || (c.translate(0, this.size[1]), c.scale(1, -1)), c.drawImage(this._canvas, 0, 0, this.size[0], this.size[1]), c.restore());
+ }
+ }
+ };
+ LGraphTexture.generateLowResTexturePreview = function(c) {
+ if (!c) {
+ return null;
+ }
+ var e = LGraphTexture.image_preview_size, f = c;
+ if (c.format == gl.DEPTH_COMPONENT) {
+ return null;
+ }
+ if (c.width > e || c.height > e) {
+ f = this._preview_temp_tex, this._preview_temp_tex || (this._preview_temp_tex = f = new GL.Texture(e, e, {minFilter:gl.NEAREST})), c.copyTo(f);
+ }
+ c = this._preview_canvas;
+ c || (this._preview_canvas = c = createCanvas(e, e));
+ f && f.toCanvas(c);
+ return c;
+ };
+ LGraphTexture.prototype.getResources = function(c) {
+ c[this.properties.name] = GL.Texture;
+ return c;
+ };
+ LGraphTexture.prototype.onGetInputs = function() {
+ return [["in", "Texture"]];
+ };
+ LGraphTexture.prototype.onGetOutputs = function() {
+ return [["width", "number"], ["height", "number"], ["aspect", "number"]];
+ };
+ LiteGraph.registerNodeType("texture/texture", LGraphTexture);
+ LGraphTexturePreview.title = "Preview";
+ LGraphTexturePreview.desc = "Show a texture in the graph canvas";
+ LGraphTexturePreview.allow_preview = !1;
+ LGraphTexturePreview.prototype.onDrawBackground = function(c) {
+ if (!this.flags.collapsed && (c.webgl || LGraphTexturePreview.allow_preview)) {
+ var e = this.getInputData(0);
+ e && (e = !e.handle && c.webgl ? e : LGraphTexture.generateLowResTexturePreview(e), c.save(), this.properties.flipY && (c.translate(0, this.size[1]), c.scale(1, -1)), c.drawImage(e, 0, 0, this.size[0], this.size[1]), c.restore());
+ }
+ };
+ LiteGraph.registerNodeType("texture/preview", LGraphTexturePreview);
+ LGraphTextureSave.title = "Save";
+ LGraphTextureSave.desc = "Save a texture in the repository";
+ LGraphTextureSave.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ c && (this.properties.name && (LGraphTexture.storeTexture ? LGraphTexture.storeTexture(this.properties.name, c) : LGraphTexture.getTexturesContainer()[this.properties.name] = c), this.setOutputData(0, c));
+ };
+ LiteGraph.registerNodeType("texture/save", LGraphTextureSave);
+ LGraphTextureOperation.widgets_info = {uvcode:{widget:"textarea", height:100}, pixelcode:{widget:"textarea", height:100}, precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureOperation.title = "Operation";
+ LGraphTextureOperation.desc = "Texture shader operation";
+ LGraphTextureOperation.prototype.getExtraMenuOptions = function(c) {
+ var e = this;
+ return [{content:e.properties.show ? "Hide Texture" : "Show Texture", callback:function() {
+ e.properties.show = !e.properties.show;
+ }}];
+ };
+ LGraphTextureOperation.prototype.onDrawBackground = function(c) {
+ this.flags.collapsed || 20 >= this.size[1] || !this.properties.show || !this._tex || this._tex.gl != c || (c.save(), c.drawImage(this._tex, 0, 0, this.size[0], this.size[1]), c.restore());
+ };
+ LGraphTextureOperation.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (this.isOutputConnected(0)) {
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ var e = this.getInputData(1);
+ if (this.properties.uvcode || this.properties.pixelcode) {
+ var f = 512, g = 512;
+ c ? (f = c.width, g = c.height) : e && (f = e.width, g = e.height);
+ this._tex = c || this._tex ? LGraphTexture.getTargetTexture(c || this._tex, this._tex, this.properties.precision) : new GL.Texture(f, g, {type:this.precision === LGraphTexture.LOW ? gl.UNSIGNED_BYTE : gl.HIGH_PRECISION_FORMAT, format:gl.RGBA, filter:gl.LINEAR});
+ var l = "";
+ this.properties.uvcode && (l = "uv = " + this.properties.uvcode, -1 != this.properties.uvcode.indexOf(";") && (l = this.properties.uvcode));
+ var k = "";
+ this.properties.pixelcode && (k = "result = " + this.properties.pixelcode, -1 != this.properties.pixelcode.indexOf(";") && (k = this.properties.pixelcode));
+ var a = this._shader;
+ if (!a || this._shader_code != l + "|" + k) {
+ try {
+ this._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureOperation.pixel_shader, {UV_CODE:l, PIXEL_CODE:k}), this.boxcolor = "#00FF00";
+ } catch (h) {
+ console.log("Error compiling shader: ", h);
+ this.boxcolor = "#FF0000";
+ return;
+ }
+ this.boxcolor = "#FF0000";
+ this._shader_code = l + "|" + k;
+ a = this._shader;
+ }
+ if (a) {
+ this.boxcolor = "green";
+ var b = this.getInputData(2);
+ null != b ? this.properties.value = b : b = parseFloat(this.properties.value);
+ var d = this.graph.getTime();
+ this._tex.drawTo(function() {
+ gl.disable(gl.DEPTH_TEST);
+ gl.disable(gl.CULL_FACE);
+ gl.disable(gl.BLEND);
+ c && c.bind(0);
+ e && e.bind(1);
+ var h = Mesh.getScreenQuad();
+ a.uniforms({u_texture:0, u_textureB:1, value:b, texSize:[f, g], time:d}).draw(h);
+ });
+ this.setOutputData(0, this._tex);
+ } else {
+ this.boxcolor = "red";
+ }
+ }
+ }
+ }
+ };
+ LGraphTextureOperation.pixel_shader = "precision highp float;\n\r\n\t\t\t\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_textureB;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform vec2 texSize;\n\r\n\t\t\tuniform float time;\n\r\n\t\t\tuniform float value;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec2 uv = v_coord;\n\r\n\t\t\t\tUV_CODE;\n\r\n\t\t\t\tvec4 color4 = texture2D(u_texture, uv);\n\r\n\t\t\t\tvec3 color = color4.rgb;\n\r\n\t\t\t\tvec4 color4B = texture2D(u_textureB, uv);\n\r\n\t\t\t\tvec3 colorB = color4B.rgb;\n\r\n\t\t\t\tvec3 result = color;\n\r\n\t\t\t\tfloat alpha = 1.0;\n\r\n\t\t\t\tPIXEL_CODE;\n\r\n\t\t\t\tgl_FragColor = vec4(result, alpha);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/operation", LGraphTextureOperation);
+ LGraphTextureShader.title = "Shader";
+ LGraphTextureShader.desc = "Texture shader";
+ LGraphTextureShader.widgets_info = {code:{type:"code"}, precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureShader.prototype.onPropertyChanged = function(c, e) {
+ if ("code" == c && (c = this.getShader())) {
+ e = c.uniformInfo;
+ if (this.inputs) {
+ for (var f = {}, g = 0; g < this.inputs.length; ++g) {
+ var l = this.getInputInfo(g);
+ l && (e[l.name] && !f[l.name] ? f[l.name] = !0 : (this.removeInput(g), g--));
+ }
+ }
+ for (g in e) {
+ if (l = c.uniformInfo[g], null !== l.loc && "time" != g) {
+ if (this._shader.samplers[g]) {
+ e = "texture";
+ } else {
+ switch(l.size) {
+ case 1:
+ e = "number";
+ break;
+ case 2:
+ e = "vec2";
+ break;
+ case 3:
+ e = "vec3";
+ break;
+ case 4:
+ e = "vec4";
+ break;
+ case 9:
+ e = "mat3";
+ break;
+ case 16:
+ e = "mat4";
+ break;
+ default:
+ continue;
+ }
+ }
+ f = this.findInputSlot(g);
+ if (-1 != f && (l = this.getInputInfo(f))) {
+ if (l.type == e) {
+ continue;
+ }
+ this.removeInput(f, e);
+ }
+ this.addInput(g, e);
+ }
+ }
+ }
+ };
+ LGraphTextureShader.prototype.getShader = function() {
+ if (this._shader && this._shader_code == this.properties.code) {
+ return this._shader;
+ }
+ this._shader_code = this.properties.code;
+ this._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureShader.pixel_shader + this.properties.code), this.boxcolor = "green";
+ return this._shader;
+ };
+ LGraphTextureShader.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var c = this.getShader();
+ if (c) {
+ for (var e = 0; e < this.inputs.length; ++e) {
+ var f = this.getInputInfo(e), g = this.getInputData(e);
+ null != g && (g.constructor === GL.Texture && (g.bind(slot), g = slot, slot++), c.setUniform(f.name, g));
+ }
+ this._tex && this._tex.width == this.properties.width && this._tex.height == this.properties.height || (this._tex = new GL.Texture(this.properties.width, this.properties.height, {format:gl.RGBA, filter:gl.LINEAR}));
+ var l = this._tex, k = this.graph.getTime();
+ l.drawTo(function() {
+ c.uniforms({texSize:[l.width, l.height], time:k}).draw(Mesh.getScreenQuad());
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ };
+ LGraphTextureShader.pixel_shader = "precision highp float;\n\r\n\t\t\t\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform float time;\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/shader", LGraphTextureShader);
+ LGraphTextureScaleOffset.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureScaleOffset.title = "Scale/Offset";
+ LGraphTextureScaleOffset.desc = "Applies an scaling and offseting";
+ LGraphTextureScaleOffset.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (this.isOutputConnected(0) && c) {
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ var e = c.width, f = c.height, g = this.precision === LGraphTexture.LOW ? gl.UNSIGNED_BYTE : gl.HIGH_PRECISION_FORMAT;
+ this.precision === LGraphTexture.DEFAULT && (g = c.type);
+ this._tex && this._tex.width == e && this._tex.height == f && this._tex.type == g || (this._tex = new GL.Texture(e, f, {type:g, format:gl.RGBA, filter:gl.LINEAR}));
+ var l = this._shader;
+ l || (l = new GL.Shader(GL.Shader.SCREEN_VERTEX_SHADER, LGraphTextureScaleOffset.pixel_shader));
+ var k = this.getInputData(1);
+ k ? (this.properties.scale[0] = k[0], this.properties.scale[1] = k[1]) : k = this.properties.scale;
+ var a = this.getInputData(2);
+ a ? (this.properties.offset[0] = a[0], this.properties.offset[1] = a[1]) : a = this.properties.offset;
+ this._tex.drawTo(function() {
+ gl.disable(gl.DEPTH_TEST);
+ gl.disable(gl.CULL_FACE);
+ gl.disable(gl.BLEND);
+ c.bind(0);
+ var b = Mesh.getScreenQuad();
+ l.uniforms({u_texture:0, u_scale:k, u_offset:a}).draw(b);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ };
+ LGraphTextureScaleOffset.pixel_shader = "precision highp float;\n\r\n\t\t\t\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_textureB;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform vec2 u_scale;\n\r\n\t\t\tuniform vec2 u_offset;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec2 uv = v_coord;\n\r\n\t\t\t\tuv = uv / u_scale - u_offset;\n\r\n\t\t\t\tgl_FragColor = texture2D(u_texture, uv);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/scaleOffset", LGraphTextureScaleOffset);
+ LGraphTextureWarp.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureWarp.title = "Warp";
+ LGraphTextureWarp.desc = "Texture warp operation";
+ LGraphTextureWarp.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (this.isOutputConnected(0)) {
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ var e = this.getInputData(1), f = 512, g = 512;
+ c ? (f = c.width, g = c.height) : e && (f = e.width, g = e.height);
+ this._tex = c || this._tex ? LGraphTexture.getTargetTexture(c || this._tex, this._tex, this.properties.precision) : new GL.Texture(f, g, {type:this.precision === LGraphTexture.LOW ? gl.UNSIGNED_BYTE : gl.HIGH_PRECISION_FORMAT, format:gl.RGBA, filter:gl.LINEAR});
+ var l = this._shader;
+ l || (l = new GL.Shader(GL.Shader.SCREEN_VERTEX_SHADER, LGraphTextureWarp.pixel_shader));
+ var k = this.getInputData(2);
+ null != k ? this.properties.factor = k : k = parseFloat(this.properties.factor);
+ this._tex.drawTo(function() {
+ gl.disable(gl.DEPTH_TEST);
+ gl.disable(gl.CULL_FACE);
+ gl.disable(gl.BLEND);
+ c && c.bind(0);
+ e && e.bind(1);
+ var a = Mesh.getScreenQuad();
+ l.uniforms({u_texture:0, u_textureB:1, u_factor:k}).draw(a);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ };
+ LGraphTextureWarp.pixel_shader = "precision highp float;\n\r\n\t\t\t\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_textureB;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform float u_factor;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec2 uv = v_coord;\n\r\n\t\t\t\tuv += ( texture2D(u_textureB, uv).rg - vec2(0.5)) * u_factor;\n\r\n\t\t\t\tgl_FragColor = texture2D(u_texture, uv);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/warp", LGraphTextureWarp);
+ LGraphTextureToViewport.title = "to Viewport";
+ LGraphTextureToViewport.desc = "Texture to viewport";
+ LGraphTextureToViewport.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (c) {
+ this.properties.disable_alpha ? gl.disable(gl.BLEND) : (gl.enable(gl.BLEND), this.properties.additive ? gl.blendFunc(gl.SRC_ALPHA, gl.ONE) : gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA));
+ gl.disable(gl.DEPTH_TEST);
+ var e = this.properties.gamma || 1.0;
+ this.isInputConnected(1) && (e = this.getInputData(1));
+ c.setParameter(gl.TEXTURE_MAG_FILTER, this.properties.filter ? gl.LINEAR : gl.NEAREST);
+ if (this.properties.antialiasing) {
+ LGraphTextureToViewport._shader || (LGraphTextureToViewport._shader = new GL.Shader(GL.Shader.SCREEN_VERTEX_SHADER, LGraphTextureToViewport.aa_pixel_shader));
+ gl.getViewport();
+ var f = Mesh.getScreenQuad();
+ c.bind(0);
+ LGraphTextureToViewport._shader.uniforms({u_texture:0, uViewportSize:[c.width, c.height], u_igamma:1 / e, inverseVP:[1 / c.width, 1 / c.height]}).draw(f);
+ } else {
+ 1.0 != e ? (LGraphTextureToViewport._gamma_shader || (LGraphTextureToViewport._gamma_shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureToViewport.gamma_pixel_shader)), c.toViewport(LGraphTextureToViewport._gamma_shader, {u_texture:0, u_igamma:1 / e})) : c.toViewport();
+ }
+ }
+ };
+ LGraphTextureToViewport.prototype.onGetInputs = function() {
+ return [["gamma", "number"]];
+ };
+ LGraphTextureToViewport.aa_pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 uViewportSize;\n\r\n\t\t\tuniform vec2 inverseVP;\n\r\n\t\t\tuniform float u_igamma;\n\r\n\t\t\t#define FXAA_REDUCE_MIN (1.0/ 128.0)\n\r\n\t\t\t#define FXAA_REDUCE_MUL (1.0 / 8.0)\n\r\n\t\t\t#define FXAA_SPAN_MAX 8.0\n\r\n\t\t\t\n\r\n\t\t\t/* from mitsuhiko/webgl-meincraft based on the code on geeks3d.com */\n\r\n\t\t\tvec4 applyFXAA(sampler2D tex, vec2 fragCoord)\n\r\n\t\t\t{\n\r\n\t\t\t\tvec4 color = vec4(0.0);\n\r\n\t\t\t\t/*vec2 inverseVP = vec2(1.0 / uViewportSize.x, 1.0 / uViewportSize.y);*/\n\r\n\t\t\t\tvec3 rgbNW = texture2D(tex, (fragCoord + vec2(-1.0, -1.0)) * inverseVP).xyz;\n\r\n\t\t\t\tvec3 rgbNE = texture2D(tex, (fragCoord + vec2(1.0, -1.0)) * inverseVP).xyz;\n\r\n\t\t\t\tvec3 rgbSW = texture2D(tex, (fragCoord + vec2(-1.0, 1.0)) * inverseVP).xyz;\n\r\n\t\t\t\tvec3 rgbSE = texture2D(tex, (fragCoord + vec2(1.0, 1.0)) * inverseVP).xyz;\n\r\n\t\t\t\tvec3 rgbM = texture2D(tex, fragCoord * inverseVP).xyz;\n\r\n\t\t\t\tvec3 luma = vec3(0.299, 0.587, 0.114);\n\r\n\t\t\t\tfloat lumaNW = dot(rgbNW, luma);\n\r\n\t\t\t\tfloat lumaNE = dot(rgbNE, luma);\n\r\n\t\t\t\tfloat lumaSW = dot(rgbSW, luma);\n\r\n\t\t\t\tfloat lumaSE = dot(rgbSE, luma);\n\r\n\t\t\t\tfloat lumaM = dot(rgbM, luma);\n\r\n\t\t\t\tfloat lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));\n\r\n\t\t\t\tfloat lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));\n\r\n\t\t\t\t\n\r\n\t\t\t\tvec2 dir;\n\r\n\t\t\t\tdir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));\n\r\n\t\t\t\tdir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));\n\r\n\t\t\t\t\n\r\n\t\t\t\tfloat dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);\n\r\n\t\t\t\t\n\r\n\t\t\t\tfloat rcpDirMin = 1.0 / (min(abs(dir.x), abs(dir.y)) + dirReduce);\n\r\n\t\t\t\tdir = min(vec2(FXAA_SPAN_MAX, FXAA_SPAN_MAX), max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), dir * rcpDirMin)) * inverseVP;\n\r\n\t\t\t\t\n\r\n\t\t\t\tvec3 rgbA = 0.5 * (texture2D(tex, fragCoord * inverseVP + dir * (1.0 / 3.0 - 0.5)).xyz + \n\r\n\t\t\t\t\ttexture2D(tex, fragCoord * inverseVP + dir * (2.0 / 3.0 - 0.5)).xyz);\n\r\n\t\t\t\tvec3 rgbB = rgbA * 0.5 + 0.25 * (texture2D(tex, fragCoord * inverseVP + dir * -0.5).xyz + \n\r\n\t\t\t\t\ttexture2D(tex, fragCoord * inverseVP + dir * 0.5).xyz);\n\r\n\t\t\t\t\n\r\n\t\t\t\t//return vec4(rgbA,1.0);\n\r\n\t\t\t\tfloat lumaB = dot(rgbB, luma);\n\r\n\t\t\t\tif ((lumaB < lumaMin) || (lumaB > lumaMax))\n\r\n\t\t\t\t\tcolor = vec4(rgbA, 1.0);\n\r\n\t\t\t\telse\n\r\n\t\t\t\t\tcolor = vec4(rgbB, 1.0);\n\r\n\t\t\t\tif(u_igamma != 1.0)\n\r\n\t\t\t\t\tcolor.xyz = pow( color.xyz, vec3(u_igamma) );\n\r\n\t\t\t\treturn color;\n\r\n\t\t\t}\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t gl_FragColor = applyFXAA( u_texture, v_coord * uViewportSize) ;\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LGraphTextureToViewport.gamma_pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform float u_igamma;\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D( u_texture, v_coord);\n\r\n\t\t\t\tcolor.xyz = pow(color.xyz, vec3(u_igamma) );\n\r\n\t\t\t gl_FragColor = color;\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/toviewport", LGraphTextureToViewport);
+ LGraphTextureCopy.title = "Copy";
+ LGraphTextureCopy.desc = "Copy Texture";
+ LGraphTextureCopy.widgets_info = {size:{widget:"combo", values:[0, 32, 64, 128, 256, 512, 1024, 2048]}, precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureCopy.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if ((c || this._temp_texture) && this.isOutputConnected(0)) {
+ if (c) {
+ var e = c.width, f = c.height;
+ 0 != this.properties.size && (f = e = this.properties.size);
+ var g = this._temp_texture, l = c.type;
+ this.properties.precision === LGraphTexture.LOW ? l = gl.UNSIGNED_BYTE : this.properties.precision === LGraphTexture.HIGH && (l = gl.HIGH_PRECISION_FORMAT);
+ g && g.width == e && g.height == f && g.type == l || (g = gl.LINEAR, this.properties.generate_mipmaps && isPowerOfTwo(e) && isPowerOfTwo(f) && (g = gl.LINEAR_MIPMAP_LINEAR), this._temp_texture = new GL.Texture(e, f, {type:l, format:gl.RGBA, minFilter:g, magFilter:gl.LINEAR}));
+ c.copyTo(this._temp_texture);
+ this.properties.generate_mipmaps && (this._temp_texture.bind(0), gl.generateMipmap(this._temp_texture.texture_type), this._temp_texture.unbind(0));
+ }
+ this.setOutputData(0, this._temp_texture);
+ }
+ };
+ LiteGraph.registerNodeType("texture/copy", LGraphTextureCopy);
+ LGraphTextureDownsample.title = "Downsample";
+ LGraphTextureDownsample.desc = "Downsample Texture";
+ LGraphTextureDownsample.widgets_info = {iterations:{type:"number", step:1, precision:0, min:1}, precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureDownsample.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if ((c || this._temp_texture) && this.isOutputConnected(0) && c && c.texture_type === GL.TEXTURE_2D) {
+ var e = LGraphTextureDownsample._shader;
+ e || (LGraphTextureDownsample._shader = e = new GL.Shader(GL.Shader.SCREEN_VERTEX_SHADER, LGraphTextureDownsample.pixel_shader));
+ var f = c.width | 0, g = c.height | 0, l = c.type;
+ this.properties.precision === LGraphTexture.LOW ? l = gl.UNSIGNED_BYTE : this.properties.precision === LGraphTexture.HIGH && (l = gl.HIGH_PRECISION_FORMAT);
+ var k = this.properties.iterations || 1, a = c, b = [];
+ l = {type:l, format:c.format};
+ var d = vec2.create(), h = {u_offset:d};
+ this._texture && GL.Texture.releaseTemporary(this._texture);
+ for (var n = 0; n < k; ++n) {
+ d[0] = 1 / f;
+ d[1] = 1 / g;
+ f = f >> 1 || 0;
+ g = g >> 1 || 0;
+ c = GL.Texture.getTemporary(f, g, l);
+ b.push(c);
+ a.setParameter(GL.TEXTURE_MAG_FILTER, GL.NEAREST);
+ a.copyTo(c, e, h);
+ if (1 == f && 1 == g) {
+ break;
+ }
+ a = c;
+ }
+ this._texture = b.pop();
+ for (n = 0; n < b.length; ++n) {
+ GL.Texture.releaseTemporary(b[n]);
+ }
+ this.properties.generate_mipmaps && (this._texture.bind(0), gl.generateMipmap(this._texture.texture_type), this._texture.unbind(0));
+ this.setOutputData(0, this._texture);
+ }
+ };
+ LGraphTextureDownsample.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_offset;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord );\n\r\n\t\t\t\tcolor += texture2D(u_texture, v_coord + vec2( u_offset.x, 0.0 ) );\n\r\n\t\t\t\tcolor += texture2D(u_texture, v_coord + vec2( 0.0, u_offset.y ) );\n\r\n\t\t\t\tcolor += texture2D(u_texture, v_coord + vec2( u_offset.x, u_offset.y ) );\n\r\n\t\t\t gl_FragColor = color * 0.25;\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/downsample", LGraphTextureDownsample);
+ LGraphTextureAverage.title = "Average";
+ LGraphTextureAverage.desc = "Compute a partial average (32 random samples) of a texture and stores it as a 1x1 pixel texture";
+ LGraphTextureAverage.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (c && this.isOutputConnected(0)) {
+ if (!LGraphTextureAverage._shader) {
+ LGraphTextureAverage._shader = new GL.Shader(GL.Shader.SCREEN_VERTEX_SHADER, LGraphTextureAverage.pixel_shader);
+ for (var e = new Float32Array(32), f = 0; 32 > f; ++f) {
+ e[f] = Math.random();
+ }
+ LGraphTextureAverage._shader.uniforms({u_samples_a:e.subarray(0, 16), u_samples_b:e.subarray(16, 32)});
+ }
+ e = this._temp_texture;
+ f = this.properties.low_precision ? gl.UNSIGNED_BYTE : c.type;
+ e && e.type == f || (this._temp_texture = new GL.Texture(1, 1, {type:f, format:gl.RGBA, filter:gl.NEAREST}));
+ var g = LGraphTextureAverage._shader, l = this._uniforms;
+ l.u_mipmap_offset = this.properties.mipmap_offset;
+ this._temp_texture.drawTo(function() {
+ c.toViewport(g, l);
+ });
+ this.setOutputData(0, this._temp_texture);
+ }
+ };
+ LGraphTextureAverage.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tuniform mat4 u_samples_a;\n\r\n\t\t\tuniform mat4 u_samples_b;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform float u_mipmap_offset;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = vec4(0.0);\n\r\n\t\t\t\tfor(int i = 0; i < 4; ++i)\n\r\n\t\t\t\t\tfor(int j = 0; j < 4; ++j)\n\r\n\t\t\t\t\t{\n\r\n\t\t\t\t\t\tcolor += texture2D(u_texture, vec2( u_samples_a[i][j], u_samples_b[i][j] ), u_mipmap_offset );\n\r\n\t\t\t\t\t\tcolor += texture2D(u_texture, vec2( 1.0 - u_samples_a[i][j], 1.0 - u_samples_b[i][j] ), u_mipmap_offset );\n\r\n\t\t\t\t\t}\n\r\n\t\t\t gl_FragColor = color * 0.03125;\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/average", LGraphTextureAverage);
+ LGraphImageToTexture.title = "Image to Texture";
+ LGraphImageToTexture.desc = "Uploads an image to the GPU";
+ LGraphImageToTexture.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (c) {
+ var e = c.videoWidth || c.width, f = c.videoHeight || c.height;
+ if (c.gltexture) {
+ this.setOutputData(0, c.gltexture);
+ } else {
+ var g = this._temp_texture;
+ g && g.width == e && g.height == f || (this._temp_texture = new GL.Texture(e, f, {format:gl.RGBA, filter:gl.LINEAR}));
+ try {
+ this._temp_texture.uploadImage(c);
+ } catch (l) {
+ console.error("image comes from an unsafe location, cannot be uploaded to webgl");
+ return;
+ }
+ this.setOutputData(0, this._temp_texture);
+ }
+ }
+ };
+ LiteGraph.registerNodeType("texture/imageToTexture", LGraphImageToTexture);
+ LGraphTextureLUT.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureLUT.title = "LUT";
+ LGraphTextureLUT.desc = "Apply LUT to Texture";
+ LGraphTextureLUT.widgets_info = {texture:{widget:"texture"}};
+ LGraphTextureLUT.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var c = this.getInputData(0);
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ if (c) {
+ var e = this.getInputData(1);
+ e || (e = LGraphTexture.getTexture(this.properties.texture));
+ if (e) {
+ e.bind(0);
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+ gl.bindTexture(gl.TEXTURE_2D, null);
+ var f = this.properties.intensity;
+ this.isInputConnected(2) && (this.properties.intensity = f = this.getInputData(2));
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ this._tex.drawTo(function() {
+ e.bind(1);
+ c.toViewport(LGraphTextureLUT._shader, {u_texture:0, u_textureB:1, u_amount:f});
+ });
+ this.setOutputData(0, this._tex);
+ } else {
+ this.setOutputData(0, c);
+ }
+ }
+ }
+ }
+ };
+ LGraphTextureLUT.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_textureB;\n\r\n\t\t\tuniform float u_amount;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\t lowp vec4 textureColor = clamp( texture2D(u_texture, v_coord), vec4(0.0), vec4(1.0) );\n\r\n\t\t\t\t mediump float blueColor = textureColor.b * 63.0;\n\r\n\t\t\t\t mediump vec2 quad1;\n\r\n\t\t\t\t quad1.y = floor(floor(blueColor) / 8.0);\n\r\n\t\t\t\t quad1.x = floor(blueColor) - (quad1.y * 8.0);\n\r\n\t\t\t\t mediump vec2 quad2;\n\r\n\t\t\t\t quad2.y = floor(ceil(blueColor) / 8.0);\n\r\n\t\t\t\t quad2.x = ceil(blueColor) - (quad2.y * 8.0);\n\r\n\t\t\t\t highp vec2 texPos1;\n\r\n\t\t\t\t texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);\n\r\n\t\t\t\t texPos1.y = 1.0 - ((quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g));\n\r\n\t\t\t\t highp vec2 texPos2;\n\r\n\t\t\t\t texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);\n\r\n\t\t\t\t texPos2.y = 1.0 - ((quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g));\n\r\n\t\t\t\t lowp vec4 newColor1 = texture2D(u_textureB, texPos1);\n\r\n\t\t\t\t lowp vec4 newColor2 = texture2D(u_textureB, texPos2);\n\r\n\t\t\t\t lowp vec4 newColor = mix(newColor1, newColor2, fract(blueColor));\n\r\n\t\t\t\t gl_FragColor = vec4( mix( textureColor.rgb, newColor.rgb, u_amount), textureColor.w);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/LUT", LGraphTextureLUT);
+ LGraphTextureChannels.title = "Texture to Channels";
+ LGraphTextureChannels.desc = "Split texture channels";
+ LGraphTextureChannels.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (c) {
+ this._channels || (this._channels = Array(4));
+ for (var e = 0, f = 0; 4 > f; f++) {
+ this.isOutputConnected(f) ? (this._channels[f] && this._channels[f].width == c.width && this._channels[f].height == c.height && this._channels[f].type == c.type || (this._channels[f] = new GL.Texture(c.width, c.height, {type:c.type, format:gl.RGBA, filter:gl.LINEAR})), e++) : this._channels[f] = null;
+ }
+ if (e) {
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var g = Mesh.getScreenQuad(), l = LGraphTextureChannels._shader, k = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]];
+ for (f = 0; 4 > f; f++) {
+ this._channels[f] && (this._channels[f].drawTo(function() {
+ c.bind(0);
+ l.uniforms({u_texture:0, u_mask:k[f]}).draw(g);
+ }), this.setOutputData(f, this._channels[f]));
+ }
+ }
+ }
+ };
+ LGraphTextureChannels.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec4 u_mask;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t gl_FragColor = vec4( vec3( length( texture2D(u_texture, v_coord) * u_mask )), 1.0 );\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/textureChannels", LGraphTextureChannels);
+ LGraphChannelsTexture.title = "Channels to Texture";
+ LGraphChannelsTexture.desc = "Split texture channels";
+ LGraphChannelsTexture.prototype.onExecute = function() {
+ var c = [this.getInputData(0), this.getInputData(1), this.getInputData(2), this.getInputData(3)];
+ if (c[0] && c[1] && c[2] && c[3]) {
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var e = Mesh.getScreenQuad(), f = LGraphChannelsTexture._shader;
+ this._tex = LGraphTexture.getTargetTexture(c[0], this._tex);
+ this._tex.drawTo(function() {
+ c[0].bind(0);
+ c[1].bind(1);
+ c[2].bind(2);
+ c[3].bind(3);
+ f.uniforms({u_textureR:0, u_textureG:1, u_textureB:2, u_textureA:3}).draw(e);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ };
+ LGraphChannelsTexture.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_textureR;\n\r\n\t\t\tuniform sampler2D u_textureG;\n\r\n\t\t\tuniform sampler2D u_textureB;\n\r\n\t\t\tuniform sampler2D u_textureA;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t gl_FragColor = vec4( \r\n\t\t\t\t\t\ttexture2D(u_textureR, v_coord).r,\r\n\t\t\t\t\t\ttexture2D(u_textureG, v_coord).r,\r\n\t\t\t\t\t\ttexture2D(u_textureB, v_coord).r,\r\n\t\t\t\t\t\ttexture2D(u_textureA, v_coord).r);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/channelsTexture", LGraphChannelsTexture);
+ LGraphTextureGradient.title = "Gradient";
+ LGraphTextureGradient.desc = "Generates a gradient";
+ LGraphTextureGradient["@A"] = {type:"color"};
+ LGraphTextureGradient["@B"] = {type:"color"};
+ LGraphTextureGradient["@texture_size"] = {type:"enum", values:[32, 64, 128, 256, 512]};
+ LGraphTextureGradient.prototype.onExecute = function() {
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var c = GL.Mesh.getScreenQuad(), e = LGraphTextureGradient._shader, f = this.getInputData(0);
+ f || (f = this.properties.A);
+ var g = this.getInputData(1);
+ g || (g = this.properties.B);
+ for (var l = 2; l < this.inputs.length; l++) {
+ var k = this.inputs[l], a = this.getInputData(l);
+ void 0 !== a && (this.properties[k.name] = a);
+ }
+ var b = this._uniforms;
+ this._uniforms.u_angle = this.properties.angle * DEG2RAD;
+ this._uniforms.u_scale = this.properties.scale;
+ vec3.copy(b.u_colorA, f);
+ vec3.copy(b.u_colorB, g);
+ f = parseInt(this.properties.texture_size);
+ this._tex && this._tex.width == f || (this._tex = new GL.Texture(f, f, {format:gl.RGB, filter:gl.LINEAR}));
+ this._tex.drawTo(function() {
+ e.uniforms(b).draw(c);
+ });
+ this.setOutputData(0, this._tex);
+ };
+ LGraphTextureGradient.prototype.onGetInputs = function() {
+ return [["angle", "number"], ["scale", "number"]];
+ };
+ LGraphTextureGradient.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform float u_angle;\n\r\n\t\t\tuniform float u_scale;\n\r\n\t\t\tuniform vec3 u_colorA;\n\r\n\t\t\tuniform vec3 u_colorB;\n\r\n\t\t\t\n\r\n\t\t\tvec2 rotate(vec2 v, float angle)\n\r\n\t\t\t{\n\r\n\t\t\t\tvec2 result;\n\r\n\t\t\t\tfloat _cos = cos(angle);\n\r\n\t\t\t\tfloat _sin = sin(angle);\n\r\n\t\t\t\tresult.x = v.x * _cos - v.y * _sin;\n\r\n\t\t\t\tresult.y = v.x * _sin + v.y * _cos;\n\r\n\t\t\t\treturn result;\n\r\n\t\t\t}\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tfloat f = (rotate(u_scale * (v_coord - vec2(0.5)), u_angle) + vec2(0.5)).x;\n\r\n\t\t\t\tvec3 color = mix(u_colorA,u_colorB,clamp(f,0.0,1.0));\n\r\n\t\t\t gl_FragColor = vec4(color,1.0);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/gradient", LGraphTextureGradient);
+ LGraphTextureMix.title = "Mix";
+ LGraphTextureMix.desc = "Generates a texture mixing two textures";
+ LGraphTextureMix.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureMix.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (this.isOutputConnected(0)) {
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ var e = this.getInputData(1), f = this.getInputData(2);
+ if (c && e && f) {
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var g = Mesh.getScreenQuad(), l = LGraphTextureMix._shader;
+ this._tex.drawTo(function() {
+ c.bind(0);
+ e.bind(1);
+ f.bind(2);
+ l.uniforms({u_textureA:0, u_textureB:1, u_textureMix:2}).draw(g);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ }
+ };
+ LGraphTextureMix.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_textureA;\n\r\n\t\t\tuniform sampler2D u_textureB;\n\r\n\t\t\tuniform sampler2D u_textureMix;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t gl_FragColor = mix( texture2D(u_textureA, v_coord), texture2D(u_textureB, v_coord), texture2D(u_textureMix, v_coord) );\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/mix", LGraphTextureMix);
+ LGraphTextureEdges.title = "Edges";
+ LGraphTextureEdges.desc = "Detects edges";
+ LGraphTextureEdges.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureEdges.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var c = this.getInputData(0);
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ if (c) {
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var e = Mesh.getScreenQuad(), f = LGraphTextureEdges._shader, g = this.properties.invert, l = this.properties.factor;
+ this._tex.drawTo(function() {
+ c.bind(0);
+ f.uniforms({u_texture:0, u_isize:[1 / c.width, 1 / c.height], u_factor:l, u_invert:g ? 1 : 0}).draw(e);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ }
+ };
+ LGraphTextureEdges.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_isize;\n\r\n\t\t\tuniform int u_invert;\n\r\n\t\t\tuniform float u_factor;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 center = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tvec4 up = texture2D(u_texture, v_coord + u_isize * vec2(0.0,1.0) );\n\r\n\t\t\t\tvec4 down = texture2D(u_texture, v_coord + u_isize * vec2(0.0,-1.0) );\n\r\n\t\t\t\tvec4 left = texture2D(u_texture, v_coord + u_isize * vec2(1.0,0.0) );\n\r\n\t\t\t\tvec4 right = texture2D(u_texture, v_coord + u_isize * vec2(-1.0,0.0) );\n\r\n\t\t\t\tvec4 diff = abs(center - up) + abs(center - down) + abs(center - left) + abs(center - right);\n\r\n\t\t\t\tdiff *= u_factor;\n\r\n\t\t\t\tif(u_invert == 1)\n\r\n\t\t\t\t\tdiff.xyz = vec3(1.0) - diff.xyz;\n\r\n\t\t\t gl_FragColor = vec4( diff.xyz, center.a );\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/edges", LGraphTextureEdges);
+ LGraphTextureDepthRange.title = "Depth Range";
+ LGraphTextureDepthRange.desc = "Generates a texture with a depth range";
+ LGraphTextureDepthRange.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var c = this.getInputData(0);
+ if (c) {
+ var e = gl.UNSIGNED_BYTE;
+ this.properties.high_precision && (e = gl.half_float_ext ? gl.HALF_FLOAT_OES : gl.FLOAT);
+ this._temp_texture && this._temp_texture.type == e && this._temp_texture.width == c.width && this._temp_texture.height == c.height || (this._temp_texture = new GL.Texture(c.width, c.height, {type:e, format:gl.RGBA, filter:gl.LINEAR}));
+ var f = this.properties.distance;
+ this.isInputConnected(1) && (f = this.getInputData(1), this.properties.distance = f);
+ var g = this.properties.range;
+ this.isInputConnected(2) && (g = this.getInputData(2), this.properties.range = g);
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var l = Mesh.getScreenQuad();
+ LGraphTextureDepthRange._shader || (LGraphTextureDepthRange._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureDepthRange.pixel_shader));
+ var k = LGraphTextureDepthRange._shader, a = [LS.Renderer._current_camera.near, LS.Renderer._current_camera.far];
+ this._temp_texture.drawTo(function() {
+ c.bind(0);
+ k.uniforms({u_texture:0, u_distance:f, u_range:g, u_camera_planes:a}).draw(l);
+ });
+ this.setOutputData(0, this._temp_texture);
+ }
+ }
+ };
+ LGraphTextureDepthRange.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_camera_planes;\n\r\n\t\t\tuniform float u_distance;\n\r\n\t\t\tuniform float u_range;\n\r\n\t\t\t\n\r\n\t\t\tfloat LinearDepth()\n\r\n\t\t\t{\n\r\n\t\t\t\tfloat n = u_camera_planes.x;\n\r\n\t\t\t\tfloat f = u_camera_planes.y;\n\r\n\t\t\t\treturn (2.0 * n) / (f + n - texture2D(u_texture, v_coord).x * (f - n));\n\r\n\t\t\t}\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tfloat diff = abs(LinearDepth() * u_camera_planes.y - u_distance);\n\r\n\t\t\t\tfloat dof = 1.0;\n\r\n\t\t\t\tif(diff <= u_range)\n\r\n\t\t\t\t\tdof = diff / u_range;\n\r\n\t\t\t gl_FragColor = vec4(dof);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/depth_range", LGraphTextureDepthRange);
+ LGraphTextureBlur.title = "Blur";
+ LGraphTextureBlur.desc = "Blur a texture";
+ LGraphTextureBlur.max_iterations = 20;
+ LGraphTextureBlur.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (c && this.isOutputConnected(0)) {
+ var e = this._temp_texture;
+ e && e.width == c.width && e.height == c.height && e.type == c.type || (this._temp_texture = new GL.Texture(c.width, c.height, {type:c.type, format:gl.RGBA, filter:gl.LINEAR}), this._final_texture = new GL.Texture(c.width, c.height, {type:c.type, format:gl.RGBA, filter:gl.LINEAR}));
+ e = this.properties.iterations;
+ this.isInputConnected(1) && (e = this.getInputData(1), this.properties.iterations = e);
+ e = Math.min(Math.floor(e), LGraphTextureBlur.max_iterations);
+ if (0 == e) {
+ this.setOutputData(0, c);
+ } else {
+ var f = this.properties.intensity;
+ this.isInputConnected(2) && (f = this.getInputData(2), this.properties.intensity = f);
+ var g = LiteGraph.camera_aspect;
+ g || void 0 === window.gl || (g = gl.canvas.height / gl.canvas.width);
+ g || (g = 1);
+ g = this.properties.preserve_aspect ? g : 1;
+ for (var l = this.properties.scale || [1, 1], k = 0; k < e; ++k) {
+ c.applyBlur(g * l[0] * k, l[1] * k, f, this._temp_texture, this._final_texture), c = this._final_texture;
+ }
+ this.setOutputData(0, this._final_texture);
+ }
+ }
+ };
+ LGraphTextureBlur.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_offset;\n\r\n\t\t\tuniform float u_intensity;\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t vec4 sum = vec4(0.0);\n\r\n\t\t\t vec4 center = texture2D(u_texture, v_coord);\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * -4.0) * 0.05/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * -3.0) * 0.09/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * -2.0) * 0.12/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * -1.0) * 0.15/0.98;\n\r\n\t\t\t sum += center * 0.16/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * 4.0) * 0.05/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * 3.0) * 0.09/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * 2.0) * 0.12/0.98;\n\r\n\t\t\t sum += texture2D(u_texture, v_coord + u_offset * 1.0) * 0.15/0.98;\n\r\n\t\t\t gl_FragColor = u_intensity * sum;\n\r\n\t\t\t /*gl_FragColor.a = center.a*/;\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("texture/blur", LGraphTextureBlur);
+ LGraphTextureKuwaharaFilter.title = "Kuwahara Filter";
+ LGraphTextureKuwaharaFilter.desc = "Filters a texture giving an artistic oil canvas painting";
+ LGraphTextureKuwaharaFilter.max_radius = 10;
+ LGraphTextureKuwaharaFilter._shaders = [];
+ LGraphTextureKuwaharaFilter.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (c && this.isOutputConnected(0)) {
+ var e = this._temp_texture;
+ e && e.width == c.width && e.height == c.height && e.type == c.type || (this._temp_texture = new GL.Texture(c.width, c.height, {type:c.type, format:gl.RGBA, filter:gl.LINEAR}));
+ e = this.properties.radius;
+ e = Math.min(Math.floor(e), LGraphTextureKuwaharaFilter.max_radius);
+ if (0 == e) {
+ this.setOutputData(0, c);
+ } else {
+ var f = this.properties.intensity, g = LiteGraph.camera_aspect;
+ g || void 0 === window.gl || (g = gl.canvas.height / gl.canvas.width);
+ g || (g = 1);
+ g = this.properties.preserve_aspect ? g : 1;
+ LGraphTextureKuwaharaFilter._shaders[e] || (LGraphTextureKuwaharaFilter._shaders[e] = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphTextureKuwaharaFilter.pixel_shader, {RADIUS:e.toFixed(0)}));
+ var l = LGraphTextureKuwaharaFilter._shaders[e], k = GL.Mesh.getScreenQuad();
+ c.bind(0);
+ this._temp_texture.drawTo(function() {
+ l.uniforms({u_texture:0, u_intensity:f, u_resolution:[c.width, c.height], u_iResolution:[1 / c.width, 1 / c.height]}).draw(k);
+ });
+ this.setOutputData(0, this._temp_texture);
+ }
+ }
+ };
+ LGraphTextureKuwaharaFilter.pixel_shader = "\n\r\n\tprecision highp float;\n\r\n\tvarying vec2 v_coord;\n\r\n\tuniform sampler2D u_texture;\n\r\n\tuniform float u_intensity;\n\r\n\tuniform vec2 u_resolution;\n\r\n\tuniform vec2 u_iResolution;\n\r\n\t#ifndef RADIUS\n\r\n\t\t#define RADIUS 7\n\r\n\t#endif\n\r\n\tvoid main() {\n\r\n\t\n\r\n\t\tconst int radius = RADIUS;\n\r\n\t\tvec2 fragCoord = v_coord;\n\r\n\t\tvec2 src_size = u_iResolution;\n\r\n\t\tvec2 uv = v_coord;\n\r\n\t\tfloat n = float((radius + 1) * (radius + 1));\n\r\n\t\tint i;\n\r\n\t\tint j;\n\r\n\t\tvec3 m0 = vec3(0.0); vec3 m1 = vec3(0.0); vec3 m2 = vec3(0.0); vec3 m3 = vec3(0.0);\n\r\n\t\tvec3 s0 = vec3(0.0); vec3 s1 = vec3(0.0); vec3 s2 = vec3(0.0); vec3 s3 = vec3(0.0);\n\r\n\t\tvec3 c;\n\r\n\t\t\n\r\n\t\tfor (int j = -radius; j <= 0; ++j) {\n\r\n\t\t\tfor (int i = -radius; i <= 0; ++i) {\n\r\n\t\t\t\tc = texture2D(u_texture, uv + vec2(i,j) * src_size).rgb;\n\r\n\t\t\t\tm0 += c;\n\r\n\t\t\t\ts0 += c * c;\n\r\n\t\t\t}\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tfor (int j = -radius; j <= 0; ++j) {\n\r\n\t\t\tfor (int i = 0; i <= radius; ++i) {\n\r\n\t\t\t\tc = texture2D(u_texture, uv + vec2(i,j) * src_size).rgb;\n\r\n\t\t\t\tm1 += c;\n\r\n\t\t\t\ts1 += c * c;\n\r\n\t\t\t}\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tfor (int j = 0; j <= radius; ++j) {\n\r\n\t\t\tfor (int i = 0; i <= radius; ++i) {\n\r\n\t\t\t\tc = texture2D(u_texture, uv + vec2(i,j) * src_size).rgb;\n\r\n\t\t\t\tm2 += c;\n\r\n\t\t\t\ts2 += c * c;\n\r\n\t\t\t}\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tfor (int j = 0; j <= radius; ++j) {\n\r\n\t\t\tfor (int i = -radius; i <= 0; ++i) {\n\r\n\t\t\t\tc = texture2D(u_texture, uv + vec2(i,j) * src_size).rgb;\n\r\n\t\t\t\tm3 += c;\n\r\n\t\t\t\ts3 += c * c;\n\r\n\t\t\t}\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tfloat min_sigma2 = 1e+2;\n\r\n\t\tm0 /= n;\n\r\n\t\ts0 = abs(s0 / n - m0 * m0);\n\r\n\t\t\n\r\n\t\tfloat sigma2 = s0.r + s0.g + s0.b;\n\r\n\t\tif (sigma2 < min_sigma2) {\n\r\n\t\t\tmin_sigma2 = sigma2;\n\r\n\t\t\tgl_FragColor = vec4(m0, 1.0);\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tm1 /= n;\n\r\n\t\ts1 = abs(s1 / n - m1 * m1);\n\r\n\t\t\n\r\n\t\tsigma2 = s1.r + s1.g + s1.b;\n\r\n\t\tif (sigma2 < min_sigma2) {\n\r\n\t\t\tmin_sigma2 = sigma2;\n\r\n\t\t\tgl_FragColor = vec4(m1, 1.0);\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tm2 /= n;\n\r\n\t\ts2 = abs(s2 / n - m2 * m2);\n\r\n\t\t\n\r\n\t\tsigma2 = s2.r + s2.g + s2.b;\n\r\n\t\tif (sigma2 < min_sigma2) {\n\r\n\t\t\tmin_sigma2 = sigma2;\n\r\n\t\t\tgl_FragColor = vec4(m2, 1.0);\n\r\n\t\t}\n\r\n\t\t\n\r\n\t\tm3 /= n;\n\r\n\t\ts3 = abs(s3 / n - m3 * m3);\n\r\n\t\t\n\r\n\t\tsigma2 = s3.r + s3.g + s3.b;\n\r\n\t\tif (sigma2 < min_sigma2) {\n\r\n\t\t\tmin_sigma2 = sigma2;\n\r\n\t\t\tgl_FragColor = vec4(m3, 1.0);\n\r\n\t\t}\n\r\n\t}\n\r\n\t";
+ LiteGraph.registerNodeType("texture/kuwahara", LGraphTextureKuwaharaFilter);
+ LGraphTextureWebcam.title = "Webcam";
+ LGraphTextureWebcam.desc = "Webcam texture";
+ LGraphTextureWebcam.prototype.openStream = function() {
+ navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia;
+ window.URL = window.URL || window.webkitURL;
+ if (navigator.getUserMedia) {
+ this._waiting_confirmation = !0;
+ var c = this;
+ navigator.getUserMedia({video:!0}, this.streamReady.bind(this), function(e) {
+ console.log("Webcam rejected", e);
+ c._webcam_stream = !1;
+ c.box_color = "red";
+ });
+ }
+ };
+ LGraphTextureWebcam.prototype.streamReady = function(c) {
+ this._webcam_stream = c;
+ var e = this._video;
+ e || (e = document.createElement("video"), e.autoplay = !0, e.src = window.URL.createObjectURL(c), this._video = e, e.onloadedmetadata = function(c) {
+ console.log(c);
+ });
+ };
+ LGraphTextureWebcam.prototype.onRemoved = function() {
+ this._webcam_stream && (this._webcam_stream.stop(), this._video = this._webcam_stream = null);
+ };
+ LGraphTextureWebcam.prototype.onDrawBackground = function(c) {
+ this.flags.collapsed || 20 >= this.size[1] || !this._video || (c.save(), c.webgl ? this._temp_texture && c.drawImage(this._temp_texture, 0, 0, this.size[0], this.size[1]) : (c.translate(0, this.size[1]), c.scale(1, -1), c.drawImage(this._video, 0, 0, this.size[0], this.size[1])), c.restore());
+ };
+ LGraphTextureWebcam.prototype.onExecute = function() {
+ null != this._webcam_stream || this._waiting_confirmation || this.openStream();
+ if (this._video && this._video.videoWidth) {
+ var c = this._video.videoWidth, e = this._video.videoHeight, f = this._temp_texture;
+ f && f.width == c && f.height == e || (this._temp_texture = new GL.Texture(c, e, {format:gl.RGB, filter:gl.LINEAR}));
+ this._temp_texture.uploadImage(this._video);
+ this.properties.texture_name && (LGraphTexture.getTexturesContainer()[this.properties.texture_name] = this._temp_texture);
+ this.setOutputData(0, this._temp_texture);
+ }
+ };
+ LiteGraph.registerNodeType("texture/webcam", LGraphTextureWebcam);
+ LGraphTextureMatte.title = "Matte";
+ LGraphTextureMatte.desc = "Extracts background";
+ LGraphTextureMatte.widgets_info = {key_color:{widget:"color"}, precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphTextureMatte.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var c = this.getInputData(0);
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ if (c) {
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ this._uniforms || (this._uniforms = {u_texture:0, u_key_color:this.properties.key_color, u_threshold:1, u_slope:1});
+ var e = this._uniforms, f = Mesh.getScreenQuad(), g = LGraphTextureMatte._shader;
+ e.u_key_color = this.properties.key_color;
+ e.u_threshold = this.properties.threshold;
+ e.u_slope = this.properties.slope;
+ this._tex.drawTo(function() {
+ c.bind(0);
+ g.uniforms(e).draw(f);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ }
+ };
+ LGraphTextureMatte.pixel_shader = "precision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec3 u_key_color;\n\r\n\t\t\tuniform float u_threshold;\n\r\n\t\t\tuniform float u_slope;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec3 color = texture2D( u_texture, v_coord ).xyz;\n\r\n\t\t\t\tfloat diff = length( normalize(color) - normalize(u_key_color) );\n\r\n\t\t\t\tfloat edge = u_threshold * (1.0 - u_slope);\n\r\n\t\t\t\tfloat alpha = smoothstep( edge, u_threshold, diff);\n\r\n\t\t\t\tgl_FragColor = vec4( color, alpha );\n\r\n\t\t\t}";
+ LiteGraph.registerNodeType("texture/matte", LGraphTextureMatte);
+ LGraphCubemap.title = "Cubemap";
+ LGraphCubemap.prototype.onDropFile = function(c, e, f) {
+ c ? (this._drop_texture = "string" == typeof c ? GL.Texture.fromURL(c) : GL.Texture.fromDDSInMemory(c), this.properties.name = e) : (this._drop_texture = null, this.properties.name = "");
+ };
+ LGraphCubemap.prototype.onExecute = function() {
+ if (this._drop_texture) {
+ this.setOutputData(0, this._drop_texture);
+ } else {
+ if (this.properties.name) {
+ var c = LGraphTexture.getTexture(this.properties.name);
+ c && (this._last_tex = c, this.setOutputData(0, c));
+ }
+ }
+ };
+ LGraphCubemap.prototype.onDrawBackground = function(c) {
+ this.flags.collapsed || 20 >= this.size[1] || !c.webgl || gl.meshes.cube || (gl.meshes.cube = GL.Mesh.cube({size:1}));
+ };
+ LiteGraph.registerNodeType("texture/cubemap", LGraphCubemap);
+}
+;if ("undefined" != typeof LiteGraph) {
+ var LGraphFXVigneting = function() {
+ this.addInput("Tex.", "Texture");
+ this.addInput("intensity", "number");
+ this.addOutput("Texture", "Texture");
+ this.properties = {intensity:1, invert:!1, precision:LGraphTexture.DEFAULT};
+ LGraphFXVigneting._shader || (LGraphFXVigneting._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphFXVigneting.pixel_shader));
+ }, LGraphFXGeneric = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("value1", "number");
+ this.addInput("value2", "number");
+ this.addOutput("Texture", "Texture");
+ this.properties = {fx:"halftone", value1:1, value2:1, precision:LGraphTexture.DEFAULT};
+ }, LGraphFXBokeh = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("Blurred", "Texture");
+ this.addInput("Mask", "Texture");
+ this.addInput("Threshold", "number");
+ this.addOutput("Texture", "Texture");
+ this.properties = {shape:"", size:10, alpha:1.0, threshold:1.0, high_precision:!1};
+ }, LGraphFXLens = function() {
+ this.addInput("Texture", "Texture");
+ this.addInput("Aberration", "number");
+ this.addInput("Distortion", "number");
+ this.addInput("Blur", "number");
+ this.addOutput("Texture", "Texture");
+ this.properties = {aberration:1.0, distortion:1.0, blur:1.0, precision:LGraphTexture.DEFAULT};
+ LGraphFXLens._shader || (LGraphFXLens._shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphFXLens.pixel_shader));
+ };
+ LGraphFXLens.title = "Lens";
+ LGraphFXLens.desc = "Camera Lens distortion";
+ LGraphFXLens.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphFXLens.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ if (c) {
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ var e = this.properties.aberration;
+ this.isInputConnected(1) && (e = this.getInputData(1), this.properties.aberration = e);
+ var f = this.properties.distortion;
+ this.isInputConnected(2) && (f = this.getInputData(2), this.properties.distortion = f);
+ var g = this.properties.blur;
+ this.isInputConnected(3) && (g = this.getInputData(3), this.properties.blur = g);
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var l = Mesh.getScreenQuad(), k = LGraphFXLens._shader;
+ this._tex.drawTo(function() {
+ c.bind(0);
+ k.uniforms({u_texture:0, u_aberration:e, u_distortion:f, u_blur:g}).draw(l);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ };
+ LGraphFXLens.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_camera_planes;\n\r\n\t\t\tuniform float u_aberration;\n\r\n\t\t\tuniform float u_distortion;\n\r\n\t\t\tuniform float u_blur;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec2 coord = v_coord;\n\r\n\t\t\t\tfloat dist = distance(vec2(0.5), coord);\n\r\n\t\t\t\tvec2 dist_coord = coord - vec2(0.5);\n\r\n\t\t\t\tfloat percent = 1.0 + ((0.5 - dist) / 0.5) * u_distortion;\n\r\n\t\t\t\tdist_coord *= percent;\n\r\n\t\t\t\tcoord = dist_coord + vec2(0.5);\n\r\n\t\t\t\tvec4 color = texture2D(u_texture,coord, u_blur * dist);\n\r\n\t\t\t\tcolor.r = texture2D(u_texture,vec2(0.5) + dist_coord * (1.0+0.01*u_aberration), u_blur * dist ).r;\n\r\n\t\t\t\tcolor.b = texture2D(u_texture,vec2(0.5) + dist_coord * (1.0-0.01*u_aberration), u_blur * dist ).b;\n\r\n\t\t\t\tgl_FragColor = color;\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("fx/lens", LGraphFXLens);
+ window.LGraphFXLens = LGraphFXLens;
+ LGraphFXBokeh.title = "Bokeh";
+ LGraphFXBokeh.desc = "applies an Bokeh effect";
+ LGraphFXBokeh.widgets_info = {shape:{widget:"texture"}};
+ LGraphFXBokeh.prototype.onExecute = function() {
+ var c = this.getInputData(0), e = this.getInputData(1), f = this.getInputData(2);
+ if (c && f && this.properties.shape) {
+ e || (e = c);
+ var g = LGraphTexture.getTexture(this.properties.shape);
+ if (g) {
+ var l = this.properties.threshold;
+ this.isInputConnected(3) && (l = this.getInputData(3), this.properties.threshold = l);
+ var k = gl.UNSIGNED_BYTE;
+ this.properties.high_precision && (k = gl.half_float_ext ? gl.HALF_FLOAT_OES : gl.FLOAT);
+ this._temp_texture && this._temp_texture.type == k && this._temp_texture.width == c.width && this._temp_texture.height == c.height || (this._temp_texture = new GL.Texture(c.width, c.height, {type:k, format:gl.RGBA, filter:gl.LINEAR}));
+ var a = LGraphFXBokeh._first_shader;
+ a || (a = LGraphFXBokeh._first_shader = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, LGraphFXBokeh._first_pixel_shader));
+ var b = LGraphFXBokeh._second_shader;
+ b || (b = LGraphFXBokeh._second_shader = new GL.Shader(LGraphFXBokeh._second_vertex_shader, LGraphFXBokeh._second_pixel_shader));
+ var d = this._points_mesh;
+ d && d._width == c.width && d._height == c.height && 2 == d._spacing || (d = this.createPointsMesh(c.width, c.height, 2));
+ var h = Mesh.getScreenQuad(), n = this.properties.size, v = this.properties.alpha;
+ gl.disable(gl.DEPTH_TEST);
+ gl.disable(gl.BLEND);
+ this._temp_texture.drawTo(function() {
+ c.bind(0);
+ e.bind(1);
+ f.bind(2);
+ a.uniforms({u_texture:0, u_texture_blur:1, u_mask:2, u_texsize:[c.width, c.height]}).draw(h);
+ });
+ this._temp_texture.drawTo(function() {
+ gl.enable(gl.BLEND);
+ gl.blendFunc(gl.ONE, gl.ONE);
+ c.bind(0);
+ g.bind(3);
+ b.uniforms({u_texture:0, u_mask:2, u_shape:3, u_alpha:v, u_threshold:l, u_pointSize:n, u_itexsize:[1.0 / c.width, 1.0 / c.height]}).draw(d, gl.POINTS);
+ });
+ this.setOutputData(0, this._temp_texture);
+ }
+ } else {
+ this.setOutputData(0, c);
+ }
+ };
+ LGraphFXBokeh.prototype.createPointsMesh = function(c, e, f) {
+ for (var g = Math.round(c / f), l = Math.round(e / f), k = new Float32Array(g * l * 2), a = -1, b = 2 / c * f, d = 2 / e * f, h = 0; h < l; ++h) {
+ for (var n = -1, v = 0; v < g; ++v) {
+ var u = h * g * 2 + 2 * v;
+ k[u] = n;
+ k[u + 1] = a;
+ n += b;
+ }
+ a += d;
+ }
+ this._points_mesh = GL.Mesh.load({vertices2D:k});
+ this._points_mesh._width = c;
+ this._points_mesh._height = e;
+ this._points_mesh._spacing = f;
+ return this._points_mesh;
+ };
+ LGraphFXBokeh._first_pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_texture_blur;\n\r\n\t\t\tuniform sampler2D u_mask;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tvec4 blurred_color = texture2D(u_texture_blur, v_coord);\n\r\n\t\t\t\tfloat mask = texture2D(u_mask, v_coord).x;\n\r\n\t\t\t gl_FragColor = mix(color, blurred_color, mask);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LGraphFXBokeh._second_vertex_shader = "precision highp float;\n\r\n\t\t\tattribute vec2 a_vertex2D;\n\r\n\t\t\tvarying vec4 v_color;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_mask;\n\r\n\t\t\tuniform vec2 u_itexsize;\n\r\n\t\t\tuniform float u_pointSize;\n\r\n\t\t\tuniform float u_threshold;\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec2 coord = a_vertex2D * 0.5 + 0.5;\n\r\n\t\t\t\tv_color = texture2D( u_texture, coord );\n\r\n\t\t\t\tv_color += texture2D( u_texture, coord + vec2(u_itexsize.x, 0.0) );\n\r\n\t\t\t\tv_color += texture2D( u_texture, coord + vec2(0.0, u_itexsize.y));\n\r\n\t\t\t\tv_color += texture2D( u_texture, coord + u_itexsize);\n\r\n\t\t\t\tv_color *= 0.25;\n\r\n\t\t\t\tfloat mask = texture2D(u_mask, coord).x;\n\r\n\t\t\t\tfloat luminance = length(v_color) * mask;\n\r\n\t\t\t\t/*luminance /= (u_pointSize*u_pointSize)*0.01 */;\n\r\n\t\t\t\tluminance -= u_threshold;\n\r\n\t\t\t\tif(luminance < 0.0)\n\r\n\t\t\t\t{\n\r\n\t\t\t\t\tgl_Position.x = -100.0;\n\r\n\t\t\t\t\treturn;\n\r\n\t\t\t\t}\n\r\n\t\t\t\tgl_PointSize = u_pointSize;\n\r\n\t\t\t\tgl_Position = vec4(a_vertex2D,0.0,1.0);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LGraphFXBokeh._second_pixel_shader = "precision highp float;\n\r\n\t\t\tvarying vec4 v_color;\n\r\n\t\t\tuniform sampler2D u_shape;\n\r\n\t\t\tuniform float u_alpha;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D( u_shape, gl_PointCoord );\n\r\n\t\t\t\tcolor *= v_color * u_alpha;\n\r\n\t\t\t\tgl_FragColor = color;\n\r\n\t\t\t}\n";
+ LiteGraph.registerNodeType("fx/bokeh", LGraphFXBokeh);
+ window.LGraphFXBokeh = LGraphFXBokeh;
+ LGraphFXGeneric.title = "FX";
+ LGraphFXGeneric.desc = "applies an FX from a list";
+ LGraphFXGeneric.widgets_info = {fx:{widget:"combo", values:["halftone", "pixelate", "lowpalette", "noise", "gamma"]}, precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphFXGeneric.shaders = {};
+ LGraphFXGeneric.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var c = this.getInputData(0);
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ if (c) {
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ var e = this.properties.value1;
+ this.isInputConnected(1) && (e = this.getInputData(1), this.properties.value1 = e);
+ var f = this.properties.value2;
+ this.isInputConnected(2) && (f = this.getInputData(2), this.properties.value2 = f);
+ var g = this.properties.fx, l = LGraphFXGeneric.shaders[g];
+ if (!l) {
+ var k = LGraphFXGeneric["pixel_shader_" + g];
+ if (!k) {
+ return;
+ }
+ l = LGraphFXGeneric.shaders[g] = new GL.Shader(Shader.SCREEN_VERTEX_SHADER, k);
+ }
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var a = Mesh.getScreenQuad();
+ camera_planes = window.LS && LS.Renderer._current_camera ? [LS.Renderer._current_camera.near, LS.Renderer._current_camera.far] : [1, 100];
+ var b = null;
+ "noise" == g && (b = LGraphTexture.getNoiseTexture());
+ this._tex.drawTo(function() {
+ c.bind(0);
+ "noise" == g && b.bind(1);
+ l.uniforms({u_texture:0, u_noise:1, u_size:[c.width, c.height], u_rand:[Math.random(), Math.random()], u_value1:e, u_value2:f, u_camera_planes:camera_planes}).draw(a);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ }
+ };
+ LGraphFXGeneric.pixel_shader_halftone = "precision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_camera_planes;\n\r\n\t\t\tuniform vec2 u_size;\n\r\n\t\t\tuniform float u_value1;\n\r\n\t\t\tuniform float u_value2;\n\r\n\t\t\t\n\r\n\t\t\tfloat pattern() {\n\r\n\t\t\t\tfloat s = sin(u_value1 * 3.1415), c = cos(u_value1 * 3.1415);\n\r\n\t\t\t\tvec2 tex = v_coord * u_size.xy;\n\r\n\t\t\t\tvec2 point = vec2(\n\r\n\t\t\t\t c * tex.x - s * tex.y ,\n\r\n\t\t\t\t s * tex.x + c * tex.y \n\r\n\t\t\t\t) * u_value2;\n\r\n\t\t\t\treturn (sin(point.x) * sin(point.y)) * 4.0;\n\r\n\t\t\t}\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tfloat average = (color.r + color.g + color.b) / 3.0;\n\r\n\t\t\t\tgl_FragColor = vec4(vec3(average * 10.0 - 5.0 + pattern()), color.a);\n\r\n\t\t\t}\n";
+ LGraphFXGeneric.pixel_shader_pixelate = "precision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_camera_planes;\n\r\n\t\t\tuniform vec2 u_size;\n\r\n\t\t\tuniform float u_value1;\n\r\n\t\t\tuniform float u_value2;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec2 coord = vec2( floor(v_coord.x * u_value1) / u_value1, floor(v_coord.y * u_value2) / u_value2 );\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, coord);\n\r\n\t\t\t\tgl_FragColor = color;\n\r\n\t\t\t}\n";
+ LGraphFXGeneric.pixel_shader_lowpalette = "precision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform vec2 u_camera_planes;\n\r\n\t\t\tuniform vec2 u_size;\n\r\n\t\t\tuniform float u_value1;\n\r\n\t\t\tuniform float u_value2;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tgl_FragColor = floor(color * u_value1) / u_value1;\n\r\n\t\t\t}\n";
+ LGraphFXGeneric.pixel_shader_noise = "precision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform sampler2D u_noise;\n\r\n\t\t\tuniform vec2 u_size;\n\r\n\t\t\tuniform float u_value1;\n\r\n\t\t\tuniform float u_value2;\n\r\n\t\t\tuniform vec2 u_rand;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tvec3 noise = texture2D(u_noise, v_coord * vec2(u_size.x / 512.0, u_size.y / 512.0) + u_rand).xyz - vec3(0.5);\n\r\n\t\t\t\tgl_FragColor = vec4( color.xyz + noise * u_value1, color.a );\n\r\n\t\t\t}\n";
+ LGraphFXGeneric.pixel_shader_gamma = "precision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform float u_value1;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tfloat gamma = 1.0 / u_value1;\n\r\n\t\t\t\tgl_FragColor = vec4( pow( color.xyz, vec3(gamma) ), color.a );\n\r\n\t\t\t}\n";
+ LiteGraph.registerNodeType("fx/generic", LGraphFXGeneric);
+ window.LGraphFXGeneric = LGraphFXGeneric;
+ LGraphFXVigneting.title = "Vigneting";
+ LGraphFXVigneting.desc = "Vigneting";
+ LGraphFXVigneting.widgets_info = {precision:{widget:"combo", values:LGraphTexture.MODE_VALUES}};
+ LGraphFXVigneting.prototype.onExecute = function() {
+ var c = this.getInputData(0);
+ if (this.properties.precision === LGraphTexture.PASS_THROUGH) {
+ this.setOutputData(0, c);
+ } else {
+ if (c) {
+ this._tex = LGraphTexture.getTargetTexture(c, this._tex, this.properties.precision);
+ var e = this.properties.intensity;
+ this.isInputConnected(1) && (e = this.getInputData(1), this.properties.intensity = e);
+ gl.disable(gl.BLEND);
+ gl.disable(gl.DEPTH_TEST);
+ var f = Mesh.getScreenQuad(), g = LGraphFXVigneting._shader, l = this.properties.invert;
+ this._tex.drawTo(function() {
+ c.bind(0);
+ g.uniforms({u_texture:0, u_intensity:e, u_isize:[1 / c.width, 1 / c.height], u_invert:l ? 1 : 0}).draw(f);
+ });
+ this.setOutputData(0, this._tex);
+ }
+ }
+ };
+ LGraphFXVigneting.pixel_shader = "precision highp float;\n\r\n\t\t\tprecision highp float;\n\r\n\t\t\tvarying vec2 v_coord;\n\r\n\t\t\tuniform sampler2D u_texture;\n\r\n\t\t\tuniform float u_intensity;\n\r\n\t\t\tuniform int u_invert;\n\r\n\t\t\t\n\r\n\t\t\tvoid main() {\n\r\n\t\t\t\tfloat luminance = 1.0 - length( v_coord - vec2(0.5) ) * 1.414;\n\r\n\t\t\t\tvec4 color = texture2D(u_texture, v_coord);\n\r\n\t\t\t\tif(u_invert == 1)\n\r\n\t\t\t\t\tluminance = 1.0 - luminance;\n\r\n\t\t\t\tluminance = mix(1.0, luminance, u_intensity);\n\r\n\t\t\t gl_FragColor = vec4( luminance * color.xyz, color.a);\n\r\n\t\t\t}\n\r\n\t\t\t";
+ LiteGraph.registerNodeType("fx/vigneting", LGraphFXVigneting);
+ window.LGraphFXVigneting = LGraphFXVigneting;
+}
+;(function(c) {
+ function e(a) {
+ this.cmd = this.channel = 0;
+ a ? this.setup(a) : this.data = [0, 0, 0];
+ }
+ function f(a, b) {
+ navigator.requestMIDIAccess ? (this.on_ready = a, this.state = {note:[], cc:[]}, navigator.requestMIDIAccess().then(this.onMIDISuccess.bind(this), this.onMIDIFailure.bind(this))) : (this.error = "not suppoorted", b ? b("Not supported") : console.error("MIDI NOT SUPPORTED, enable by chrome://flags"));
+ }
+ function g() {
+ this.addOutput("on_midi", LiteGraph.EVENT);
+ this.addOutput("out", "midi");
+ this.properties = {port:0};
+ this._current_midi_event = this._last_midi_event = null;
+ var a = this;
+ new f(function(b) {
+ a._midi = b;
+ if (a._waiting) {
+ a.onStart();
+ }
+ a._waiting = !1;
+ });
+ }
+ function l() {
+ this.addInput("send", LiteGraph.EVENT);
+ this.properties = {port:0};
+ var a = this;
+ new f(function(b) {
+ a._midi = b;
+ });
+ }
+ function k() {
+ this.addInput("on_midi", LiteGraph.EVENT);
+ this._str = "";
+ this.size = [200, 40];
+ }
+ function a() {
+ this.properties = {channel:-1, cmd:-1, min_value:-1, max_value:-1};
+ this.addInput("in", LiteGraph.EVENT);
+ this.addOutput("on_midi", LiteGraph.EVENT);
+ }
+ function b() {
+ this.properties = {channel:0, cmd:"CC", value1:1, value2:1};
+ this.addInput("send", LiteGraph.EVENT);
+ this.addInput("assign", LiteGraph.EVENT);
+ this.addOutput("on_midi", LiteGraph.EVENT);
+ }
+ function d() {
+ this.properties = {cc:1, value:0};
+ this.addOutput("value", "number");
+ }
+ e.prototype.setup = function(a) {
+ this.data = a;
+ this.status = a = a[0];
+ var b = a & 240;
+ this.cmd = 240 <= a ? a : b;
+ this.cmd == e.NOTEON && 0 == this.velocity && (this.cmd = e.NOTEOFF);
+ this.cmd_str = e.commands[this.cmd] || "";
+ if (b >= e.NOTEON || b <= e.NOTEOFF) {
+ this.channel = a & 15;
+ }
+ };
+ Object.defineProperty(e.prototype, "velocity", {get:function() {
+ return this.cmd == e.NOTEON ? this.data[2] : -1;
+ }, set:function(a) {
+ this.data[2] = a;
+ }, enumerable:!0});
+ e.notes = "A A# B C C# D D# E F F# G G#".split(" ");
+ e.prototype.getPitch = function() {
+ return 440 * Math.pow(2, (this.data[1] - 69) / 12);
+ };
+ e.computePitch = function(a) {
+ return 440 * Math.pow(2, (a - 69) / 12);
+ };
+ e.prototype.getCC = function() {
+ return this.data[1];
+ };
+ e.prototype.getCCValue = function() {
+ return this.data[2];
+ };
+ e.prototype.getPitchBend = function() {
+ return this.data[1] + (this.data[2] << 7) - 8192;
+ };
+ e.computePitchBend = function(a, b) {
+ return a + (b << 7) - 8192;
+ };
+ e.prototype.setCommandFromString = function(a) {
+ this.cmd = e.computeCommandFromString(a);
+ };
+ e.computeCommandFromString = function(a) {
+ if (!a) {
+ return 0;
+ }
+ if (a && a.constructor === Number) {
+ return a;
+ }
+ a = a.toUpperCase();
+ switch(a) {
+ case "NOTE ON":
+ case "NOTEON":
+ return e.NOTEON;
+ case "NOTE OFF":
+ case "NOTEOFF":
+ return e.NOTEON;
+ case "KEY PRESSURE":
+ case "KEYPRESSURE":
+ return e.KEYPRESSURE;
+ case "CONTROLLER CHANGE":
+ case "CONTROLLERCHANGE":
+ case "CC":
+ return e.CONTROLLERCHANGE;
+ case "PROGRAM CHANGE":
+ case "PROGRAMCHANGE":
+ case "PC":
+ return e.PROGRAMCHANGE;
+ case "CHANNEL PRESSURE":
+ case "CHANNELPRESSURE":
+ return e.CHANNELPRESSURE;
+ case "PITCH BEND":
+ case "PITCHBEND":
+ return e.PITCHBEND;
+ case "TIME TICK":
+ case "TIMETICK":
+ return e.TIMETICK;
+ default:
+ return Number(a);
+ }
+ };
+ e.toNoteString = function(a) {
+ var b = (a - 21) % 12;
+ 0 > b && (b = 12 + b);
+ return e.notes[b] + Math.floor((a - 24) / 12 + 1);
+ };
+ e.prototype.toString = function() {
+ var a = "" + this.channel + ". ";
+ switch(this.cmd) {
+ case e.NOTEON:
+ a += "NOTEON " + e.toNoteString(this.data[1]);
+ break;
+ case e.NOTEOFF:
+ a += "NOTEOFF " + e.toNoteString(this.data[1]);
+ break;
+ case e.CONTROLLERCHANGE:
+ a += "CC " + this.data[1] + " " + this.data[2];
+ break;
+ case e.PROGRAMCHANGE:
+ a += "PC " + this.data[1];
+ break;
+ case e.PITCHBEND:
+ a += "PITCHBEND " + this.getPitchBend();
+ break;
+ case e.KEYPRESSURE:
+ a += "KEYPRESS " + this.data[1];
+ }
+ return a;
+ };
+ e.prototype.toHexString = function() {
+ for (var a = "", b = 0; b < this.data.length; b++) {
+ a += this.data[b].toString(16) + " ";
+ }
+ };
+ e.NOTEOFF = 128;
+ e.NOTEON = 144;
+ e.KEYPRESSURE = 160;
+ e.CONTROLLERCHANGE = 176;
+ e.PROGRAMCHANGE = 192;
+ e.CHANNELPRESSURE = 208;
+ e.PITCHBEND = 224;
+ e.TIMETICK = 248;
+ e.commands = {128:"note off", 144:"note on", 160:"key pressure", 176:"controller change", 192:"program change", 208:"channel pressure", 224:"pitch bend", 240:"system", 242:"Song pos", 243:"Song select", 246:"Tune request", 248:"time tick", 250:"Start Song", 251:"Continue Song", 252:"Stop Song", 254:"Sensing", 255:"Reset"};
+ f.input = null;
+ f.MIDIEvent = e;
+ f.prototype.onMIDISuccess = function(a) {
+ console.log("MIDI ready!");
+ console.log(a);
+ this.midi = a;
+ this.updatePorts();
+ if (this.on_ready) {
+ this.on_ready(this);
+ }
+ };
+ f.prototype.updatePorts = function() {
+ var a = this.midi;
+ this.input_ports = a.inputs;
+ for (var b = 0, d = this.input_ports.values(), c = d.next(); c && !1 === c.done;) {
+ c = c.value, console.log("Input port [type:'" + c.type + "'] id:'" + c.id + "' manufacturer:'" + c.manufacturer + "' name:'" + c.name + "' version:'" + c.version + "'"), b++, c = d.next();
+ }
+ this.num_input_ports = b;
+ b = 0;
+ this.output_ports = a.outputs;
+ d = this.output_ports.values();
+ for (c = d.next(); c && !1 === c.done;) {
+ c = c.value, console.log("Output port [type:'" + c.type + "'] id:'" + c.id + "' manufacturer:'" + c.manufacturer + "' name:'" + c.name + "' version:'" + c.version + "'"), b++, c = d.next();
+ }
+ this.num_output_ports = b;
+ };
+ f.prototype.onMIDIFailure = function(a) {
+ console.error("Failed to get MIDI access - " + a);
+ };
+ f.prototype.openInputPort = function(a, b) {
+ a = this.input_ports.get("input-" + a);
+ if (!a) {
+ return !1;
+ }
+ f.input = this;
+ var c = this;
+ a.onmidimessage = function(a) {
+ var d = new e(a.data);
+ c.updateState(d);
+ b && b(a.data, d);
+ if (f.on_message) {
+ f.on_message(a.data, d);
+ }
+ };
+ console.log("port open: ", a);
+ return !0;
+ };
+ f.parseMsg = function(a) {
+ };
+ f.prototype.updateState = function(a) {
+ switch(a.cmd) {
+ case e.NOTEON:
+ this.state.note[a.value1 | 0] = a.value2;
+ break;
+ case e.NOTEOFF:
+ this.state.note[a.value1 | 0] = 0;
+ break;
+ case e.CONTROLLERCHANGE:
+ this.state.cc[a.getCC()] = a.getCCValue();
+ }
+ };
+ f.prototype.sendMIDI = function(a, b) {
+ b && (a = this.output_ports.get("output-" + a)) && (f.output = this, b.constructor === e ? a.send(b.data) : a.send(b));
+ };
+ g.MIDIInterface = f;
+ g.title = "MIDI Input";
+ g.desc = "Reads MIDI from a input port";
+ g.prototype.getPropertyInfo = function(a) {
+ if (this._midi && "port" == a) {
+ a = {};
+ for (var b = 0; b < this._midi.input_ports.size; ++b) {
+ var c = this._midi.input_ports.get("input-" + b);
+ a[b] = b + ".- " + c.name + " version:" + c.version;
+ }
+ return {type:"enum", values:a};
+ }
+ };
+ g.prototype.onStart = function() {
+ this._midi ? this._midi.openInputPort(this.properties.port, this.onMIDIEvent.bind(this)) : this._waiting = !0;
+ };
+ g.prototype.onMIDIEvent = function(a, b) {
+ this._last_midi_event = b;
+ this.trigger("on_midi", b);
+ b.cmd == e.NOTEON ? this.trigger("on_noteon", b) : b.cmd == e.NOTEOFF ? this.trigger("on_noteoff", b) : b.cmd == e.CONTROLLERCHANGE ? this.trigger("on_cc", b) : b.cmd == e.PROGRAMCHANGE ? this.trigger("on_pc", b) : b.cmd == e.PITCHBEND && this.trigger("on_pitchbend", b);
+ };
+ g.prototype.onExecute = function() {
+ if (this.outputs) {
+ for (var a = this._last_midi_event, b = 0; b < this.outputs.length; ++b) {
+ switch(this.outputs[b].name) {
+ case "midi":
+ var c = this._midi;
+ break;
+ case "last_midi":
+ c = a;
+ break;
+ default:
+ continue;
+ }
+ this.setOutputData(b, c);
+ }
+ }
+ };
+ g.prototype.onGetOutputs = function() {
+ return [["last_midi", "midi"], ["on_midi", LiteGraph.EVENT], ["on_noteon", LiteGraph.EVENT], ["on_noteoff", LiteGraph.EVENT], ["on_cc", LiteGraph.EVENT], ["on_pc", LiteGraph.EVENT], ["on_pitchbend", LiteGraph.EVENT]];
+ };
+ LiteGraph.registerNodeType("midi/input", g);
+ l.MIDIInterface = f;
+ l.title = "MIDI Output";
+ l.desc = "Sends MIDI to output channel";
+ l.prototype.getPropertyInfo = function(a) {
+ if (this._midi && "port" == a) {
+ a = {};
+ for (var b = 0; b < this._midi.output_ports.size; ++b) {
+ var c = this._midi.output_ports.get(b);
+ a[b] = b + ".- " + c.name + " version:" + c.version;
+ }
+ return {type:"enum", values:a};
+ }
+ };
+ l.prototype.onAction = function(a, b) {
+ console.log(b);
+ this._midi && ("send" == a && this._midi.sendMIDI(this.port, b), this.trigger("midi", b));
+ };
+ l.prototype.onGetInputs = function() {
+ return [["send", LiteGraph.ACTION]];
+ };
+ l.prototype.onGetOutputs = function() {
+ return [["on_midi", LiteGraph.EVENT]];
+ };
+ LiteGraph.registerNodeType("midi/output", l);
+ k.title = "MIDI Show";
+ k.desc = "Shows MIDI in the graph";
+ k.prototype.onAction = function(a, b) {
+ b && (this._str = b.constructor === e ? b.toString() : "???");
+ };
+ k.prototype.onDrawForeground = function(a) {
+ this._str && (a.font = "30px Arial", a.fillText(this._str, 10, 0.8 * this.size[1]));
+ };
+ k.prototype.onGetInputs = function() {
+ return [["in", LiteGraph.ACTION]];
+ };
+ k.prototype.onGetOutputs = function() {
+ return [["on_midi", LiteGraph.EVENT]];
+ };
+ LiteGraph.registerNodeType("midi/show", k);
+ a.title = "MIDI Filter";
+ a.desc = "Filters MIDI messages";
+ a.prototype.onAction = function(a, b) {
+ !b || b.constructor !== e || -1 != this.properties.channel && b.channel != this.properties.channel || -1 != this.properties.cmd && b.cmd != this.properties.cmd || -1 != this.properties.min_value && b.data[1] < this.properties.min_value || -1 != this.properties.max_value && b.data[1] > this.properties.max_value || this.trigger("on_midi", b);
+ };
+ LiteGraph.registerNodeType("midi/filter", a);
+ b.title = "MIDIEvent";
+ b.desc = "Create a MIDI Event";
+ b.prototype.onAction = function(a, b) {
+ "assign" == a ? (this.properties.channel = b.channel, this.properties.cmd = b.cmd, this.properties.value1 = b.data[1], this.properties.value2 = b.data[2]) : (b = new e, b.channel = this.properties.channel, this.properties.cmd && this.properties.cmd.constructor === String ? b.setCommandFromString(this.properties.cmd) : b.cmd = this.properties.cmd, b.data[0] = b.cmd | b.channel, b.data[1] = Number(this.properties.value1), b.data[2] = Number(this.properties.value2), this.trigger("on_midi", b));
+ };
+ b.prototype.onExecute = function() {
+ var a = this.properties;
+ if (this.outputs) {
+ for (var b = 0; b < this.outputs.length; ++b) {
+ switch(this.outputs[b].name) {
+ case "midi":
+ var c = new e;
+ c.setup([a.cmd, a.value1, a.value2]);
+ c.channel = a.channel;
+ break;
+ case "command":
+ c = a.cmd;
+ break;
+ case "cc":
+ c = a.value1;
+ break;
+ case "cc_value":
+ c = a.value2;
+ break;
+ case "note":
+ c = a.cmd == e.NOTEON || a.cmd == e.NOTEOFF ? a.value1 : null;
+ break;
+ case "velocity":
+ c = a.cmd == e.NOTEON ? a.value2 : null;
+ break;
+ case "pitch":
+ c = a.cmd == e.NOTEON ? e.computePitch(a.value1) : null;
+ break;
+ case "pitchbend":
+ c = a.cmd == e.PITCHBEND ? e.computePitchBend(a.value1, a.value2) : null;
+ break;
+ default:
+ continue;
+ }
+ null !== c && this.setOutputData(b, c);
+ }
+ }
+ };
+ b.prototype.onPropertyChanged = function(a, b) {
+ "cmd" == a && (this.properties.cmd = e.computeCommandFromString(b));
+ };
+ b.prototype.onGetOutputs = function() {
+ return [["midi", "midi"], ["on_midi", LiteGraph.EVENT], ["command", "number"], ["note", "number"], ["velocity", "number"], ["cc", "number"], ["cc_value", "number"], ["pitch", "number"], ["pitchbend", "number"]];
+ };
+ LiteGraph.registerNodeType("midi/event", b);
+ d.title = "MIDICC";
+ d.desc = "gets a Controller Change";
+ d.prototype.onExecute = function() {
+ f.input && (this.properties.value = f.input.state.cc[this.properties.cc]);
+ this.setOutputData(0, this.properties.value);
+ };
+ LiteGraph.registerNodeType("midi/cc", d);
+})(window);
+(function(c) {
+ function e() {
+ this.properties = {src:"", gain:0.5, loop:!0, autoplay:!0, playbackRate:1};
+ this._loading_audio = !1;
+ this._audiobuffer = null;
+ this._audionodes = [];
+ this._last_sourcenode = null;
+ this.addOutput("out", "audio");
+ this.addInput("gain", "number");
+ this.audionode = p.getAudioContext().createGain();
+ this.audionode.graphnode = this;
+ this.audionode.gain.value = this.properties.gain;
+ this.properties.src && this.loadSound(this.properties.src);
+ }
+ function f() {
+ this.properties = {fftSize:2048, minDecibels:-100, maxDecibels:-10, smoothingTimeConstant:0.5};
+ this.audionode = p.getAudioContext().createAnalyser();
+ this.audionode.graphnode = this;
+ this.audionode.fftSize = this.properties.fftSize;
+ this.audionode.minDecibels = this.properties.minDecibels;
+ this.audionode.maxDecibels = this.properties.maxDecibels;
+ this.audionode.smoothingTimeConstant = this.properties.smoothingTimeConstant;
+ this.addInput("in", "audio");
+ this.addOutput("freqs", "array");
+ this.addOutput("samples", "array");
+ this._time_bin = this._freq_bin = null;
+ }
+ function g() {
+ this.properties = {gain:1};
+ this.audionode = p.getAudioContext().createGain();
+ this.addInput("in", "audio");
+ this.addInput("gain", "number");
+ this.addOutput("out", "audio");
+ }
+ function l() {
+ this.properties = {impulse_src:"", normalize:!0};
+ this.audionode = p.getAudioContext().createConvolver();
+ this.addInput("in", "audio");
+ this.addOutput("out", "audio");
+ }
+ function k() {
+ this.properties = {threshold:-50, knee:40, ratio:12, reduction:-20, attack:0, release:0.25};
+ this.audionode = p.getAudioContext().createDynamicsCompressor();
+ this.addInput("in", "audio");
+ this.addOutput("out", "audio");
+ }
+ function a() {
+ this.properties = {};
+ this.audionode = p.getAudioContext().createWaveShaper();
+ this.addInput("in", "audio");
+ this.addInput("shape", "waveshape");
+ this.addOutput("out", "audio");
+ }
+ function b() {
+ this.properties = {gain1:0.5, gain2:0.5};
+ this.audionode = p.getAudioContext().createGain();
+ this.audionode1 = p.getAudioContext().createGain();
+ this.audionode1.gain.value = this.properties.gain1;
+ this.audionode2 = p.getAudioContext().createGain();
+ this.audionode2.gain.value = this.properties.gain2;
+ this.audionode1.connect(this.audionode);
+ this.audionode2.connect(this.audionode);
+ this.addInput("in1", "audio");
+ this.addInput("in1 gain", "number");
+ this.addInput("in2", "audio");
+ this.addInput("in2 gain", "number");
+ this.addOutput("out", "audio");
+ }
+ function d() {
+ this.properties = {delayTime:0.5};
+ this.audionode = p.getAudioContext().createDelay(10);
+ this.audionode.delayTime.value = this.properties.delayTime;
+ this.addInput("in", "audio");
+ this.addInput("time", "number");
+ this.addOutput("out", "audio");
+ }
+ function h() {
+ this.properties = {frequency:350, detune:0, Q:1};
+ this.addProperty("type", "lowpass", "enum", {values:"lowpass highpass bandpass lowshelf highshelf peaking notch allpass".split(" ")});
+ this.audionode = p.getAudioContext().createBiquadFilter();
+ this.addInput("in", "audio");
+ this.addOutput("out", "audio");
+ }
+ function n() {
+ this.properties = {frequency:440, detune:0, type:"sine"};
+ this.addProperty("type", "sine", "enum", {values:["sine", "square", "sawtooth", "triangle", "custom"]});
+ this.audionode = p.getAudioContext().createOscillator();
+ this.addOutput("out", "audio");
+ }
+ function v() {
+ this.properties = {continuous:!0, mark:-1};
+ this.addInput("data", "array");
+ this.addInput("mark", "number");
+ this.size = [300, 200];
+ this._last_buffer = null;
+ }
+ function u() {
+ this.properties = {band:440, amplitude:1};
+ this.addInput("freqs", "array");
+ this.addOutput("signal", "number");
+ }
+ function r() {
+ if (!r.default_code) {
+ var a = r.default_function.toString(), b = a.indexOf("{") + 1, c = a.lastIndexOf("}");
+ r.default_code = a.substr(b, c - b);
+ }
+ this.properties = {code:r.default_code};
+ a = p.getAudioContext();
+ a.createScriptProcessor ? this.audionode = a.createScriptProcessor(4096, 1, 1) : (console.warn("ScriptProcessorNode deprecated"), this.audionode = a.createGain());
+ this.processCode();
+ r._bypass_function || (r._bypass_function = this.audionode.onaudioprocess);
+ this.addInput("in", "audio");
+ this.addOutput("out", "audio");
+ }
+ function t() {
+ this.audionode = p.getAudioContext().destination;
+ this.addInput("in", "audio");
+ }
+ var p = {};
+ c.LGAudio = p;
+ p.getAudioContext = function() {
+ if (!this._audio_context) {
+ window.AudioContext = window.AudioContext || window.webkitAudioContext;
+ if (!window.AudioContext) {
+ return console.error("AudioContext not supported by browser"), null;
+ }
+ this._audio_context = new AudioContext;
+ this._audio_context.onmessage = function(a) {
+ console.log("msg", a);
+ };
+ this._audio_context.onended = function(a) {
+ console.log("ended", a);
+ };
+ this._audio_context.oncomplete = function(a) {
+ console.log("complete", a);
+ };
+ }
+ return this._audio_context;
+ };
+ p.connect = function(a, b) {
+ try {
+ a.connect(b);
+ } catch (y) {
+ console.warn("LGraphAudio:", y);
+ }
+ };
+ p.disconnect = function(a, b) {
+ try {
+ a.disconnect(b);
+ } catch (y) {
+ console.warn("LGraphAudio:", y);
+ }
+ };
+ p.changeAllAudiosConnections = function(a, b) {
+ if (a.inputs) {
+ for (var c = 0; c < a.inputs.length; ++c) {
+ var d = a.graph.links[a.inputs[c].link];
+ if (d) {
+ var e = a.graph.getNodeById(d.origin_id);
+ e = e.getAudioNodeInOutputSlot ? e.getAudioNodeInOutputSlot(d.origin_slot) : e.audionode;
+ d = a.getAudioNodeInInputSlot ? a.getAudioNodeInInputSlot(c) : a.audionode;
+ b ? p.connect(e, d) : p.disconnect(e, d);
+ }
+ }
+ }
+ if (a.outputs) {
+ for (c = 0; c < a.outputs.length; ++c) {
+ for (var f = a.outputs[c], g = 0; g < f.links.length; ++g) {
+ if (d = a.graph.links[f.links[g]]) {
+ e = a.getAudioNodeInOutputSlot ? a.getAudioNodeInOutputSlot(c) : a.audionode;
+ var h = a.graph.getNodeById(d.target_id);
+ d = h.getAudioNodeInInputSlot ? h.getAudioNodeInInputSlot(d.target_slot) : h.audionode;
+ b ? p.connect(e, d) : p.disconnect(e, d);
+ }
+ }
+ }
+ }
+ };
+ p.onConnectionsChange = function(a, b, c, d) {
+ a == LiteGraph.OUTPUT && (a = null, d && (a = this.graph.getNodeById(d.target_id)), a && (b = this.getAudioNodeInOutputSlot ? this.getAudioNodeInOutputSlot(b) : this.audionode, d = a.getAudioNodeInInputSlot ? a.getAudioNodeInInputSlot(d.target_slot) : a.audionode, c ? p.connect(b, d) : p.disconnect(b, d)));
+ };
+ p.createAudioNodeWrapper = function(a) {
+ var b = a.prototype.onPropertyChanged;
+ a.prototype.onPropertyChanged = function(a, c) {
+ b && b.call(this, a, c);
+ this.audionode && void 0 !== this.audionode[a] && (void 0 !== this.audionode[a].value ? this.audionode[a].value = c : this.audionode[a] = c);
+ };
+ a.prototype.onConnectionsChange = p.onConnectionsChange;
+ };
+ p.cached_audios = {};
+ p.loadSound = function(a, b, c) {
+ function d(a) {
+ console.log("Audio loading sample error:", a);
+ c && c(a);
+ }
+ if (p.cached_audios[a] && -1 == a.indexOf("blob:")) {
+ b && b(p.cached_audios[a]);
+ } else {
+ p.onProcessAudioURL && (a = p.onProcessAudioURL(a));
+ var e = new XMLHttpRequest;
+ e.open("GET", a, !0);
+ e.responseType = "arraybuffer";
+ var f = p.getAudioContext();
+ e.onload = function() {
+ console.log("AudioSource loaded");
+ f.decodeAudioData(e.response, function(c) {
+ console.log("AudioSource decoded");
+ p.cached_audios[a] = c;
+ b && b(c);
+ }, d);
+ };
+ e.send();
+ return e;
+ }
+ };
+ e["@src"] = {widget:"resource"};
+ e.supported_extensions = ["wav", "ogg", "mp3"];
+ e.prototype.onAdded = function(a) {
+ if (a.status === LGraph.STATUS_RUNNING) {
+ this.onStart();
+ }
+ };
+ e.prototype.onStart = function() {
+ this._audiobuffer && this.properties.autoplay && this.playBuffer(this._audiobuffer);
+ };
+ e.prototype.onStop = function() {
+ this.stopAllSounds();
+ };
+ e.prototype.onPause = function() {
+ this.pauseAllSounds();
+ };
+ e.prototype.onUnpause = function() {
+ this.unpauseAllSounds();
+ };
+ e.prototype.onRemoved = function() {
+ this.stopAllSounds();
+ this._dropped_url && URL.revokeObjectURL(this._url);
+ };
+ e.prototype.stopAllSounds = function() {
+ for (var a = 0; a < this._audionodes.length; ++a) {
+ this._audionodes[a].started && (this._audionodes[a].started = !1, this._audionodes[a].stop());
+ }
+ this._audionodes.length = 0;
+ };
+ e.prototype.pauseAllSounds = function() {
+ p.getAudioContext().suspend();
+ };
+ e.prototype.unpauseAllSounds = function() {
+ p.getAudioContext().resume();
+ };
+ e.prototype.onExecute = function() {
+ if (this.inputs) {
+ for (var a = 0; a < this.inputs.length; ++a) {
+ var b = this.inputs[a];
+ if (null != b.link) {
+ var c = this.getInputData(a);
+ if (void 0 !== c) {
+ if ("gain" == b.name) {
+ this.audionode.gain.value = c;
+ } else {
+ if ("playbackRate" == b.name) {
+ for (this.properties.playbackRate = c, b = 0; b < this._audionodes.length; ++b) {
+ this._audionodes[b].playbackRate.value = c;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (this.outputs) {
+ for (a = 0; a < this.outputs.length; ++a) {
+ "buffer" == this.outputs[a].name && this._audiobuffer && this.setOutputData(a, this._audiobuffer);
+ }
+ }
+ };
+ e.prototype.onAction = function(a) {
+ this._audiobuffer && ("Play" == a ? this.playBuffer(this._audiobuffer) : "Stop" == a && this.stopAllSounds());
+ };
+ e.prototype.onPropertyChanged = function(a, b) {
+ if ("src" == a) {
+ this.loadSound(b);
+ } else {
+ if ("gain" == a) {
+ this.audionode.gain.value = b;
+ } else {
+ if ("playbackRate" == a) {
+ for (a = 0; a < this._audionodes.length; ++a) {
+ this._audionodes[a].playbackRate.value = b;
+ }
+ }
+ }
+ }
+ };
+ e.prototype.playBuffer = function(a) {
+ var b = this, c = p.getAudioContext().createBufferSource();
+ this._last_sourcenode = c;
+ c.graphnode = this;
+ c.buffer = a;
+ c.loop = this.properties.loop;
+ c.playbackRate.value = this.properties.playbackRate;
+ this._audionodes.push(c);
+ c.connect(this.audionode);
+ this._audionodes.push(c);
+ c.onended = function() {
+ b.trigger("ended");
+ var a = b._audionodes.indexOf(c);
+ -1 != a && b._audionodes.splice(a, 1);
+ };
+ c.started || (c.started = !0, c.start());
+ return c;
+ };
+ e.prototype.loadSound = function(a) {
+ var b = this;
+ this._request && (this._request.abort(), this._request = null);
+ this._audiobuffer = null;
+ this._loading_audio = !1;
+ a && (this._request = p.loadSound(a, function(a) {
+ this.boxcolor = LiteGraph.NODE_DEFAULT_BOXCOLOR;
+ b._audiobuffer = a;
+ b._loading_audio = !1;
+ if (b.graph && b.graph.status === LGraph.STATUS_RUNNING) {
+ b.onStart();
+ }
+ }), this._loading_audio = !0, this.boxcolor = "#AA4");
+ };
+ e.prototype.onConnectionsChange = p.onConnectionsChange;
+ e.prototype.onGetInputs = function() {
+ return [["playbackRate", "number"], ["Play", LiteGraph.ACTION], ["Stop", LiteGraph.ACTION]];
+ };
+ e.prototype.onGetOutputs = function() {
+ return [["buffer", "audiobuffer"], ["ended", LiteGraph.EVENT]];
+ };
+ e.prototype.onDropFile = function(a) {
+ this._dropped_url && URL.revokeObjectURL(this._dropped_url);
+ a = URL.createObjectURL(a);
+ this.properties.src = a;
+ this.loadSound(a);
+ this._dropped_url = a;
+ };
+ e.title = "Source";
+ e.desc = "Plays audio";
+ LiteGraph.registerNodeType("audio/source", e);
+ f.prototype.onPropertyChanged = function(a, b) {
+ this.audionode[a] = b;
+ };
+ f.prototype.onExecute = function() {
+ if (this.isOutputConnected(0)) {
+ var a = this.audionode.frequencyBinCount;
+ this._freq_bin && this._freq_bin.length == a || (this._freq_bin = new Uint8Array(a));
+ this.audionode.getByteFrequencyData(this._freq_bin);
+ this.setOutputData(0, this._freq_bin);
+ }
+ this.isOutputConnected(1) && (a = this.audionode.frequencyBinCount, this._time_bin && this._time_bin.length == a || (this._time_bin = new Uint8Array(a)), this.audionode.getByteTimeDomainData(this._time_bin), this.setOutputData(1, this._time_bin));
+ for (a = 1; a < this.inputs.length; ++a) {
+ var b = this.inputs[a];
+ if (null != b.link) {
+ var c = this.getInputData(a);
+ void 0 !== c && (this.audionode[b.name].value = c);
+ }
+ }
+ };
+ f.prototype.onGetInputs = function() {
+ return [["minDecibels", "number"], ["maxDecibels", "number"], ["smoothingTimeConstant", "number"]];
+ };
+ f.prototype.onGetOutputs = function() {
+ return [["freqs", "array"], ["samples", "array"]];
+ };
+ f.title = "Analyser";
+ f.desc = "Audio Analyser";
+ LiteGraph.registerNodeType("audio/analyser", f);
+ g.prototype.onExecute = function() {
+ if (this.inputs && this.inputs.length) {
+ for (var a = 1; a < this.inputs.length; ++a) {
+ var b = this.inputs[a], c = this.getInputData(a);
+ void 0 !== c && (this.audionode[b.name].value = c);
+ }
+ }
+ };
+ p.createAudioNodeWrapper(g);
+ g.title = "Gain";
+ g.desc = "Audio gain";
+ LiteGraph.registerNodeType("audio/gain", g);
+ p.createAudioNodeWrapper(l);
+ l.prototype.onRemove = function() {
+ this._dropped_url && URL.revokeObjectURL(this._dropped_url);
+ };
+ l.prototype.onPropertyChanged = function(a, b) {
+ "impulse_src" == a ? this.loadImpulse(b) : "normalize" == a && (this.audionode.normalize = b);
+ };
+ l.prototype.onDropFile = function(a) {
+ this._dropped_url && URL.revokeObjectURL(this._dropped_url);
+ this._dropped_url = URL.createObjectURL(a);
+ this.properties.impulse_src = this._dropped_url;
+ this.loadImpulse(this._dropped_url);
+ };
+ l.prototype.loadImpulse = function(a) {
+ var b = this;
+ this._request && (this._request.abort(), this._request = null);
+ this._impulse_buffer = null;
+ this._loading_impulse = !1;
+ a && (this._request = p.loadSound(a, function(a) {
+ b._impulse_buffer = a;
+ b.audionode.buffer = a;
+ console.log("Impulse signal set");
+ b._loading_impulse = !1;
+ }), this._loading_impulse = !0);
+ };
+ l.title = "Convolver";
+ l.desc = "Convolves the signal (used for reverb)";
+ LiteGraph.registerNodeType("audio/convolver", l);
+ p.createAudioNodeWrapper(k);
+ k.prototype.onExecute = function() {
+ if (this.inputs && this.inputs.length) {
+ for (var a = 1; a < this.inputs.length; ++a) {
+ var b = this.inputs[a];
+ if (null != b.link) {
+ var c = this.getInputData(a);
+ void 0 !== c && (this.audionode[b.name].value = c);
+ }
+ }
+ }
+ };
+ k.prototype.onGetInputs = function() {
+ return [["threshold", "number"], ["knee", "number"], ["ratio", "number"], ["reduction", "number"], ["attack", "number"], ["release", "number"]];
+ };
+ k.title = "DynamicsCompressor";
+ k.desc = "Dynamics Compressor";
+ LiteGraph.registerNodeType("audio/dynamicsCompressor", k);
+ a.prototype.onExecute = function() {
+ if (this.inputs && this.inputs.length) {
+ var a = this.getInputData(1);
+ void 0 !== a && (this.audionode.curve = a);
+ }
+ };
+ a.prototype.setWaveShape = function(a) {
+ this.audionode.curve = a;
+ };
+ p.createAudioNodeWrapper(a);
+ b.prototype.getAudioNodeInInputSlot = function(a) {
+ if (0 == a) {
+ return this.audionode1;
+ }
+ if (2 == a) {
+ return this.audionode2;
+ }
+ };
+ b.prototype.onPropertyChanged = function(a, b) {
+ "gain1" == a ? this.audionode1.gain.value = b : "gain2" == a && (this.audionode2.gain.value = b);
+ };
+ b.prototype.onExecute = function() {
+ if (this.inputs && this.inputs.length) {
+ for (var a = 1; a < this.inputs.length; ++a) {
+ var b = this.inputs[a];
+ null != b.link && "audio" != b.type && (b = this.getInputData(a), void 0 !== b && (1 == a ? this.audionode1.gain.value = b : 3 == a && (this.audionode2.gain.value = b)));
+ }
+ }
+ };
+ p.createAudioNodeWrapper(b);
+ b.title = "Mixer";
+ b.desc = "Audio mixer";
+ LiteGraph.registerNodeType("audio/mixer", b);
+ p.createAudioNodeWrapper(d);
+ d.prototype.onExecute = function() {
+ var a = this.getInputData(1);
+ void 0 !== a && (this.audionode.delayTime.value = a);
+ };
+ d.title = "Delay";
+ d.desc = "Audio delay";
+ LiteGraph.registerNodeType("audio/delay", d);
+ h.prototype.onExecute = function() {
+ if (this.inputs && this.inputs.length) {
+ for (var a = 1; a < this.inputs.length; ++a) {
+ var b = this.inputs[a];
+ if (null != b.link) {
+ var c = this.getInputData(a);
+ void 0 !== c && (this.audionode[b.name].value = c);
+ }
+ }
+ }
+ };
+ h.prototype.onGetInputs = function() {
+ return [["frequency", "number"], ["detune", "number"], ["Q", "number"]];
+ };
+ p.createAudioNodeWrapper(h);
+ h.title = "BiquadFilter";
+ h.desc = "Audio filter";
+ LiteGraph.registerNodeType("audio/biquadfilter", h);
+ n.prototype.onStart = function() {
+ this.audionode.started || (this.audionode.started = !0, this.audionode.start());
+ };
+ n.prototype.onStop = function() {
+ this.audionode.started && (this.audionode.started = !1, this.audionode.stop());
+ };
+ n.prototype.onPause = function() {
+ this.onStop();
+ };
+ n.prototype.onUnpause = function() {
+ this.onStart();
+ };
+ n.prototype.onExecute = function() {
+ if (this.inputs && this.inputs.length) {
+ for (var a = 0; a < this.inputs.length; ++a) {
+ var b = this.inputs[a];
+ if (null != b.link) {
+ var c = this.getInputData(a);
+ void 0 !== c && (this.audionode[b.name].value = c);
+ }
+ }
+ }
+ };
+ n.prototype.onGetInputs = function() {
+ return [["frequency", "number"], ["detune", "number"], ["type", "string"]];
+ };
+ p.createAudioNodeWrapper(n);
+ n.title = "Oscillator";
+ n.desc = "Oscillator";
+ LiteGraph.registerNodeType("audio/oscillator", n);
+ v.prototype.onExecute = function() {
+ this._last_buffer = this.getInputData(0);
+ var a = this.getInputData(1);
+ void 0 !== a && (this.properties.mark = a);
+ this.setDirtyCanvas(!0, !1);
+ };
+ v.prototype.onDrawForeground = function(a) {
+ if (this._last_buffer) {
+ var b = this._last_buffer, c = b.length / this.size[0], d = this.size[1];
+ a.fillStyle = "black";
+ a.fillRect(0, 0, this.size[0], this.size[1]);
+ a.strokeStyle = "white";
+ a.beginPath();
+ var e = 0;
+ if (this.properties.continuous) {
+ a.moveTo(e, d);
+ for (var f = 0; f < b.length; f += c) {
+ a.lineTo(e, d - b[f | 0] / 255 * d), e++;
+ }
+ } else {
+ for (f = 0; f < b.length; f += c) {
+ a.moveTo(e + 0.5, d), a.lineTo(e + 0.5, d - b[f | 0] / 255 * d), e++;
+ }
+ }
+ a.stroke();
+ 0 <= this.properties.mark && (b = p.getAudioContext().sampleRate / b.length, e = this.properties.mark / b * 2 / c, e >= this.size[0] && (e = this.size[0] - 1), a.strokeStyle = "red", a.beginPath(), a.moveTo(e, d), a.lineTo(e, 0), a.stroke());
+ }
+ };
+ v.title = "Visualization";
+ v.desc = "Audio Visualization";
+ LiteGraph.registerNodeType("audio/visualization", v);
+ u.prototype.onExecute = function() {
+ if (this._freqs = this.getInputData(0)) {
+ var a = this.properties.band, b = this.getInputData(1);
+ void 0 !== b && (a = b);
+ b = p.getAudioContext().sampleRate / this._freqs.length;
+ b = a / b * 2;
+ b >= this._freqs.length ? b = this._freqs[this._freqs.length - 1] : (a = b | 0, b -= a, b = this._freqs[a] * (1 - b) + this._freqs[a + 1] * b);
+ this.setOutputData(0, b / 255 * this.properties.amplitude);
+ }
+ };
+ u.prototype.onGetInputs = function() {
+ return [["band", "number"]];
+ };
+ u.title = "Signal";
+ u.desc = "extract the signal of some frequency";
+ LiteGraph.registerNodeType("audio/signal", u);
+ r.prototype.onAdded = function(a) {
+ a.status == LGraph.STATUS_RUNNING && (this.audionode.onaudioprocess = this._callback);
+ };
+ r["@code"] = {widget:"code"};
+ r.prototype.onStart = function() {
+ this.audionode.onaudioprocess = this._callback;
+ };
+ r.prototype.onStop = function() {
+ this.audionode.onaudioprocess = r._bypass_function;
+ };
+ r.prototype.onPause = function() {
+ this.audionode.onaudioprocess = r._bypass_function;
+ };
+ r.prototype.onUnpause = function() {
+ this.audionode.onaudioprocess = this._callback;
+ };
+ r.prototype.onExecute = function() {
+ };
+ r.prototype.onRemoved = function() {
+ this.audionode.onaudioprocess = r._bypass_function;
+ };
+ r.prototype.processCode = function() {
+ try {
+ this._script = new (new Function("properties", this.properties.code))(this.properties), this._old_code = this.properties.code, this._callback = this._script.onaudioprocess;
+ } catch (q) {
+ console.error("Error in onaudioprocess code", q), this._callback = r._bypass_function, this.audionode.onaudioprocess = this._callback;
+ }
+ };
+ r.prototype.onPropertyChanged = function(a, b) {
+ "code" == a && (this.properties.code = b, this.processCode(), this.graph && this.graph.status == LGraph.STATUS_RUNNING && (this.audionode.onaudioprocess = this._callback));
+ };
+ r.default_function = function() {
+ this.onaudioprocess = function(a) {
+ var b = a.inputBuffer;
+ a = a.outputBuffer;
+ for (var c = 0; c < a.numberOfChannels; c++) {
+ for (var d = b.getChannelData(c), e = a.getChannelData(c), f = 0; f < b.length; f++) {
+ e[f] = d[f];
+ }
+ }
+ };
+ };
+ p.createAudioNodeWrapper(r);
+ r.title = "Script";
+ r.desc = "apply script to signal";
+ LiteGraph.registerNodeType("audio/script", r);
+ t.title = "Destination";
+ t.desc = "Audio output";
+ LiteGraph.registerNodeType("audio/destination", t);
+})(window);
+
+>>>>>>> 2cc2a410eb150720207034f5fb45b7bf8dd5b67d
diff --git a/build/package.json b/build/package.json
new file mode 100644
index 000000000..372fdec0f
--- /dev/null
+++ b/build/package.json
@@ -0,0 +1,9 @@
+{
+ "version": "0.2.1",
+ "name": "litegraph.js",
+ "main": "litegraph.js",
+ "description": "A graph node editor similar to PD or UDK Blueprints, it works in a HTML5 Canvas and allow to exported graphs to be included in applications.",
+ "author": "jagenjo",
+ "license": "MIT",
+ "scripts": {}
+}
\ No newline at end of file
diff --git a/gruntfile.js b/gruntfile.js
new file mode 100644
index 000000000..490c9fbde
--- /dev/null
+++ b/gruntfile.js
@@ -0,0 +1,82 @@
+module.exports = function (grunt) {
+ grunt.initConfig({
+ pkg: grunt.file.readJSON('package.json'),
+ projectFiles: ['src/litegraph.js',
+ 'src/nodes/base.js',
+ 'src/nodes/events.js',
+ 'src/nodes/interface.js',
+ 'src/nodes/input.js',
+ 'src/nodes/math.js',
+ 'src/nodes/logic.js',
+ 'src/nodes/image.js',
+ 'src/nodes/gltextures.js',
+ 'src/nodes/glfx.js',
+ 'src/nodes/midi.js',
+ 'src/nodes/audio.js'
+ ],
+ concat: {
+ build: {
+ src: '<%= projectFiles %>',
+ dest: 'build/litegraph.js'
+ }
+ },
+ copy: {
+ parts: {
+ files: [
+ {
+ expand: true,
+ flatten: true,
+ cwd: '',
+ src: ['README.md'],
+ dest: 'build/'
+ }
+ ]
+ }
+ },
+ clean: {
+ build: {src: ['build/*']}
+ },
+ closureCompiler: {
+
+ options: {
+ compilerFile: 'node_modules/google-closure-compiler/compiler.jar',
+ compilerOpts: {
+ formatting: 'pretty_print',
+ warning_level: 'default'
+ },
+ d32: false, // will use 'java -client -d32 -jar compiler.jar'
+ TieredCompilation: false// will use 'java -server -XX:+TieredCompilation -jar compiler.jar',
+ // ,output_wrapper: '"var LiteGraph = (function(){%output% return LiteGraph;}).call(this);"' //* Make container for all
+ },
+ targetName: {
+ src: '<%= projectFiles %>',
+ dest: 'build/litegraph.min.js'
+ }
+ }
+ })
+
+ grunt.registerTask('buildPackage', function () {
+ var pkg = grunt.config.data.pkg
+ var newPackage = {
+ version: pkg.version,
+ name: 'litegraph.js', //* Static name without ogranisation
+ main: 'litegraph.js',
+ description: pkg.description,
+ dependencies: pkg.dependencies,
+ author: pkg.author,
+ license: 'MIT',
+ scripts: {
+
+ }
+ }
+
+ grunt.file.write('build/package.json', JSON.stringify(newPackage, undefined, 2))
+ })
+
+ grunt.loadNpmTasks('grunt-contrib-concat')
+ grunt.loadNpmTasks('grunt-contrib-copy')
+ grunt.loadNpmTasks('grunt-closure-tools')
+ grunt.loadNpmTasks('grunt-contrib-clean')
+
+ grunt.registerTask('build', ['buildPackage', 'copy:parts', 'concat:build', 'closureCompiler'])
+}
diff --git a/imgs/node_graph_example.PNG b/imgs/node_graph_example.PNG
new file mode 100644
index 000000000..37ef90b2c
Binary files /dev/null and b/imgs/node_graph_example.PNG differ
diff --git a/package.json b/package.json
new file mode 100644
index 000000000..bdd06735d
--- /dev/null
+++ b/package.json
@@ -0,0 +1,33 @@
+{
+ "name": "@skymaker/litegraph.js",
+ "version": "0.2.1",
+ "description": "A graph node editor similar to PD or UDK Blueprints, it works in a HTML5 Canvas and allow to exported graphs to be included in applications.",
+ "main": "build/litegraph.js",
+ "directories": {
+ "doc": "doc"
+ },
+ "private": false,
+ "scripts": {
+ "prebuild": "grunt clean:build",
+ "build": "grunt build",
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/jagenjo/litegraph.js.git"
+ },
+ "author": "jagenjo",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/jagenjo/litegraph.js/issues"
+ },
+ "homepage": "https://github.com/kriffe/litegraph.js#readme",
+ "devDependencies": {
+ "google-closure-compiler": "^20171112.0.0",
+ "grunt": "^1.0.1",
+ "grunt-closure-tools": "^1.0.0",
+ "grunt-contrib-clean": "^1.1.0",
+ "grunt-contrib-concat": "^1.0.1",
+ "grunt-contrib-copy": "^1.0.0"
+ }
+}
diff --git a/src/nodes/gltextures.js b/src/nodes/gltextures.js
index 0e58df322..d41dd21f2 100755
--- a/src/nodes/gltextures.js
+++ b/src/nodes/gltextures.js
@@ -1,7 +1,8 @@
//Works with Litegl.js to create WebGL nodes
+var LGraphTexture
if(typeof(LiteGraph) != "undefined")
{
- function LGraphTexture()
+ LGraphTexture = function()
{
this.addOutput("Texture","Texture");
this.properties = { name:"", filter: true };
diff --git a/src/nodes/image.js b/src/nodes/image.js
index 659776e3c..860cb2037 100755
--- a/src/nodes/image.js
+++ b/src/nodes/image.js
@@ -313,7 +313,7 @@ LiteGraph.registerNodeType("visualization/graph", {
function ImageFade()
{
this.addInputs([["img1","image"],["img2","image"],["fade","number"]]);
- this.addInput("","image");
+ this.addOutput("","image");
this.properties = {fade:0.5,width:512,height:512};
}
@@ -714,4 +714,4 @@ ImageWebcam.prototype.onDrawBackground = function(ctx)
LiteGraph.registerNodeType("graphics/webcam", ImageWebcam );
-})();
\ No newline at end of file
+})();