@cjcoding-git/gamelib 0.0.0-stage → 1.1.3

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

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

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

@@ -0,0 +1,12 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Header = class HeaderNode extends Node {
+  constructor(type, ...data) {
+    super();
+    this.canAddHeader = true;
+    this._type = type;
+    this._data = data;
+    var joinedData = this._data.join(' ');
+    this.text = `#${this._type} ${joinedData}`;
+  }
+};

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

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

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

@@ -0,0 +1,7 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { VariableTypes } from "../VariableTypes.js"
+NodeTypes.MainFunction = class MainFunctionNode extends NodeTypes.Function {
+  constructor() {
+    super(VariableTypes.VOID, "main", []);
+  }
+};

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

@@ -0,0 +1,14 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Max = class MaxNode 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 = `max(${valuesText})`;
+  }
+};

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

@@ -0,0 +1,14 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Mix = class MixNode 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 = `mix(${valuesText})`;
+  } 
+};

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

@@ -0,0 +1,13 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Multiply = class MultiplyNode 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/Negative.js

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

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

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

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

@@ -0,0 +1,10 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Normalize = class NormalizeNode extends Node {
+  constructor(value) {
+    super();
+    this._value = value;
+    var valueText = this._value.text;
+    this.text = `normalize(${valueText})`;
+  }
+};

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

@@ -0,0 +1,11 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Precision = class PrecisionNode extends Node {
+  constructor(type, precision) {
+    super();
+    this.canAddHeader = true;
+    this._type = type;
+    this._precision = precision;
+    this.text = `precision ${this._precision} ${this._type};`;
+  }
+};

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

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

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

@@ -0,0 +1,13 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Subtract = class SubtractNode 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/Symbol.js

@@ -0,0 +1,9 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Symbol = class SymbolNode extends Node {
+  constructor(name) {
+      super();
+      this._name = name;
+      this.text = name;
+  }
+};

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

@@ -0,0 +1,10 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Texture2D = class Texture2DNode extends Node {
+  constructor(value1, value2) {
+    super();
+    this._value1 = value1;
+    this._value2 = value2;
+    this.text = `texture2D(${value1.text}, ${value2.text})`;
+  }
+};

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

@@ -0,0 +1,22 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+import { Modifiers } from "../Modifiers/index.js"
+NodeTypes.Variable = class VariableNode extends Node {
+  constructor(type, name, modifiers=null, initialValue=null) {
+    super();
+    if(!modifiers || !(modifiers instanceof Modifiers.Variable)) modifiers = new Modifiers.Variable();
+    modifiers.update();
+    this.canAddNode = true;
+    this.canAddVar = true;
+    this._type = type;
+    this._name = name;
+    this._modifiers = modifiers;
+    this._initialValue = initialValue;
+    var initialValueText = "";
+    if(this._initialValue !== null) {
+      var valueString = this._initialValue.text;
+      initialValueText = ` = ${valueString}`;
+    }
+    this.text = `${this._modifiers.text}${this._type} ${this._name}${initialValueText};`;
+  }
+};

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

@@ -0,0 +1,15 @@
+import { NodeTypes } from "./NodeTypes.js"
+import { Node } from "../Node.js"
+NodeTypes.Vector = class VectorNode extends Node {
+  constructor(type, ...values) {
+    super();
+    this._type = type;
+    this._values = values;
+    var valueTexts = [];
+    for(var i=0;i<this._values.length;i++) {
+      valueTexts.push(this._values[i].text);
+    }
+    var joinedValues = valueTexts.join(', ');
+    this.text = `${this._type}(${joinedValues})`;
+  }
+};

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

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

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

@@ -0,0 +1,32 @@
+import { GameLibCore } from "../../../Core/index.js"
+import { NodeTypes } from "./NodeTypes.js"
+import "./Header.js"
+import "./Variable.js"
+import "./Function.js"
+import "./MainFunction.js"
+import "./AssignVariable.js"
+import "./Constant.js"
+import "./Symbol.js"
+import "./Add.js"
+import "./Subtract.js"
+import "./Multiply.js"
+import "./Divide.js"
+import "./Vector.js"
+import "./Normalize.js"
+import "./Precision.js"
+import "./Dot.js"
+import "./Max.js"
+import "./XYZ.js"
+import "./Group.js"
+import "./Texture2D.js"
+import "./RGB.js"
+import "./A.js"
+import "./Length.js"
+import "./Exp2.js"
+import "./Define.js"
+import "./Negative.js"
+import "./Clamp.js"
+import "./Mix.js"
+export {
+  NodeTypes
+}

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

