@cjcoding-git/gamelib 1.1.2 → 1.1.3

package/src/3D/GameLib.js

@@ -0,0 +1,202 @@
+import { GameLibCore } from "../Core/index.js"
+import { GameLib3D } from "./index.js"
+import { Object } from "./Object.js"
+import { UIRenderer } from "./UI/UIRenderer.js"
+import { UILoading } from "./UI/UILoading.js"
+class GameLib extends GameLibCore.GameLibBase {
+  constructor(renderCanvas, renderCtx, options) {
+    super();
+    if (GameLib3D.GameLib._instance != null) {
+      return GameLib3D.GameLib._instance;
+    } else {
+      console.log("[GameLib] No GameLib3D instance found. Creating new instance.");
+      this._canvas = renderCanvas;
+      this._gl = renderCtx;
+      this._objects = [];
+      this._options = options;
+      this._clearColor = [ 0.0, 0.0, 0.0, 1.0 ];
+      this._camera = null;
+      this._program = null;
+      this._uiRenderer = new UIRenderer(this);
+      this._scene = "loading";
+      this._loadingConfig = {};
+      this._uiLoading = new UILoading(this);
+      this._uiLoading.setConfig(this._loadingConfig);
+      this._uiRenderer.addObject(this._uiLoading);
+      this._listeners = {};
+      this.registerMainloop();
+      GameLib3D.GameLib._instance = this;
+    }
+  }
+  setLoadingConfig(config) {
+    this._loadingConfig = config;
+    this._uiLoading.setConfig(config);
+  }
+  static getContext(canvas, webgl2=true) {
+    if(webgl2) {
+      return canvas.getContext('webgl2');
+    } else {
+      return canvas.getContext('webgl');
+    }
+  }
+  get webgl() {
+    return this._gl;
+  }
+  get options() {
+    return this._options;
+  }
+  setClearColor(color) {
+    this._clearColor = color;
+  }
+  compileShader(type, source) {
+    if(typeof type == "string") {
+      if(type == "vertex") {
+        type = this._gl.VERTEX_SHADER;
+      }
+      if(type == "fragment") {
+        type = this._gl.FRAGMENT_SHADER;
+      }
+    }
+    var shader = this._gl.createShader(type);
+    this._gl.shaderSource(shader, source);
+    this._gl.compileShader(shader);
+    if(!this._gl.getShaderParameter(shader, this._gl.COMPILE_STATUS)) {
+      console.warn("[GameLib] Shader compilation failed:", this._gl.getShaderInfoLog(shader));
+      this._gl.deleteShader(shader);
+      return null;
+    }
+    return shader;
+  }
+  createProgram(...shaders) {
+    var program = this._gl.createProgram();
+    for(var i=0;i<shaders.length;i++) {
+      this._gl.attachShader(program, shaders[i]);
+    }
+    this._gl.linkProgram(program);
+    if(!this._gl.getProgramParameter(program, this._gl.LINK_STATUS)) {
+      console.warn("[GameLib] Program linking failed:", this._gl.getProgramInfoLog(program));
+      return null;
+    }
+    return program;
+  }
+  useProgram(program) {
+    this._program = program;
+    this._gl.useProgram(program);
+  }
+  setCamera(camera) {
+    this._camera = camera;
+  }
+  getAttributeLocation(program, name, forceMode=null) {
+    var location;
+    if((!forceMode && name.startsWith('a')) || forceMode == 'attribute') {
+      location = this._gl.getAttribLocation(program, name);
+    }
+    if((!forceMode && name.startsWith('u')) || forceMode == 'uniform') {
+      location = this._gl.getUniformLocation(program, name);
+    }
+    return location;
+  }
+  setProgramAttribute(program, name, buffer, num, type, normalize=false, stride=0, offset=0, forceMode=null) {
+    if(!type) type = this._gl.FLOAT;
+    var location = this.getAttributeLocation(program, name, forceMode);
+    if (location === null || location === -1) {
+      return;
+    }
+    this._gl.bindBuffer(this._gl.ARRAY_BUFFER, buffer);
+    this._gl.vertexAttribPointer(location, num, type, normalize, stride, offset);
+    this._gl.enableVertexAttribArray(location);
+  }
+  addObject(object) {
+    if(object instanceof Object) {
+      object.setup();
+      this._objects.push(object);
+    } else {
+      throw new GameLibCore.Error("GameLib3D.GameLib.addObject(object) must be passed an instance of Object!");
+    }
+  }
+  update() {
+    if(!this._active) return;
+    this.callHook('pre-update');
+    for(var i=0;i<this._objects.length;i++) {
+      this._objects[i].update(this._camera);
+    }
+    this.callHook('post-update');
+  }
+  clearCanvas() {
+    this._gl.clearColor(...this._clearColor);
+    this._gl.clearDepth(1.0);
+    this._gl.enable(this._gl.DEPTH_TEST);
+    this._gl.depthFunc(this._gl.LEQUAL);
+    this._gl.enable(this._gl.BLEND);
+    this._gl.blendFunc(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA);
+    this._gl.clear(this._gl.COLOR_BUFFER_BIT | this._gl.DEPTH_BUFFER_BIT);
+  }
+  draw() {
+    if(!this._rendering) return;
+    this.clearCanvas();
+    this.callHook('pre-render');
+    for(var i=0;i<this._objects.length;i++) {
+      if(this._objects[i].scene === this._scene) {
+        this._objects[i].draw(this._camera);
+      }
+    }
+    this._uiRenderer.render(this._scene);
+    this.callHook('post-render');
+  }
+  addUIObject(object) {
+    return this._uiRenderer.addObject(object);
+  }
+  getUIObjects() {
+    return this._uiRenderer.getObjects();
+  }
+  removeUIObject(id) {
+    this._uiRenderer.removeObject(id);
+  }
+  mainloop() {
+    this.update();
+    this.draw();
+    this.registerMainloop();
+  }
+  registerMainloop() {
+    window.requestAnimationFrame(this.mainloop.bind(this));
+  }
+  stopLoading() {
+    this._scene = "init";
+  }
+  setScene(scene) {
+    this._scene = scene;
+  }
+  listen(type, callback) {
+    if(!this._listeners[type]) this._listeners[type] = [];
+    this._listeners[type].push(callback);
+  }
+  _fire(type) {
+    if(!this._listeners[type]) return;
+    for(var i=0;i<this._listeners[type].length;i++) {
+      var listener = this._listeners[type][i];
+      if(listener && typeof listener === "function") {
+        listener();
+      }
+    }
+  }
+  resizeToWindow() {
+    this._canvas.width = window.innerWidth;
+    this._canvas.height = window.innerHeight;
+    this._canvas.style.position = "fixed";
+    this._canvas.style.top = "0";
+    this._canvas.style.left = "0";
+    this._gl.viewport(0, 0, this._canvas.width, this._canvas.height);
+    this._fire('resize');
+  }
+  fillWindow() {
+    window.addEventListener('resize', this.resizeToWindow.bind(this), false);
+    this.resizeToWindow();
+  }
+  getLights(scene) {
+    if(!scene) scene = this._scene;
+    return this._objects.filter(object => object.isLight && object.scene === scene);
+  }
+}
+export {
+  GameLib
+}

