@cjcoding-git/gamelib 0.0.0-stage → 1.1.3

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

@@ -0,0 +1,207 @@
+import { GameLibCore } from "../../Core/index.js"
+import GL1Vertex from "../../Shaders/UI/Vertex/GL1.glsl"
+import GL1Fragment from "../../Shaders/UI/Fragment/GL1.glsl"
+import GL2Vertex from "../../Shaders/UI/Vertex/GL2.glsl"
+import GL2Fragment from "../../Shaders/UI/Fragment/GL2.glsl"
+import TextureGL1Vertex from "../../Shaders/UITexture/Vertex/GL1.glsl"
+import TextureGL1Fragment from "../../Shaders/UITexture/Fragment/GL1.glsl"
+import TextureGL2Vertex from "../../Shaders/UITexture/Vertex/GL2.glsl"
+import TextureGL2Fragment from "../../Shaders/UITexture/Fragment/GL2.glsl"
+class UIRenderer {
+  constructor(gameLib) {
+    this._gameLib = gameLib;
+    this._uiObjects = [];
+    this._vertices = [];
+    this._program = null;
+    this._buffer = null
+    this._positionLocation = null;
+    this._colorLocation = null;
+    this._resolutionLocation = null;
+    this._textureProgram = null;
+    this._textureBuffer = null;
+    this._texturePositionLocation = null;
+    this._textureUVLocation = null;
+    this._textureResolutionLocation = null;
+    this._textureSamplerLocation = null;
+  }
+  _getVertexShaderSource(webgl2) {
+    if(webgl2) {
+      return GL2Vertex;
+    } else {
+      return GL1Vertex;
+    }
+  }
+  _getFragmentShaderSource(webgl2) {
+    if(webgl2) {
+      return GL2Fragment;
+    } else {
+      return GL1Fragment;
+    }
+  }
+  _getTextureVertexShaderSource(webgl2) {
+    if(webgl2) {
+      return TextureGL2Vertex;
+    } else {
+      return TextureGL1Vertex;
+    }
+  }
+  _getTextureFragmentShaderSource(webgl2) {
+    if(webgl2) {
+      return TextureGL2Fragment;
+    } else {
+      return TextureGL1Fragment;
+    }
+  }
+  _initializeTextureRenderer() {
+    if(this._textureProgram) return true;
+    var gl = this._gameLib.webgl;
+    var webgl2 = !this._gameLib.options || this._gameLib.options.webGL2 !== false;
+    var vertexSource = this._getTextureVertexShaderSource(webgl2);
+    var fragmentSource = this._getTextureFragmentShaderSource(webgl2);
+    var vertexShader = this._gameLib.compileShader(gl.VERTEX_SHADER, vertexSource);
+    var fragmentShader = this._gameLib.compileShader(gl.FRAGMENT_SHADER, fragmentSource);
+    if(!vertexShader || !fragmentShader) return false;
+    this._textureProgram = this._gameLib.createProgram(vertexShader, fragmentShader);
+    if(!this._textureProgram) return false;
+    this._textureBuffer = gl.createBuffer();
+    this._texturePositionLocation = gl.getAttribLocation(this._textureProgram, "aPosition");
+    this._textureUVLocation = gl.getAttribLocation(this._textureProgram, "aUV");
+    this._textureResolutionLocation = gl.getUniformLocation(this._textureProgram, "uResolution");
+    this._textureSamplerLocation = gl.getUniformLocation(this._textureProgram, "uTexture");
+    return Boolean(this._textureBuffer);
+  }
+  _renderTexturedObject(object) {
+    var gl = this._gameLib.webgl;
+    var source = object.source;
+    if(!source || !this._initializeTextureRenderer()) return;
+    if(!this._textureProgram || !this._textureBuffer) return;
+    if(!object._glTexture) {
+      object._glTexture = gl.createTexture();
+      object.textureDirty = true;
+      gl.bindTexture(gl.TEXTURE_2D, object._glTexture);
+      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.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    }
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, object._glTexture);
+    if(object.textureDirty && source.complete !== false) {
+      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+      object.textureDirty = false;
+    }
+    var x = object.x;
+    var y = object.y;
+    var right = x + object.width;
+    var bottom = y + object.height;
+    var vertices = new Float32Array([
+      x, y, 0, 0,
+      right, y, 1, 0,
+      x, bottom, 0, 1,
+      x, bottom, 0, 1,
+      right, y, 1, 0,
+      right, bottom, 1, 1
+    ]);
+    gl.useProgram(this._textureProgram);
+    gl.bindBuffer(gl.ARRAY_BUFFER, this._textureBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.DYNAMIC_DRAW);
+    var stride = 4 * Float32Array.BYTES_PER_ELEMENT;
+    gl.enableVertexAttribArray(this._texturePositionLocation);
+    gl.vertexAttribPointer(this._texturePositionLocation, 2, gl.FLOAT, false, stride, 0);
+    gl.enableVertexAttribArray(this._textureUVLocation);
+    gl.vertexAttribPointer(this._textureUVLocation, 2, gl.FLOAT, false, stride, 2 * Float32Array.BYTES_PER_ELEMENT);
+    gl.uniform2f(this._textureResolutionLocation, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    gl.uniform1i(this._textureSamplerLocation, 0);
+    gl.disable(gl.DEPTH_TEST);
+    gl.depthMask(false);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    gl.drawArrays(gl.TRIANGLES, 0, 6);
+    gl.depthMask(true);
+    gl.enable(gl.DEPTH_TEST);
+  }
+  addObject(object) {
+    object.id = GameLibCore.Utils.UUID();
+    this._uiObjects.push(object);
+    return object.id;
+  }
+  getObjects() {
+    return this._uiObjects;
+  }
+  removeObject(id) {
+    this._uiObjects = this._uiObjects.filter(object => object.id !== id);
+  }
+  _initialize() {
+    if(this._program) return true;
+    var gl = this._gameLib.webgl;
+    var isWebGL2 = !this._gameLib.options || this._gameLib.options.webGL2 !== false;
+    var vertexSource = this._getVertexShaderSource(isWebGL2);
+    var fragmentSource = this._getFragmentShaderSource(isWebGL2);
+    var vertexShader = this._gameLib.compileShader(gl.VERTEX_SHADER, vertexSource);
+    var fragmentShader = this._gameLib.compileShader(gl.FRAGMENT_SHADER, fragmentSource);
+    if(!vertexShader || !fragmentShader) return false;
+    this._program = this._gameLib.createProgram(vertexShader, fragmentShader);
+    if(!this._program) return false;
+    this._buffer = gl.createBuffer();
+    this._positionLocation = gl.getAttribLocation(this._program, "aPosition");
+    this._colorLocation = gl.getAttribLocation(this._program, "aColor");
+    this._resolutionLocation = gl.getUniformLocation(this._program, "uResolution");
+    return Boolean(this._buffer);
+  }
+  render(scene) {
+    this._vertices = [];
+    for(var i=0;i<this._uiObjects.length;i++) {
+      var object = this._uiObjects[i];
+      if(object.scene === scene && object.visible !== false) {
+        if(object.update && typeof object.update === "function") object.update();
+        this.renderObject(object);
+      }
+    }
+    if(this._vertices.length === 0 || !this._initialize()) return;
+    var gl = this._gameLib.webgl;
+    var vertices = new Float32Array(this._vertices);
+    var bytesPerFloat = Float32Array.BYTES_PER_ELEMENT;
+    var vertexStride = 6 * bytesPerFloat;
+    gl.useProgram(this._program);
+    gl.bindBuffer(gl.ARRAY_BUFFER, this._buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.DYNAMIC_DRAW);
+    gl.enableVertexAttribArray(this._positionLocation);
+    gl.vertexAttribPointer(this._positionLocation, 2, gl.FLOAT, false, vertexStride, 0);
+    gl.enableVertexAttribArray(this._colorLocation);
+    gl.vertexAttribPointer(this._colorLocation, 4, gl.FLOAT, false, vertexStride, 2 * bytesPerFloat);
+    gl.uniform2f(this._resolutionLocation, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    gl.disable(gl.DEPTH_TEST);
+    gl.depthMask(false);
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    gl.drawArrays(gl.TRIANGLES, 0, vertices.length / 6);
+    gl.depthMask(true);
+    gl.enable(gl.DEPTH_TEST);
+  }
+  renderObject(object) {
+    if(object.update && typeof object.update == "function") object.update();
+    if(object.isTexturedUI) return this._renderTexturedObject(object);
+    var x = object.x;
+    var y = object.y;
+    var width = object.width;
+    var height = object.height;
+    var color = object.color || [1.0, 1.0, 1.0, 1.0];
+    var r = color[0];
+    var g = color[1];
+    var b = color[2];
+    var a = color[3];
+    var addVertex = (px, py) => {
+      this._vertices.push(px, py, r, g, b, a);
+    };
+    addVertex(x, y);
+    addVertex(x + width, y);
+    addVertex(x, y + height);
+    addVertex(x, y + height);
+    addVertex(x + width, y);
+    addVertex(x + width, y + height);
+  }
+}
+export {
+  UIRenderer
+}

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

@@ -0,0 +1,35 @@
+import { UIObject } from "./UIObject.js"
+class UIText extends UIObject {
+  constructor(gameLib, scene, x, y, width, height, text, 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.text = text;
+    this.font = options.font || "24px sans-serif";
+    this.fillStyle = options.fillStyle || "#ffffff";
+    this.textAlign = options.textAlign || "left";
+    this.textBaseline = options.textBaseline || "top";
+    this.textureDirty = true;
+    this._drawText();
+  }
+  setText(text) {
+    this.text = text;
+    this._drawText();
+    return this;
+  }
+  _drawText() {
+    var ctx = this.source.getContext('2d');
+    ctx.clearRect(0, 0, this.source.width, this.source.height);
+    ctx.font = this.font;
+    ctx.fillStyle = this.fillStyle;
+    ctx.textAlign = this.textAlign;
+    ctx.textBaseline = this.textBaseline;
+    ctx.fillText(this.text, 0, 0, this.source.width);
+    this.textureDirty = true;
+  }
+}
+export {
+  UIText
+}

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

@@ -0,0 +1,19 @@
+import { GameLibCore } from "../../Core/index.js"
+import { UIRenderer } from "./UIRenderer.js"
+import { UIObject } from "./UIObject.js"
+import { UIPath } from "./UIPath.js"
+import { UIImage } from "./UIImage.js"
+import { UIText } from "./UIText.js"
+class UI {
+  constructor() {
+    throw new GameLibCore.Error("Class UI may not be constructed!");
+  }
+  static UIRenderer = UIRenderer;
+  static UIObject = UIObject;
+  static Path = UIPath;
+  static Image = UIImage;
+  static Text = UIText;
+}
+export {
+  UI
+}

package/src/3D/Utils.js

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

package/src/3D/index.js

@@ -0,0 +1,43 @@
+import { GameLibCore } from "../Core/index.js"
+import { Utils } from "./Utils.js"
+import { Object } from "./Object.js"
+import { ShaderFactory } from "./ShaderFactory/index.js"
+import { GameLib } from "./GameLib.js"
+import { Transform } from "./Transform.js"
+import { Position } from "./Position.js"
+import { Rotation } from "./Rotation.js"
+import { Scale } from "./Scale.js"
+import { Camera } from "./Camera.js"
+import { Geometry } from "./Geometry/index.js"
+import { Ammo } from "../Lib/Ammo.js"
+import { Mesh } from "./Mesh.js"
+import { Material } from "./Material.js"
+import { Texture } from "./Texture.js"
+import { TextureFactory } from "./TextureFactory.js"
+import { UI } from "./UI/index.js"
+import { Lighting } from "./Lighting/index.js"
+class GameLib3D {
+  constructor() {
+    throw new GameLibCore.Error("Wrapper class GameLib3D may not be constructed!");
+  }
+  static Utils = Utils;
+  static Object = Object;
+  static ShaderFactory = ShaderFactory;
+  static GameLib = GameLib;
+  static Transform = Transform;
+  static Position = Position;
+  static Rotation = Rotation;
+  static Scale = Scale;
+  static Geometry = Geometry;
+  static Camera = Camera;
+  static Ammo = Ammo;
+  static Mesh = Mesh;
+  static Material = Material;
+  static Texture = Texture;
+  static TextureFactory = TextureFactory;
+  static UI = UI;
+  static Lighting = Lighting;
+}
+export {
+  GameLib3D
+}

package/src/Core/AssetManager.js

@@ -0,0 +1,116 @@
+import { GameLibError } from "./Error.js"
+class AssetManager {
+  static _shared = null;
+  static get shared() {
+    if (!AssetManager._shared) {
+      AssetManager._shared = new AssetManager();
+    }
+    return AssetManager._shared;
+  }
+  constructor() {
+    this._cache = new Map();
+    this._loaders = new Map();
+    this.registerLoader("image", (url, options = {}) => {
+      return new Promise((resolve, reject) => {
+        const image = new Image();
+        if (options.crossOrigin !== undefined) {
+          image.crossOrigin = options.crossOrigin;
+        }
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new GameLibError(`Failed to load image: ${url}`));
+        image.src = url;
+      });
+    });
+    this.registerLoader("json", async (url, options = {}) => {
+      const response = await fetch(url, options.fetchOptions);
+      if (!response.ok) {
+        throw new GameLibError(`Failed to load JSON "${url}": ${response.status}`);
+      }
+      return response.json();
+    });
+    this.registerLoader("text", async (url, options = {}) => {
+      const response = await fetch(url, options.fetchOptions);
+      if (!response.ok) {
+        throw new GameLibError(`Failed to load text "${url}": ${response.status}`);
+      }
+      return response.text();
+    });
+    this.registerLoader("arrayBuffer", async (url, options = {}) => {
+      const response = await fetch(url, options.fetchOptions);
+      if (!response.ok) {
+        throw new GameLibError(`Failed to load data "${url}": ${response.status}`);
+      }
+      return response.arrayBuffer();
+    });
+  }
+  registerLoader(type, loader) {
+    if (typeof loader !== "function") {
+      throw new TypeError("Asset loader must be a function");
+    }
+    this._loaders.set(type, loader);
+    return this;
+  }
+  load(type, url, options = {}) {
+    const loader = this._loaders.get(type);
+    if (!loader) {
+      return Promise.reject(new GameLibError(`No asset loader registered for type "${type}"`));
+    }
+    const key = `${type}:${url}`;
+    if (this._cache.has(key)) {
+      return this._cache.get(key);
+    }
+    const promise = Promise.resolve()
+      .then(() => loader(url, options))
+      .catch(error => {
+        this._cache.delete(key);
+        throw error;
+      });
+    this._cache.set(key, promise);
+    return promise;
+  }
+  loadImage(url, options) {
+    return this.load("image", url, options);
+  }
+  loadJSON(url, options) {
+    return this.load("json", url, options);
+  }
+  loadText(url, options) {
+    return this.load("text", url, options);
+  }
+  loadArrayBuffer(url, options) {
+    return this.load("arrayBuffer", url, options);
+  }
+  async loadBatch(manifest, onProgress = null) {
+    const total = manifest.length;
+    let completed = 0;
+    const entries = await Promise.all(manifest.map(async asset => {
+      try {
+        const value = await this.load(asset.type, asset.url, asset.options);
+        return [asset.name, value];
+      } finally {
+        completed++;
+        if (onProgress) {
+          onProgress({
+            completed,
+            total,
+            progress: total === 0 ? 1 : completed / total,
+            asset
+          });
+        }
+      }
+    }));
+    return Object.fromEntries(entries);
+  }
+  has(type, url) {
+    return this._cache.has(`${type}:${url}`);
+  }
+  unload(type, url) {
+    return this._cache.delete(`${type}:${url}`);
+  }
+  clear() {
+    this._cache.clear();
+  }
+}
+export {
+  AssetManager
+}