@@ -0,0 +1,8 @@
+var PrecisionTypes = {
+  "LOW": "lowp",
+  "MEDIUM": "mediump",
+  "HIGH": "highp"
+};
+export {
+  PrecisionTypes
+}

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

@@ -0,0 +1,41 @@
+import { GameLibCore } from "../../Core/index.js"
+class Program {
+  constructor() {
+    this._header = [];
+    this._vars = [];
+    this._nodes = [];
+  }
+  get header() {
+    return this._header;
+  }
+  get vars() {
+    return this._vars;
+  }
+  get nodes() {
+    return this._nodes;
+  }
+  addNode(node) {
+    if(!node.canAddNode) {
+      throw new GameLibCore.Error("Cannot add a GameLib3D.ShaderFactory.Node that has canAddNode set to false!");
+    }
+    node._parent = this;
+    this._nodes.push(node);
+  }
+  addVar(node) {
+    if(!node.canAddVar) {
+      throw new GameLibCore.Error("Cannot add a GameLib3D.ShaderFactory.Node as a variable that has canAddVar set to false!");
+    }
+    node._parent = this;
+    this._vars.push(node);
+  }
+  addHeader(node) {
+    if(!node.canAddHeader) {
+      throw new GameLibCore.Error("Cannot add a GameLib3D.ShaderFactory.Node as a header that has canAddHeader set to false!");
+    }
+    node._parent = this;
+    this._header.push(node);
+  }
+}
+export {
+  Program
+}

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

@@ -0,0 +1,49 @@
+var VariableTypes = {
+  "VECTOR": {
+    "FLOAT": {
+      "2": "vec2",
+      "3": "vec3",
+      "4": "vec4"
+    },
+    "DOUBLE": {
+      "2": "dvec2",
+      "3": "dvec3",
+      "4": "dvec4"
+    },
+    "INT": {
+      "2": "ivec2",
+      "3": "ivec3",
+      "4": "ivec4"
+    },
+    "UINT": {
+      "2": "uvec2",
+      "3": "uvec3",
+      "4": "uvec4"
+    },
+    "BOOL": {
+      "2": "bvec2",
+      "3": "bvec3",
+      "4": "bvec4"
+    }
+  },
+  "MATRIX": {
+    "2": "mat2",
+    "3": "mat3",
+    "4": "mat4",
+    "custom": function(rows, cols) {
+      return `mat${rows}x${cols}`;
+    }
+  },
+  "FLOAT": "float",
+  "DOUBLE": "double",
+  "INT": "int",
+  "UINT": "uint",
+  "BOOL": "bool",
+  "VOID": "void",
+  "SAMPLER": {
+    "2D": "sampler2D"
+  }
+};
+export {
+  VariableTypes
+}

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

@@ -0,0 +1,45 @@
+import { GameLibCore } from "../../Core/index.js"
+import { Node } from "./Node.js"
+import { Modifiers } from "./Modifiers/index.js"
+import { FunctionParam } from "./FunctionParam.js"
+import { VariableTypes } from "./VariableTypes.js"
+import { PrecisionTypes } from "./PrecisionTypes.js"
+import { NodeTypes } from "./NodeTypes/index.js"
+import { Program } from "./Program.js"
+class ShaderFactory {
+  constructor() {
+    throw new GameLibCore.Error("Class GameLib3D.ShaderFactory may not be constructed!");
+  }
+  static Node = Node;
+  static Modifiers = Modifiers;
+  static FunctionParam = FunctionParam;
+  static VariableTypes = VariableTypes;
+  static PrecisionTypes = PrecisionTypes;
+  static NodeTypes = NodeTypes;
+  static Program = Program;
+  static compileFactory(shaderFactoryProgram) {
+    var headers = shaderFactoryProgram.header;
+    var headerTexts = [];
+    for(var i=0;i<headers.length;i++) {
+      headerTexts.push(headers[i].text);
+    }
+    var headersText = headerTexts.join("\n");
+    var vars = shaderFactoryProgram.vars;
+    var varTexts = [];
+    for(var i=0;i<vars.length;i++) {
+      varTexts.push(vars[i].text);
+    }
+    var varsText = varTexts.join("\n");
+    var nodes = shaderFactoryProgram.nodes;
+    var nodeTexts = [];
+    for(var i=0;i<nodes.length;i++) {
+      nodeTexts.push(nodes[i].text);
+    }
+    var nodesText = nodeTexts.join("\n");
+    var result = `${headersText}\n${varsText}\n${nodesText}`;
+    return result;
+  }
+}
+export {
+  ShaderFactory
+}