package/src/3D/Geometry/Box.js

@@ -0,0 +1,39 @@
+class Box {
+  constructor(width=1, height=1, depth=1) {
+    var w = width / 2;
+    var h = height / 2;
+    var d = depth / 2;
+    var positions = [
+      -w, -h,  d,   w, -h,  d,   w,  h,  d,  -w,  h,  d,
+      -w, -h, -d,  -w,  h, -d,   w,  h, -d,   w, -h, -d,
+      -w,  h, -d,  -w,  h,  d,   w,  h,  d,   w,  h, -d,
+      -w, -h, -d,   w, -h, -d,   w, -h,  d,  -w, -h,  d,
+       w, -h, -d,   w,  h, -d,   w,  h,  d,   w, -h,  d,
+      -w, -h, -d,  -w, -h,  d,  -w,  h,  d,  -w,  h, -d
+    ];
+    var normals = [
+       0, 0, 1,  0, 0, 1,  0, 0, 1,  0, 0, 1,
+       0, 0,-1,  0, 0,-1,  0, 0,-1,  0, 0,-1,
+       0, 1, 0,  0, 1, 0,  0, 1, 0,  0, 1, 0,
+       0,-1, 0,  0,-1, 0,  0,-1, 0,  0,-1, 0,
+       1, 0, 0,  1, 0, 0,  1, 0, 0,  1, 0, 0,
+      -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0
+    ];
+    var uv = [];
+    for(var i=0;i<6;i++) {
+      uv.push(0, 0,  1, 0,  1, 1,  0, 1);
+    }
+    var indices = [];
+    for(var i=0;i<6;i++) {
+      var offset = i * 4;
+      indices.push(offset, offset + 1, offset + 2, offset, offset + 2, offset + 3);
+    }
+    this.positions = positions;
+    this.normals = normals;
+    this.uv = uv;
+    this.indices = indices;
+  }
+}
+export {
+  Box
+}