package/src/Core/AudioManager.js

@@ -0,0 +1,151 @@
+import { GameLibCore } from "./index.js"
+class AudioManager {
+  constructor() {
+    if (GameLibCore.AudioManager._instance) {
+      return GameLibCore.AudioManager._instance;
+    } else {
+      console.log("[GameLib] No AudioManager instance found. Creating new instance...");
+      this._musicPool = [];
+      this._loopingSoundPool = {};
+      this._sfxPool = {};
+      this._activeLoopingSoundPool = {};
+      this._currentMusic = null;
+      this._musicPaused = true;
+      this._musicSource = null;
+      this._musicOffset = 0;
+      this._musicStartedAt = 0;
+      this._audioCtx = new AudioContext();
+      this.bindEvents();
+      GameLibCore.AudioManager._instance = this;
+    }
+  }
+  bindEvents() {
+    window.addEventListener('click', this.resumeMusic.bind(this), false);
+    document.addEventListener('visibilitychange', this.visibilityChange.bind(this), false);
+  }
+  visibilityChange() {
+    if (document.visibilityState != 'visible') {
+      this._audioCtx.suspend();
+    } else {
+      this._audioCtx.resume();
+    }
+  }
+  async loadLoopingSound(name, url) {
+    var data = await GameLibCore.AssetManager.shared.loadArrayBuffer(url);
+    this._loopingSoundPool[name] = await this._audioCtx.decodeAudioData(data.slice(0));
+  }
+  playLoopingSound(name) {
+    if (this._loopingSoundPool[name] != null) {
+      var source = this._audioCtx.createBufferSource();
+      source.loop = true;
+      source.buffer = this._loopingSoundPool[name];
+      source.connect(this._audioCtx.destination);
+      this._activeLoopingSoundPool[name] = source;
+      source.start(0);
+    } else {
+      console.warn("[GameLib] Attempted to play a looping sound that does not exist!");
+    }
+  }
+  stopLoopingSound(name) {
+    if (this._activeLoopingSoundPool[name] != null) {
+      this._activeLoopingSoundPool[name].stop();
+      delete this._activeLoopingSoundPool[name];
+    }
+  }
+  async addSong(url) {
+    var data = await GameLibCore.AssetManager.shared.loadArrayBuffer(url);
+    var buffer = await this._audioCtx.decodeAudioData(data.slice(0));
+    this._musicPool.push(buffer);
+  }
+  stopCurrentMusicSource() {
+    if (this._musicSource != null) {
+      this._musicSource.onended = null;
+      try {
+        this._musicSource.stop();
+      } catch (error) {}
+      this._musicSource.disconnect();
+      this._musicSource = null;
+    }
+  }
+  startCurrentMusic() {
+    if (this._currentMusic == null || this._musicPaused || this._musicSource != null) {
+      return;
+    }
+    var source = this._audioCtx.createBufferSource();
+    source.buffer = this._currentMusic;
+    source.connect(this._audioCtx.destination);
+    source.onended = () => {
+      if (this._musicSource === source) {
+        this._musicSource = null;
+        this._musicOffset = 0;
+        if (!this._musicPaused) {
+          this.nextSong();
+        }
+      }
+    };
+    this._musicSource = source;
+    this._musicStartedAt = this._audioCtx.currentTime;
+    source.start(0, this._musicOffset);
+  }
+  nextSong() {
+    if (this._musicPool.length <= 0) {
+      throw new GameLibCore.Error("Music Pool is empty!");
+    }
+    this.stopCurrentMusicSource();
+    this._currentMusic = GameLibCore.Utils.getRandomListItem(this._musicPool);
+    this._musicOffset = 0;
+    this.startCurrentMusic();
+  }
+  async playMusic() {
+    this._musicPaused = false;
+    if (this._currentMusic == null) {
+      if (this._musicPool.length <= 0) {
+        this._musicPaused = true;
+        throw new GameLibCore.Error("Music Pool is empty!");
+      }
+      this._currentMusic = GameLibCore.Utils.getRandomListItem(this._musicPool);
+      this._musicOffset = 0;
+    }
+    if (this._audioCtx.state === 'suspended') {
+      await this._audioCtx.resume();
+    }
+    this.startCurrentMusic();
+  }
+  async resumeMusic() {
+    if (this._audioCtx.state === 'suspended') {
+      await this._audioCtx.resume();
+    }
+    if (!this._musicPaused) {
+      this.startCurrentMusic();
+    }
+  }
+  pauseMusic() {
+    this._musicPaused = true;
+    if (this._musicSource != null) {
+      this._musicOffset += this._audioCtx.currentTime - this._musicStartedAt;
+      this._musicOffset %= this._currentMusic.duration;
+      this.stopCurrentMusicSource();
+    }
+  }
+  async loadSfx(name, url) {
+    var data = await GameLibCore.AssetManager.shared.loadArrayBuffer(url);
+    this._sfxPool[name] = await this._audioCtx.decodeAudioData(data.slice(0));
+  }
+  playSfx(name, speed = 1, gain = 1.5) {
+    if (this._sfxPool[name]) {
+      var source = this._audioCtx.createBufferSource();
+      source.buffer = this._sfxPool[name];
+      source.playbackRate.value = speed;
+      var gainNode = this._audioCtx.createGain();
+      gainNode.gain.setValueAtTime(gain, 0);
+      gainNode.connect(this._audioCtx.destination);
+      source.connect(gainNode);
+      source.start(0);
+    } else {
+      console.warn("[GameLib] Attempted to play SFX that does not exist!");
+    }
+  }
+}
+export {
+  AudioManager
+}

