@cjcoding-git/gamelib 0.0.0-stage → 1.1.3

package/src/3D/Material.js

@@ -0,0 +1,181 @@
+import { GameLibCore } from "../Core/index.js"
+import GL1Vertex from "../Shaders/Material/Vertex/GL1.glsl"
+import GL1Fragment from "../Shaders/Material/Fragment/GL1.glsl"
+import GL2Vertex from "../Shaders/Material/Vertex/GL2.glsl"
+import GL2Fragment from "../Shaders/Material/Fragment/GL2.glsl"
+class Material {
+  constructor(gameLib, shader = null) {
+    if (!gameLib) {
+      throw new GameLibCore.Error("Constructing a Material requires a GameLib instance.");
+    }
+    this.gameLib = gameLib;
+    this.program = shader;
+    this.hasColor = false;
+    this.color = null;
+    this.gradient = null;
+    this.texture = null;
+    this.textureUnit = 0;
+    this.uniforms = {};
+  }
+  static webGL1VertexShader = GL1Vertex;
+  static webGL1FragmentShader = GL1Fragment;
+  static webGL2VertexShader = GL2Vertex;
+  static webGL2FragmentShader = GL2Fragment;
+  static get standardVertexShader() {
+    return Material.webGL1VertexShader;
+  }
+  static get standardFragmentShader() {
+    return Material.webGL1FragmentShader;
+  }
+  static normalizeColor(color) {
+    if (!Array.isArray(color)) {
+      return [ 1.0, 1.0, 1.0, 1.0 ];
+    }
+    if (color.length === 3) {
+      return [ color[0], color[1], color[2], 1.0 ];
+    }
+    if (color.length >= 4) {
+      return [ color[0], color[1], color[2], color[3] ];
+    }
+    return [ 1.0, 1.0, 1.0, 1.0 ];
+  }
+  static interpolate(a, b, t) {
+    return a + (b - a) * t;
+  }
+  static createStandardProgram(gameLib) {
+    if (!gameLib || !gameLib.webgl) {
+      throw new GameLibCore.Error("Material.createStandardProgram(gameLib) requires a GameLib instance with a WebGL context.");
+    }
+    var webgl = gameLib.webgl;
+    var isWebGL2 = !gameLib.options || gameLib.options.webGL2 !== false;
+    var vertexSource = isWebGL2 ? Material.webGL2VertexShader : Material.webGL1VertexShader;
+    var fragmentSource = isWebGL2 ? Material.webGL2FragmentShader : Material.webGL1FragmentShader;
+    var vertexShader = gameLib.compileShader(webgl.VERTEX_SHADER, vertexSource);
+    var fragmentShader = gameLib.compileShader(webgl.FRAGMENT_SHADER, fragmentSource);
+    if (!vertexShader || !fragmentShader) {
+      console.warn("[GameLib] Standard material shader compilation failed.");
+      return null;
+    }
+    var program = gameLib.createProgram(vertexShader, fragmentShader);
+    if (!program) {
+      console.warn("[GameLib] Standard material shader linking failed.");
+      return null;
+    }
+    return program;
+  }
+  static getDefaultProgram(gameLib) {
+    return Material.createStandardProgram(gameLib);
+  }
+  ensureProgram(gameLib = this.gameLib) {
+    if (!this.program && gameLib) {
+      this.program = Material.createStandardProgram(gameLib);
+    }
+    return this.program;
+  }
+  setColor(color) {
+    this.color = Material.normalizeColor(color);
+    this.hasColor = true;
+    this.gradient = null;
+    return this;
+  }
+  setTexture(texture) {
+    this.texture = texture;
+    return this;
+  }
+  setGradient(stops, options = {}) {
+    if (!Array.isArray(stops) || stops.length === 0) {
+      this.gradient = null;
+      return this;
+    }
+    this.gradient = {
+      source: options.source || "uv",
+      axis: options.axis || "y",
+      stops: stops
+        .map((stop) => {
+          if (!Array.isArray(stop) || stop.length < 2) {
+            return null;
+          }
+          return [ Number(stop[0]), Material.normalizeColor(stop[1]) ];
+        })
+        .filter(Boolean)
+        .sort((a, b) => a[0] - b[0])
+    };
+    if (this.gradient.stops.length === 0) {
+      this.gradient = null;
+      return this;
+    }
+    this.hasColor = true;
+    this.color = null;
+    return this;
+  }
+  interpolateGradient(value) {
+    if (!this.gradient || this.gradient.stops.length === 0) {
+      return [ 1.0, 1.0, 1.0, 1.0 ];
+    }
+    var stops = this.gradient.stops;
+    if (value <= stops[0][0]) {
+      return stops[0][1];
+    }
+    for (var i = 0; i < stops.length - 1; i++) {
+      var current = stops[i];
+      var next = stops[i + 1];
+      if (value >= current[0] && value <= next[0]) {
+        var t = (value - current[0]) / (next[0] - current[0] || 1);
+        return [
+          Material.interpolate(current[1][0], next[1][0], t),
+          Material.interpolate(current[1][1], next[1][1], t),
+          Material.interpolate(current[1][2], next[1][2], t),
+          Material.interpolate(current[1][3], next[1][3], t)
+        ];
+      }
+    }
+    return stops[stops.length - 1][1];
+  }
+  getVertexColors(geometry) {
+    var vertexCount = Math.max(1, Math.floor((geometry.positions?.length || 0) / 3));
+    var colors = [];
+    if (!this.hasColor && !this.gradient) {
+      for (var i = 0; i < vertexCount; i++) {
+        colors.push(1.0, 1.0, 1.0, 1.0);
+      }
+      return new Float32Array(colors);
+    }
+    if (this.gradient) {
+      var axis = (this.gradient.axis || "y").toLowerCase();
+      var source = (this.gradient.source || "uv").toLowerCase();
+      var axisIndex = axis === "x" ? 0 : axis === "z" ? 2 : 1;
+      var coordinates = [];
+      if (source === "position" && Array.isArray(geometry.positions)) {
+        for (var i = 0; i < vertexCount; i++) {
+          coordinates.push(geometry.positions[i * 3 + axisIndex]);
+        }
+      } else if (Array.isArray(geometry.uv)) {
+        var uvIndex = axis === "x" ? 0 : 1;
+        for (var i = 0; i < vertexCount; i++) {
+          coordinates.push(geometry.uv[i * 2 + uvIndex] ?? 0.5);
+        }
+      } else if (Array.isArray(geometry.positions)) {
+        for (var i = 0; i < vertexCount; i++) {
+          coordinates.push(geometry.positions[i * 3 + axisIndex]);
+        }
+      } else {
+        for (var i = 0; i < vertexCount; i++) {
+          coordinates.push(0.5);
+        }
+      }
+      for (var i = 0; i < vertexCount; i++) {
+        var color = this.interpolateGradient(coordinates[i]);
+        colors.push(color[0], color[1], color[2], color[3]);
+      }
+      return new Float32Array(colors);
+    }
+    var baseColor = Material.normalizeColor(this.color || [ 1.0, 1.0, 1.0, 1.0 ]);
+    for (var i = 0; i < vertexCount; i++) {
+      colors.push(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+    }
+    return new Float32Array(colors);
+  }
+}
+export {
+  Material
+}

package/src/3D/Mesh.js

@@ -0,0 +1,142 @@
+import { Object } from "./Object.js"
+import { Transform } from "./Transform.js"
+import { mat4 } from "../Core/Matrix/mat4.js"
+class Mesh extends Object {
+  constructor(gameLib, scene, geometryData, material) {
+    super(gameLib, scene);
+    this.transform = new Transform();
+    this.material = material;
+    this.geometry = geometryData;
+    this.buffers = {};
+  }
+  setup() {
+    var webgl = this._gl;
+    var program = this.material.ensureProgram(this._gameLib);
+    if (program) {
+      this._gameLib.useProgram(program);
+    }
+    this.buffers.position = webgl.createBuffer();
+    webgl.bindBuffer(webgl.ARRAY_BUFFER, this.buffers.position);
+    webgl.bufferData(webgl.ARRAY_BUFFER, new Float32Array(this.geometry.positions), webgl.STATIC_DRAW);
+    this.buffers.normal = webgl.createBuffer();
+    webgl.bindBuffer(webgl.ARRAY_BUFFER, this.buffers.normal);
+    webgl.bufferData(webgl.ARRAY_BUFFER, new Float32Array(this.geometry.normals), webgl.STATIC_DRAW);
+    this.buffers.uv = webgl.createBuffer();
+    webgl.bindBuffer(webgl.ARRAY_BUFFER, this.buffers.uv);
+    webgl.bufferData(webgl.ARRAY_BUFFER, new Float32Array(this.geometry.uv || []), webgl.STATIC_DRAW);
+    var colors = this.material.getVertexColors ? this.material.getVertexColors(this.geometry) : new Float32Array([]);
+    this.buffers.color = webgl.createBuffer();
+    webgl.bindBuffer(webgl.ARRAY_BUFFER, this.buffers.color);
+    webgl.bufferData(webgl.ARRAY_BUFFER, colors, webgl.STATIC_DRAW);
+    this.buffers.indices = webgl.createBuffer();
+    webgl.bindBuffer(webgl.ELEMENT_ARRAY_BUFFER, this.buffers.indices);
+    webgl.bufferData(webgl.ELEMENT_ARRAY_BUFFER, new Uint16Array(this.geometry.indices), webgl.STATIC_DRAW);
+    this.indexCount = this.geometry.indices.length;
+  }
+  draw(camera) {
+    var webgl = this._gl;
+    var materialProgram = this.material && this.material.ensureProgram && this.material.ensureProgram(this._gameLib);
+    if (!materialProgram) return;
+    this._gameLib.useProgram(materialProgram);
+    var aspect = webgl.canvas.clientWidth / webgl.canvas.clientHeight;
+    var projectionMatrix = camera.getProjectionMatrix(aspect);
+    var viewMatrix = camera.getViewMatrix();
+    var modelMatrix = this.transform.getModelMatrix();
+    var modelViewMatrix = mat4.create();
+    mat4.multiply(modelViewMatrix, viewMatrix, modelMatrix);
+    var normalMatrix = this.transform.getNormalMatrix(modelViewMatrix);
+    var uniform = name => this._gameLib.getAttributeLocation(materialProgram, name, "uniform");
+    this._gameLib.setProgramAttribute(materialProgram, "aVertexPosition", this.buffers.position, 3);
+    this._gameLib.setProgramAttribute(materialProgram, "aVertexNormal", this.buffers.normal, 3);
+    this._gameLib.setProgramAttribute(materialProgram, "aVertexColor", this.buffers.color, 4);
+    this._gameLib.setProgramAttribute(materialProgram, "aTextureCoord", this.buffers.uv, 2);
+    var useTextureLocation = uniform("uUseTexture");
+    if (useTextureLocation !== null) {
+      webgl.uniform1i(useTextureLocation, this.material.texture ? 1 : 0);
+    }
+    if (this.material.texture) {
+      var textureUnit = this.material.textureUnit || 0;
+      this.material.texture.bind(textureUnit);
+      var textureLocation = uniform("uTexture");
+      if (textureLocation !== null) {
+        webgl.uniform1i(textureLocation, textureUnit);
+      }
+    }
+    var projectionLocation = uniform("uProjectionMatrix");
+    if (projectionLocation !== null) {
+      webgl.uniformMatrix4fv(projectionLocation, false, projectionMatrix);
+    }
+    var modelViewLocation = uniform("uModelViewMatrix");
+    if (modelViewLocation !== null) {
+      webgl.uniformMatrix4fv(modelViewLocation, false, modelViewMatrix);
+    }
+    var normalLocation = uniform("uNormalMatrix");
+    if (normalLocation !== null) {
+      webgl.uniformMatrix4fv(normalLocation, false, normalMatrix);
+    }
+    var MAX_LIGHTS = 8;
+    var lights = this._gameLib.getLights(this.scene).slice(0, MAX_LIGHTS);
+    var lightTypes = [];
+    var lightColors = [];
+    var lightVectors = [];
+    var lightIntensities = [];
+    var lightRanges = [];
+    var getVector3 = (value) => {
+      if (Array.isArray(value)) return [value[0] || 0, value[1] || 0, value[2] || 0];
+      if (value && typeof value === "object") {
+        if (typeof value.x !== "undefined" && typeof value.y !== "undefined" && typeof value.z !== "undefined") {
+          return [value.x, value.y, value.z];
+        }
+      }
+      return [0, 0, 0];
+    };
+    for (var light of lights) {
+      var type = light.type === "ambient" ? 0 : light.type === "point" ? 2 : 1;
+      lightTypes.push(type);
+      var color = Array.isArray(light.color) ? light.color : [1, 1, 1];
+      lightColors.push(color[0] || 0, color[1] || 0, color[2] || 0);
+      lightIntensities.push(light.intensity || 0);
+      lightRanges.push(light.range || 1);
+      var source = type === 2 ? getVector3(light.position) : getVector3(light.direction || light.position);
+      var x = source[0];
+      var y = source[1];
+      var z = source[2];
+      if (type === 2) {
+        lightVectors.push(viewMatrix[0] * x + viewMatrix[4] * y + viewMatrix[8] * z + viewMatrix[12], viewMatrix[1] * x + viewMatrix[5] * y + viewMatrix[9] * z + viewMatrix[13], viewMatrix[2] * x + viewMatrix[6] * y + viewMatrix[10] * z + viewMatrix[14]);
+      } else {
+        lightVectors.push(viewMatrix[0] * x + viewMatrix[4] * y + viewMatrix[8] * z, viewMatrix[1] * x + viewMatrix[5] * y + viewMatrix[9] * z, viewMatrix[2] * x + viewMatrix[6] * y + viewMatrix[10] * z);
+      }
+    }
+    var lightCountLocation = uniform("uLightCount");
+    if (lightCountLocation !== null) {
+      webgl.uniform1i(lightCountLocation, lights.length);
+    }
+    if (lights.length > 0) {
+      var typeLocation = uniform("uLightType[0]");
+      if (typeLocation !== null) {
+        webgl.uniform1iv(typeLocation, new Int32Array(lightTypes));
+      }
+      var colorLocation = uniform("uLightColor[0]");
+      if (colorLocation !== null) {
+        webgl.uniform3fv(colorLocation, new Float32Array(lightColors));
+      }
+      var vectorLocation = uniform("uLightVector[0]");
+      if (vectorLocation !== null) {
+        webgl.uniform3fv(vectorLocation, new Float32Array(lightVectors));
+      }
+      var intensityLocation = uniform("uLightIntensity[0]");
+      if (intensityLocation !== null) {
+        webgl.uniform1fv(intensityLocation, new Float32Array(lightIntensities));
+      }
+      var rangeLocation = uniform("uLightRange[0]");
+      if (rangeLocation !== null) {
+        webgl.uniform1fv(rangeLocation, new Float32Array(lightRanges));
+      }
+    }
+    webgl.bindBuffer(webgl.ELEMENT_ARRAY_BUFFER, this.buffers.indices);
+    webgl.drawElements(webgl.TRIANGLES, this.indexCount, webgl.UNSIGNED_SHORT, 0);
+  }
+}
+export {
+  Mesh
+}

package/src/3D/Object.js

@@ -0,0 +1,13 @@
+class Object {
+  constructor(gameLib, scene) {
+    this._gameLib = gameLib;
+    this._gl = this._gameLib.webgl;
+    this.scene = scene;
+  }
+  setup() {}
+  update(camera) {}
+  draw(camera) {}
+}
+export {
+  Object
+}

package/src/3D/Position.js

@@ -0,0 +1,15 @@
+class Position {
+  constructor(x=0, y=0, z=0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  translate(dx, dy, dz) {
+    this.x += dx;
+    this.y += dy;
+    this.z += dz;
+  }
+}
+export {
+  Position
+}

package/src/3D/Rotation.js

@@ -0,0 +1,21 @@
+class Rotation {
+  constructor(x=0, y=0, z=0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  static d2r(deg) {
+    return (deg * Math.PI) / 180;
+  }
+  static r2d(rad) {
+    return rad * (180 / Math.PI);
+  }
+  rotate(rx, ry, rz) {
+    this.x += rx;
+    this.y += ry;
+    this.z += rz;
+  }
+}
+export {
+  Rotation
+}

package/src/3D/Scale.js

@@ -0,0 +1,10 @@
+class Scale {
+  constructor(x=1, y=1, z=1) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+}
+export {
+  Scale
+}

package/src/3D/ShaderFactory/FunctionParam.js

@@ -0,0 +1,14 @@
+import { Modifiers } from "./Modifiers/index.js"
+class FunctionParam {
+  constructor(type, name, modifiers) {
+    if(!modifiers || !(Modifiers.Variable)) modifiers = new Modifiers.Variable();
+    modifiers.update();
+    this._type = type;
+    this._name = name;
+    this._modifiers = modifiers;
+    this.text = `${this._modifiers.text}${this._type} ${this._name}`;
+  }
+}
+export {
+  FunctionParam
+}

package/src/3D/ShaderFactory/Modifiers/Variable.js

@@ -0,0 +1,85 @@
+import { GameLibCore } from "../../../Core/index.js"
+class Variable {
+  constructor({ input=false, output=false, uniform=false, attribute=false, varying=false, constant=false, precision=null } = {}) {
+    this._input = input;
+    this._output = output;
+    this._uniform = uniform;
+    this._attribute = attribute;
+    this._varying = varying;
+    this._constant = constant;
+    this._precision = precision;
+    this.text = null;
+    this.update();
+  }
+  update() {
+    var includeProps = [ "_input", "_output", "_uniform", "_attribute", "_varying" ];
+    var matchedProps = 0;
+    for(var i=0;i<includeProps.length;i++) {
+      var prop = includeProps[i];
+      if(this[prop]) matchedProps += 1;
+    }
+    if(matchedProps > 1) {
+      throw new GameLibCore.Error("Class GameLib3D.ShaderFactory.Modifiers.Variable has conflicting properties!");
+    }
+    this.text = "";
+    if(this._constant) this.text += "const ";
+    if(this._input) this.text += "in ";
+    if(this._output) this.text += "out ";
+    if(this._uniform) this.text += "uniform ";
+    if(this._attribute) this.text += "attribute ";
+    if(this._varying) this.text += "varying ";
+    if(this._precision) this.text += `${this._precision} `;
+  }
+  get input() {
+    return this._input;
+  }
+  set input(value) {
+    this._input = value;
+    this.update();
+  }
+  get output() {
+    return this._output;
+  }
+  set output(value) {
+    this._output = value;
+    this.update();
+  }
+  get uniform() {
+    return this._uniform;
+  }
+  set uniform(value) {
+    this._uniform = value;
+    this.update();
+  }
+  get attribute() {
+    return this._attribute;
+  }
+  set attribute(value) {
+    this._attribute = value;
+    this.update();
+  }
+  get varying() {
+    return this._varying;
+  }
+  set varying(value) {
+    this._varying = value;
+    this.update();
+  }
+  get constant() {
+    return this._constant;
+  }
+  set constant(value) {
+    this._constant = value;
+    this.update();
+  }
+  get precision() {
+    return this._precision;
+  }
+  set precision(value) {
+    this._precision = value;
+    this.update();
+  }
+}
+export {
+  Variable
+}

package/src/3D/ShaderFactory/Modifiers/index.js

@@ -0,0 +1,11 @@
+import { GameLibCore } from "../../../Core/index.js"
+import { Variable } from "./Variable.js"
+class Modifiers {
+  constructor() {
+      throw new GameLibCore.Error("Class GameLib3D.ShaderFactory.Modifiers may not be constructed!");
+  }
+  static Variable = Variable;
+}
+export {
+  Modifiers
+}

package/src/3D/ShaderFactory/Node.js

@@ -0,0 +1,25 @@
+import { GameLibCore } from "../../Core/index.js"
+class Node {
+  constructor() {
+    this.canHaveChildren = false;
+    this.canAddNode = false;
+    this.canAddVar = false;
+    this.canAddHeader = false;
+    this._nodes = [];
+    this._parent = null;
+    this.text = null;
+  }
+  addNode(node) {
+    if(!node.canAddNode) {
+      throw new GameLibCore.Error("Cannot add a GameLib3D.ShaderFactory.Node that has canAddNode set to false!");
+    }
+    if(!this.canHaveChildren) {
+      throw new GameLibCore.Error("Trying to add children to a GameLib3D.ShaderFactory.Node that cannot contain children!");
+    }
+    node._parent = this;
+    this._nodes.push(node);
+  }
+}
+export {
+  Node
+}

package/src/3D/ShaderFactory/NodeTypes/A.js

@@ -0,0 +1,9 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.A = class ANode extends Node {
+  constructor(value) {
+    super();
+    this._value = value;
+    this.text = `(${this._value.text}).a`;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Add.js

@@ -0,0 +1,13 @@
+import { NodeTypes } from  "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Add = class AddNode extends Node {
+  constructor(...values) {
+    super();
+    this._values = values;
+    var valueTexts = [];
+    for(var i=0;i<this._values.length;i++) {
+      valueTexts.push(this._values[i].text);
+    }
+    this.text = valueTexts.join(' + ');
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/AssignVariable.js

@@ -0,0 +1,11 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.AssignVariable = class AssignVariableNode extends Node {
+  constructor(target, node) {
+    super();
+    this._target = target;
+    this._node = node;
+    this.canAddNode = true;
+    this.text = `${this._target} = ${this._node.text};`;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Clamp.js

@@ -0,0 +1,14 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Clamp = class ClampNode extends Node {
+  constructor(...values) {
+    super();
+    this._values = values;
+    var valueTexts = [];
+    for(var i=0;i<this._values.length;i++) {
+      valueTexts.push(this._values[i].text);
+    }
+    var valuesText = valueTexts.join(', ');
+    this.text = `clamp(${valuesText})`;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Constant.js

@@ -0,0 +1,9 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Constant = class ConstantNode extends Node {
+  constructor(value) {
+    super();
+    this._value = value;
+    this.text = value;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Define.js

@@ -0,0 +1,11 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Define = class DefineNode extends Node {
+  constructor(name, value) {
+    super();
+    this.canAddNode = true;
+    this._name = name;
+    this._value = value;
+    this.text = `#define ${this._name} ${this._value.text}`;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Divide.js

@@ -0,0 +1,13 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Divide = class DivideNode extends Node {
+  constructor(...values) {
+    super();
+    this._values = values;
+    var valueTexts = [];
+    for(var i=0;i<this._values.length;i++) {
+      valueTexts.push(this._values[i].text);
+    }
+    this.text = valueTexts.join(' / ');
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Dot.js

@@ -0,0 +1,14 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Dot = class DotNode extends Node {
+  constructor(...values) {
+    super();
+    this._values = values;
+    var valueTexts = [];
+    for(var i=0;i<this._values.length;i++) {
+      valueTexts.push(this._values[i].text);
+    }
+    var valuesText = valueTexts.join(', ');
+    this.text = `dot(${valuesText})`;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Exp2.js

@@ -0,0 +1,9 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Exp2 = class Exp2Node extends Node {
+  constructor(value) {
+    super();
+    this._value = value;
+    this.text = `exp2(${this._value.text})`;
+  }
+};

package/src/3D/ShaderFactory/NodeTypes/Function.js

@@ -0,0 +1,36 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+import { GameLibCore } from "../../../Core/index.js"
+NodeTypes.Function = class FunctionNode extends Node {
+  constructor(type, name, params) {
+    super();
+    this.canAddNode = true;
+    this.canHaveChildren = true;
+    this._type = type;
+    this._name = name;
+    this._params = params;
+    var paramsText = this._params.join(', ');
+    this._startText = `${this._type} ${this._name}(${paramsText}) {\n`;
+    this._endText = "\n}";
+    this.update();
+  }
+  update() {
+    var nodeTexts = [];
+    for(var i=0;i<this._nodes.length;i++) {
+      nodeTexts.push(this._nodes[i].text);
+    }
+    var nodesText = nodeTexts.join("\n");
+    this.text = `${this._startText}${nodesText}${this._endText}`;
+  }
+  addNode(node) {
+    if(!node.canAddNode) {
+      throw new GameLibCore.Error("Cannot add a GameLib3D.ShaderFactory.Node that has canAddNode set to false!");
+    }
+    if(!this.canHaveChildren) {
+      throw new GameLibCore.Error("Trying to add children to a GameLib3D.ShaderFactory.Node that cannot contain children!");
+    }
+    node._parent = this;
+    this._nodes.push(node);
+    this.update();
+  }
+};