package/src/3D/Geometry/Cone.js

@@ -0,0 +1,45 @@
+class Cone {
+  constructor(radius=1, height=2, segments=24) {
+    var positions = [];
+    var normals = [];
+    var uv = [];
+    var indices = [];
+    var halfH = height / 2;
+    positions.push(0, halfH, 0);
+    normals.push(0, 1, 0);
+    uv.push(0.5, 1.0);
+    for(var i=0;i<=segments;i++) {
+      var angle = (i * 2 * Math.PI) / segments;
+      var x = Math.sin(angle);
+      var z = Math.cos(angle);
+      positions.push(radius * x, -halfH, radius * z);
+      var slantLen = Math.sqrt(radius * radius + height * height);
+      normals.push((height / slantLen) * x, radius / slantLen, (height / slantLen) * z);
+      uv.push(i / segments, 0.0);
+    }
+    for(var i=0;i<=segments;i++) {
+      indices.push(0, i, i + 1);
+    }
+    var baseCenterIdx = positions.length / 3;
+    positions.push(0, -halfH, 0);
+    normals.push(0, -1, 0);
+    uv.push(0.5, 0.5);
+    var baseStartIdx = positions.length / 3;
+    for(var i=0;i<=segments;i++) {
+      var angle = (i * 2 * Math.PI) / segments;
+      positions.push(radius * Math.cos(angle), -halfH, radius * Math.sin(angle));
+      normals.push(0, -1, 0);
+      uv.push(0.5 + 0.5 * Math.cos(angle), 0.5 + 0.5 * Math.sin(angle));
+    }
+    for(var i=0;i<segments;i++) {
+      indices.push(baseCenterIdx, baseStartIdx + i + 1, baseStartIdx + i);
+    }
+    this.positions = positions;
+    this.normals = normals;
+    this.uv = uv;
+    this.indices = indices;
+  }
+}
+export {
+  Cone
+}

package/src/3D/Geometry/ModelLoaders/GLBLoader.js

@@ -0,0 +1,12 @@
+import { GameLibCore } from "../../../Core/index.js"
+class GLBLoader {
+  constructor() {
+    throw new GameLibCore.Error("Class GLBLoader may not be constructed!");
+  }
+  static load(url, options={}) {
+    throw new GameLibCore.Error("Loading GLB files is not yet implemented.");
+  }
+}
+export {
+  GLBLoader
+}

package/src/3D/Geometry/ModelLoaders/GLTFLoader.js

@@ -0,0 +1,12 @@
+import { GameLibCore } from "../../../Core/index.js"
+class GLTFLoader {
+  constructor() {
+    throw new GameLibCore.Error("Class GLTFLoader may not be constructed!");
+  }
+  static load(url, options={}) {
+    throw new GameLibCore.Error("Loading GLTF files is not yet implemented.");
+  }
+}
+export {
+  GLTFLoader
+}

package/src/3D/Geometry/ModelLoaders/GMLLoader.js