package/src/Core/Error.js

@@ -0,0 +1,9 @@
+class GameLibError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "GameLibError";
+  }
+}
+export {
+  GameLibError
+}

package/src/Core/FullscreenManager.js

@@ -0,0 +1,49 @@
+class FullscreenManager {
+  constructor() {
+    this._fullscreen = 0;
+    this._pointerLocked = false;
+    this.bindEvents();
+  }
+  bindEvents() {
+    window.addEventListener('click', this.fullscreen.bind(this), false);
+  }
+  async fullscreen() {
+    if (this._pointerLocked && document.pointerLockElement == null) {
+      document.documentElement.requestPointerLock().catch(function(err) {});
+    }
+    if (this._fullscreen > 0 && document.fullscreenElement == null) {
+      document.documentElement.requestFullscreen().catch(function(err) {});
+    }
+    if (this._fullscreen == 2 && document.fullscreenElement == null) {
+      try {
+        await navigator.keyboard.lock(['Escape']);
+      } catch (err) {}
+    }
+  }
+  setFullscreen(isFullscreen, locked = false) {
+    if (isFullscreen) {
+      document.documentElement.requestFullscreen();
+      if (locked) {
+        this._fullscreen = 2;
+        navigator.keyboard.lock(['Escape']);
+      } else {
+        this._fullscreen = 1;
+      }
+    } else {
+      this._fullscreen = 0;
+      document.exitFullscreen();
+    }
+  }
+  setPointerLocked(isLocked) {
+    if (isLocked == true) {
+      this._pointerLocked = true;
+      document.documentElement.requestPointerLock();
+    } else {
+      this._pointerLocked = false;
+      document.exitPointerLock();
+    }
+  }
+}
+export {
+  FullscreenManager
+}

package/src/Core/GameLibBase.js

@@ -0,0 +1,29 @@
+class GameLibBase {
+  constructor() {
+    this._active = true;
+    this._rendering = true;
+    this._hooks = {};
+  }
+  setActive(active) {
+    this._active = active;
+  }
+  setRendering(rendering) {
+    this._rendering = rendering;
+  }
+  addHook(event, hook) {
+    if(!this._hooks[event]) {
+      this._hooks[event] = [];
+    }
+    this._hooks[event].push(hook);
+  }
+  callHook(type) {
+    if(!this._hooks[type]) return;
+    var hooks = this._hooks[type];
+    for(var i=0;i<hooks.length;i++) {
+      hooks[i]();
+    }
+  }
+}
+export {
+  GameLibBase
+}