package/src/3D/Texture.js

@@ -0,0 +1,59 @@
+import { GameLibCore } from "../Core/index.js"
+class Texture {
+  constructor(gl, source = null, options = {}) {
+    this.gl = gl;
+    this.options = options;
+    this.target = options.target || gl.TEXTURE_2D;
+    this.texture = gl.createTexture();
+    gl.bindTexture(this.target, this.texture);
+    this.setParameters(options);
+    if (source !== null) {
+      this.update(source);
+    }
+  }
+  setParameters(options = {}) {
+    const gl = this.gl;
+    const target = this.target;
+    gl.texParameteri(target, gl.TEXTURE_WRAP_S, options.wrapS || gl.CLAMP_TO_EDGE);
+    gl.texParameteri(target, gl.TEXTURE_WRAP_T, options.wrapT || gl.CLAMP_TO_EDGE);
+    gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, options.minFilter || gl.LINEAR);
+    gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, options.magFilter || gl.LINEAR);
+    return this;
+  }
+  update(source) {
+    const gl = this.gl;
+    gl.bindTexture(this.target, this.texture);
+    if (this.options.flipY !== undefined) {
+      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this.options.flipY);
+    }
+    gl.texImage2D(
+      this.target,
+      0,
+      this.options.internalFormat || gl.RGBA,
+      this.options.format || gl.RGBA,
+      this.options.type || gl.UNSIGNED_BYTE,
+      source
+    );
+    if (this.options.generateMipmaps) {
+      gl.generateMipmap(this.target);
+    }
+    return this;
+  }
+  bind(unit = 0) {
+    const gl = this.gl;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(this.target, this.texture);
+    return this;
+  }
+  static fromImage(gl, image, options = {}) {
+    return new Texture(gl, image, options);
+  }
+  static load(gl, url, options = {}) {
+    return GameLibCore.AssetManager.shared
+      .loadImage(url, { crossOrigin: options.crossOrigin })
+      .then(image => Texture.fromImage(gl, image, options));
+  }
+}
+export {
+  Texture
+}

package/src/3D/TextureFactory.js

@@ -0,0 +1,22 @@
+import { GameLibCore } from "../Core/index.js"
+import { Texture } from "./Texture.js"
+class TextureFactory {
+  constructor() {
+    throw new GameLibCore.Error("Class TextureFactory may not be constructed!");
+  }
+  static create(gl, source, options = {}) {
+    if (source instanceof Texture) {
+      return source;
+    }
+    return new Texture(gl, source, options);
+  }
+  static fromImage(gl, image, options = {}) {
+    return Texture.fromImage(gl, image, options);
+  }
+  static load(gl, url, options = {}) {
+    return Texture.load(gl, url, options);
+  }
+}
+export {
+  TextureFactory
+}

package/src/3D/Transform.js