@@ -0,0 +1,114 @@
+import { GameLibCore } from "../../../Core/index.js"
+class GMLLoader {
+  constructor() {
+    throw new GameLibCore.Error("Class GMLLoader may not be constructed!");
+  }
+  static MAGIC = "GML1";
+  static VERSION = 1;
+  static async load(url, options = {}) {
+    if (typeof fetch !== "function") {
+      throw new GameLibCore.Error("GMLLoader.load requires fetch support.");
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      throw new GameLibCore.Error(`Failed to load model (${response.status} ${response.statusText}): ${url}`);
+    }
+    return GMLLoader.parse(await response.arrayBuffer());
+  }
+  static parse(input) {
+    let buffer;
+    if (input instanceof ArrayBuffer) {
+      buffer = input;
+    } else if (ArrayBuffer.isView(input)) {
+      buffer = input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength);
+    } else {
+      throw new GameLibCore.Error("GMLLoader.parse expects an ArrayBuffer or typed-array view.");
+    }
+    const view = new DataView(buffer);
+    let offset = 0;
+    const ensure = (byteLength) => {
+      if (!Number.isSafeInteger(byteLength) || byteLength < 0 || offset + byteLength > view.byteLength) {
+        throw new GameLibCore.Error("Invalid or truncated GML1 model data.");
+      }
+    };
+    const readUint16 = () => {
+      ensure(2);
+      const value = view.getUint16(offset, true);
+      offset += 2;
+      return value;
+    };
+    const readUint32 = () => {
+      ensure(4);
+      const value = view.getUint32(offset, true);
+      offset += 4;
+      return value;
+    };
+    const readFloat32Array = (length) => {
+      const byteLength = length * 4;
+      ensure(byteLength);
+      const values = new Float32Array(length);
+      for (let i = 0; i < length; i++) {
+        values[i] = view.getFloat32(offset, true);
+        offset += 4;
+      }
+      return values;
+    };
+    ensure(8);
+    const magic = String.fromCharCode(
+      view.getUint8(0), view.getUint8(1), view.getUint8(2), view.getUint8(3)
+    );
+    if (magic !== GMLLoader.MAGIC) {
+      throw new GameLibCore.Error(`Invalid native model signature: expected ${GMLLoader.MAGIC}.`);
+    }
+    offset = 4;
+    const version = readUint16();
+    if (version !== GMLLoader.VERSION) {
+      throw new GameLibCore.Error(`Unsupported GML1 model version: ${version}.`);
+    }
+    const meshCount = readUint16();
+    const decoder = new TextDecoder();
+    const meshes = [];
+    for (let meshIndex = 0; meshIndex < meshCount; meshIndex++) {
+      const nameLength = readUint16();
+      ensure(nameLength);
+      const name = decoder.decode(new Uint8Array(buffer, offset, nameLength));
+      offset += nameLength;
+      const vertexCount = readUint32();
+      const indexCount = readUint32();
+      if (vertexCount === 0 || indexCount === 0 || indexCount % 3 !== 0) {
+        throw new GameLibCore.Error(`Invalid vertex or triangle index count in GML1 mesh ${meshIndex}.`);
+      }
+      const color = readFloat32Array(4);
+      const positions = readFloat32Array(vertexCount * 3);
+      const normals = readFloat32Array(vertexCount * 3);
+      const uv = readFloat32Array(vertexCount * 2);
+      const indices = readFloat32Array(0); // Keep all reads checked through the shared bounds helper.
+      void indices;
+      const indexByteLength = indexCount * 4;
+      ensure(indexByteLength);
+      const meshIndices = new Uint32Array(indexCount);
+      for (let i = 0; i < indexCount; i++) {
+        const index = readUint32();
+        if (index >= vertexCount) {
+          throw new GameLibCore.Error(`GML1 mesh ${meshIndex} contains an out-of-range index.`);
+        }
+        meshIndices[i] = index;
+      }
+      meshes.push({
+        name,
+        positions,
+        normals,
+        uv,
+        indices: meshIndices,
+        material: { color }
+      });
+    }
+    if (offset !== view.byteLength) {
+      throw new GameLibCore.Error("Unexpected trailing bytes in GML1 model data.");
+    }
+    return { format: GMLLoader.MAGIC, version, meshes };
+  }
+}
+export {
+  GMLLoader
+}

package/src/3D/Geometry/ModelLoaders/OBJLoader.js

@@ -0,0 +1,12 @@
+import { GameLibCore } from "../../../Core/index.js"
+class OBJLoader {
+  constructor() {
+    throw new GameLibCore.Error("Class OBJLoader may not be constructed!");
+  }
+  static load(url, options={}) {
+    throw new GameLibCore.Error("Loading OBJ files is not yet implemented.");
+  }
+}
+export {
+  OBJLoader
+}

package/src/3D/Geometry/ModelLoaders/index.js

@@ -0,0 +1,17 @@
+import { GameLibCore } from "../../../Core/index.js"
+import { GMLLoader } from "./GMLLoader.js"
+import { GLBLoader } from "./GLBLoader.js"
+import { GLTFLoader } from "./GLTFLoader.js"
+import { OBJLoader } from "./OBJLoader.js"
+class ModelLoaders {
+  constructor() {
+    throw new GameLibCore.Error("Class ModelLoaders may not be constructed!");
+  }
+  static GMLLoader = GMLLoader;
+  static GLBLoader = GLBLoader;
+  static GLTFLoader = GLTFLoader;
+  static OBJLoader = OBJLoader;
+}
+export {
+  ModelLoaders
+}

package/src/3D/Geometry/Pyramid.js

@@ -0,0 +1,55 @@
+class Pyramid {
+  constructor(width=1, height=1, depth=1, sides=4) {
+    height = height / 2;
+    sides = Math.max(3, Math.floor(sides));
+    var positions = [];
+    var normals = [];
+    var uv = [];
+    var indices = [];
+    var halfW = width / 2;
+    var halfH = height / 2;
+    var halfD = depth / 2;
+    for (var i = 0; i < sides; i++) {
+      var angle0 = (i * 2 * Math.PI) / sides;
+      var angle1 = ((i + 1) * 2 * Math.PI) / sides;
+      var x0 = halfW * Math.cos(angle0);
+      var z0 = halfD * Math.sin(angle0);
+      var x1 = halfW * Math.cos(angle1);
+      var z1 = halfD * Math.sin(angle1);
+      var centerX = (x0 + x1) / 2;
+      var centerZ = (z0 + z1) / 2;
+      var normalLength = Math.hypot(height * centerX, halfH * (z0 - z1));
+      var nx = (height * centerX) / normalLength;
+      var ny = (halfH * (z0 - z1)) / normalLength;
+      var nz = (halfH * (x1 - x0)) / normalLength;
+      var offset = positions.length / 3;
+      positions.push(x0, -halfH, z0, x1, -halfH, z1, 0, halfH, 0);
+      for (var vertex = 0; vertex < 3; vertex++) {
+        normals.push(nx, ny, nz);
+      }
+      uv.push(0, 0, 1, 0, 0.5, 1);
+      indices.push(offset, offset + 1, offset + 2);
+    }
+    var baseCenter = positions.length / 3;
+    positions.push(0, -halfH, 0);
+    normals.push(0, -1, 0);
+    uv.push(0.5, 0.5);
+    var baseStart = positions.length / 3;
+    for (var j = 0; j < sides; j++) {
+      var baseAngle = (j * 2 * Math.PI) / sides;
+      positions.push(halfW * Math.cos(baseAngle), -halfH, halfD * Math.sin(baseAngle));
+      normals.push(0, -1, 0);
+      uv.push(0.5 + 0.5 * Math.cos(baseAngle), 0.5 + 0.5 * Math.sin(baseAngle));
+    }
+    for (var k = 0; k < sides; k++) {
+      indices.push(baseCenter, baseStart + (k + 1) % sides, baseStart + k);
+    }
+    this.positions = positions;
+    this.normals = normals;
+    this.uv = uv;
+    this.indices = indices;
+  }
+}
+export {
+  Pyramid
+}

package/src/3D/Geometry/Sphere.js