@@ -0,0 +1,35 @@
+import { Position } from "./Position.js"
+import { Rotation } from "./Rotation.js"
+import { Scale } from "./Scale.js"
+import { mat4 } from "../Core/Matrix/mat4.js"
+class Transform {
+  constructor(position=new Position(), rotation=new Rotation(), scale=new Scale()) {
+    this.position = position;
+    this.rotation = rotation;
+    this.scale = scale;
+  }
+  translate(x, y, z) {
+    this.position.translate(x, y, z);
+  }
+  rotate(x, y, z) {
+    this.rotation.rotate(x, y, z);
+  }
+  getModelMatrix() {
+    var matrix = mat4.create();
+    mat4.translate(matrix, matrix, [this.position.x, this.position.y, this.position.z]);
+    mat4.rotateX(matrix, matrix, this.rotation.x);
+    mat4.rotateY(matrix, matrix, this.rotation.y);
+    mat4.rotateZ(matrix, matrix, this.rotation.z);
+    mat4.scale(matrix, matrix, [this.scale.x, this.scale.y, this.scale.x]);
+    return matrix;
+  }
+  getNormalMatrix(modelViewMatrix) {
+    var normalMatrix = mat4.create();
+    mat4.invert(normalMatrix, modelViewMatrix);
+    mat4.transpose(normalMatrix, normalMatrix);
+    return normalMatrix;
+  }
+}
+export {
+  Transform
+}

package/src/3D/UI/UIImage.js

@@ -0,0 +1,24 @@
+import { UIObject } from "./UIObject.js"
+class UIImage extends UIObject {
+  constructor(gameLib, scene, x, y, width, height, url, options={}) {
+    super(gameLib, scene, x, y, width, height, options.color);
+    this.isTexturedUI = true;
+    this.source = null;
+    this.textureDirty = true;
+    var image = new Image();
+    if(options.crossOrigin) {
+      image.crossOrigin = options.crossOrigin;
+    }
+    image.onload = () => {
+      this.source = image;
+      this.textureDirty = true;
+    };
+    image.onerror = () => {
+      console.warn(`[GameLib] Failed to load image: ${url}`);
+    };
+    image.src = url;
+  }
+}
+export {
+  UIImage
+}

package/src/3D/UI/UILoading.js

@@ -0,0 +1,41 @@
+import { Loading } from "../../Core/Loading.js"
+import { UIObject } from "./UIObject.js"
+class UILoading extends UIObject {
+  constructor(gameLib) {
+    var x = 0;
+    var y = 0;
+    var width = gameLib._canvas.width;
+    var height = gameLib._canvas.height
+    super(gameLib, "loading", x, y, width, height, [1.0, 1.0, 1.0, 1.0]);
+    this.isTexturedUI = true;
+    this.source = document.createElement('canvas');
+    this.source.width = width;
+    this.source.height = height;
+    this.textureDirty = true;
+    this.config = {};
+    this.setConfig(this.config);
+    this.update();
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  update() {
+    Loading.render(this.source, this.source.getContext('2d'), this.config);
+    this.textureDirty = true;
+    if(this.width !== this._gameLib._canvas.width) {
+      this.width = this._gameLib._canvas.width;
+    }
+    if(this.height !== this._gameLib._canvas.height) {
+      this.height = this._gameLib._canvas.height;
+    }
+    if(this.source.width !== this.width) {
+      this.source.width = this.width;
+    }
+    if(this.source.height !== this.height) {
+      this.source.height = this.height;
+    }
+  }
+}
+export {
+  UILoading
+}

package/src/3D/UI/UIObject.js

@@ -0,0 +1,16 @@
+class UIObject {
+  constructor(gameLib, scene, x, y, width, height, color) {
+    this._gameLib = gameLib;
+    this.scene = scene;
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.color = color;
+    this.visible = true;
+  }
+  update() {}
+}
+export {
+  UIObject
+}

package/src/3D/UI/UIPath.js

@@ -0,0 +1,25 @@
+import { UIObject } from "./UIObject.js";
+class UIPath extends UIObject {
+  constructor(gameLib, scene, x, y, width, height, pathData, options={}) {
+    super(gameLib, scene, x, y, width, height, options.color);
+    this.isTexturedUI = true;
+    this.source = document.createElement('canvas');
+    this.source.width = Math.max(1, Math.ceil(width));
+    this.source.height = Math.max(1, Math.ceil(height));
+    this.textureDirty = true;
+    var ctx = this.source.getContext('2d');
+    var path = new Path2D(pathData);
+    if(options.fillStyle) {
+      ctx.fillStyle = options.fillStyle;
+      ctx.fill(path);
+    }
+    if(options.strokeStyle) {
+      ctx.strokeStyle = options.strokeStyle;
+      ctx.lineWidth = options.lineWidth || 1;
+      ctx.stroke(path);
+    }
+  }
+}
+export {
+  UIPath
+}