@@ -0,0 +1,37 @@
+class Sphere {
+  constructor(radius = 1, latBands = 24, longBands = 24) {
+    var positions = [];
+    var normals = [];
+    var uv = [];
+    var indices = [];
+    for (var lat = 0; lat <= latBands; lat++) {
+      var theta = (lat * Math.PI) / latBands;
+      var sinTheta = Math.sin(theta);
+      var cosTheta = Math.cos(theta);
+      for (var lon = 0; lon <= longBands; lon++) {
+        var phi = (lon * 2 * Math.PI) / longBands;
+        var x = Math.cos(phi) * sinTheta;
+        var y = cosTheta;
+        var z = Math.sin(phi) * sinTheta;
+        normals.push(x, y, z);
+        uv.push(1 - (lon / longBands), 1 - (lat / latBands));
+        positions.push(radius * x, radius * y, radius * z);
+      }
+    }
+    for (var lat = 0; lat < latBands; lat++) {
+      for (var lon = 0; lon < longBands; lon++) {
+        var first = (lat * (longBands + 1)) + lon;
+        var second = first + longBands + 1;
+        indices.push(first, first + 1, second);
+        indices.push(second, first + 1, second + 1);
+      }
+    }
+    this.positions = positions;
+    this.normals = normals;
+    this.uv = uv;
+    this.indices = indices;
+  }
+}
+export {
+  Sphere
+};

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

@@ -0,0 +1,19 @@
+import { GameLibCore } from "../../Core/index.js"
+import { Box } from "./Box.js"
+import { Sphere } from "./Sphere.js"
+import { Cone } from "./Cone.js"
+import { Pyramid } from "./Pyramid.js"
+import { ModelLoaders } from "./ModelLoaders/index.js"
+class Geometry {
+  constructor() {
+    throw new GameLibCore.Error("Class Geometry may not be constructed!");
+  }
+  static Box = Box;
+  static Sphere = Sphere;
+  static Cone = Cone;
+  static Pyramid = Pyramid;
+  static ModelLoaders = ModelLoaders;
+}
+export {
+  Geometry
+}

package/src/3D/Lighting/AmbientLight.js

@@ -0,0 +1,17 @@
+import { Object } from "../Object.js"
+import { Rotation } from "../Rotation.js"
+class AmbientLight extends Object {
+  constructor(gameLib, scene, position, { color = [1.0, 1.0, 1.0], intensity = 1, direction = new Rotation(0, -1, 0), range = 10 }) {
+    super(gameLib, scene);
+    this.isLight = true;
+    this.type = "ambient";
+    this.position = position;
+    this.color = color;
+    this.intensity = intensity;
+    this.direction = direction;
+    this.range = range;
+  }
+}
+export {
+  AmbientLight
+}

package/src/3D/Lighting/DirectionalLight.js

@@ -0,0 +1,17 @@
+import { Object } from "../Object.js"
+import { Rotation } from "../Rotation.js"
+class DirectionalLight extends Object {
+  constructor(gameLib, scene, position, { color = [1.0, 1.0, 1.0], intensity = 1, direction = new Rotation(0, -1, 0), range = 10 }) {
+    super(gameLib, scene);
+    this.isLight = true;
+    this.type = "directional";
+    this.position = position;
+    this.color = color;
+    this.intensity = intensity;
+    this.direction = direction;
+    this.range = range;
+  }
+}
+export {
+  DirectionalLight
+}

package/src/3D/Lighting/PointLight.js

@@ -0,0 +1,17 @@
+import { Object } from "../Object.js"
+import { Rotation } from "../Rotation.js"
+class PointLight extends Object {
+  constructor(gameLib, scene, position, { color = [1.0, 1.0, 1.0], intensity = 1, direction = new Rotation(0, -1, 0), range = 10 }) {
+    super(gameLib, scene);
+    this.isLight = true;
+    this.type = "point";
+    this.position = position;
+    this.color = color;
+    this.intensity = intensity;
+    this.direction = direction;
+    this.range = range;
+  }
+}
+export {
+  PointLight
+}

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

@@ -0,0 +1,15 @@
+import { GameLibCore } from "../../Core/index.js"
+import { PointLight } from "./PointLight.js"
+import { DirectionalLight } from "./DirectionalLight.js"
+import { AmbientLight } from "./AmbientLight.js"
+class Lighting {
+  constructor() {
+    throw new GameLibCore.Error("Class Lighting may not be constructed!");
+  }
+  static PointLight = PointLight;
+  static DirectionalLight = DirectionalLight;
+  static AmbientLight = AmbientLight;
+}
+export {
+  Lighting
+}