rapid-render 0.0.1

package/dist/rapid.js

@@ -0,0 +1,784 @@
+var g = Object.defineProperty;
+var _ = (s, e, t) => e in s ? g(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var a = (s, e, t) => (_(s, typeof e != "symbol" ? e + "" : e, t), t);
+class p {
+  constructor(e) {
+    a(this, "usedElemNum");
+    a(this, "typedArray");
+    a(this, "arrayType");
+    a(this, "maxElemNum");
+    a(this, "bytePerElem");
+    this.usedElemNum = 0, this.maxElemNum = 64, this.bytePerElem = e.BYTES_PER_ELEMENT, this.arrayType = e, this.typedArray = new e(this.maxElemNum);
+  }
+  clear() {
+    this.usedElemNum = 0;
+  }
+  /**
+   * resize the array
+   * @param size 
+   * @returns 
+   */
+  resize(e = 0) {
+    if (e += this.usedElemNum, e > this.maxElemNum) {
+      for (; e > this.maxElemNum; )
+        this.maxElemNum <<= 1;
+      const t = this.typedArray;
+      return this.typedArray = new this.arrayType(this.maxElemNum), this.typedArray.set(t), this;
+    }
+  }
+  /**
+   * push a new element
+   * @param value 
+   */
+  push(e) {
+    this.typedArray[this.usedElemNum] = e, this.usedElemNum += 1;
+  }
+  /**
+   * pop a element
+   * @param num 
+   */
+  pop(e) {
+    this.usedElemNum -= e;
+  }
+  /**
+   * get the array
+   * @param begin 
+   * @param end 
+   * @returns 
+   */
+  getArray(e = 0, t) {
+    return t == null ? this.typedArray : this.typedArray.subarray(e, t);
+  }
+  /**
+   * length of the array
+   */
+  get length() {
+    return this.typedArray.length;
+  }
+}
+class b extends p {
+  constructor() {
+    super(Float32Array);
+  }
+  /**
+   * push a matrix to the stack
+   */
+  pushMat() {
+    const e = this.usedElemNum - 6, t = this.typedArray;
+    this.resize(6), this.push(t[e + 0]), this.push(t[e + 1]), this.push(t[e + 2]), this.push(t[e + 3]), this.push(t[e + 4]), this.push(t[e + 5]);
+  }
+  /**
+   * pop a matrix from the stack
+   */
+  popMat() {
+    this.pop(6);
+  }
+  /**
+   * push a matrix and indentiy it
+   */
+  pushIdentity() {
+    this.resize(6), this.push(1), this.push(0), this.push(0), this.push(1), this.push(0), this.push(0);
+  }
+  /**
+   * Translates the current matrix by the specified x and y values.
+   * @param x - The amount to translate horizontally.
+   * @param y - The amount to translate vertically.
+   */
+  translate(e, t) {
+    const r = this.usedElemNum - 6, i = this.typedArray;
+    i[r + 4] = i[r + 0] * e + i[r + 2] * t + i[r + 4], i[r + 5] = i[r + 1] * e + i[r + 3] * t + i[r + 5];
+  }
+  /**
+   * Rotates the current matrix by the specified angle.
+   * @param angle - The angle, in radians, to rotate the matrix by.
+   */
+  rotate(e) {
+    const t = this.usedElemNum - 6, r = this.typedArray, i = Math.cos(e), h = Math.sin(e), n = r[t + 0], l = r[t + 1], d = r[t + 2], E = r[t + 3];
+    r[t + 0] = n * i - l * h, r[t + 1] = n * h + l * i, r[t + 2] = d * i - E * h, r[t + 3] = d * h + E * i;
+  }
+  /**
+   * Multiplies the current matrix on the top of the stack by a scaling transformation.
+   * @param x - The amount to scale the matrix horizontally.
+   * @param y - The amount to scale the matrix vertically. If not specified, x is used for both horizontal and vertical scaling.
+   */
+  scale(e, t = e) {
+    const r = this.usedElemNum - 6, i = this.typedArray;
+    i[r + 0] = i[r + 0] * e, i[r + 1] = i[r + 1] * e, i[r + 2] = i[r + 2] * t, i[r + 3] = i[r + 3] * t;
+  }
+  apply(e, t) {
+    const r = this.usedElemNum - 6, i = this.typedArray;
+    return [
+      i[r + 0] * e + i[r + 2] * t + i[r + 4],
+      i[r + 1] * e + i[r + 3] * t + i[r + 5]
+    ];
+  }
+}
+class o {
+  constructor(e, t, r, i) {
+    a(this, "r");
+    a(this, "g");
+    a(this, "b");
+    a(this, "a");
+    this.r = e, this.g = t, this.b = r, this.a = i;
+  }
+  /**
+   * is equal to another color instance
+   * @param color 
+   * @returns 
+   */
+  equals(e) {
+    return e.r == this.r && e.g == this.g && e.b == this.b && e.a == this.a;
+  }
+  /**
+   * create a new color by hex string
+   * @param hexString 
+   * @returns 
+   */
+  static fromHex(e) {
+    e.startsWith("#") && (e = e.slice(1));
+    const t = parseInt(e.slice(0, 2), 16) / 255, r = parseInt(e.slice(2, 4), 16) / 255, i = parseInt(e.slice(4, 6), 16) / 255;
+    let h = 1;
+    return e.length >= 8 && (h = parseInt(e.slice(6, 8), 16) / 255), new o(t, r, i, h);
+  }
+}
+class T extends p {
+  constructor(t, r, i = t.ARRAY_BUFFER) {
+    super(r);
+    a(this, "buffer");
+    a(this, "gl");
+    a(this, "type");
+    a(this, "bufferSize", 0);
+    this.gl = t, this.buffer = t.createBuffer(), this.type = i;
+  }
+  /**
+   * bind buffer to gpu
+   */
+  bindBuffer() {
+    this.gl.bindBuffer(this.type, this.buffer);
+  }
+  /**
+   * array data to gpu
+   */
+  bufferData() {
+    const t = this.gl;
+    this.usedElemNum > this.bufferSize ? (t.bufferData(this.type, this.getArray(0, this.usedElemNum), t.STATIC_DRAW), this.bufferSize = this.usedElemNum) : t.bufferSubData(this.type, 0, this.getArray(0, this.usedElemNum));
+  }
+  /**
+   * clear
+   */
+  clear() {
+    super.clear(), this.bufferSize = 0;
+  }
+}
+class A extends T {
+  constructor(t, r, i) {
+    super(t, Uint16Array, t.ELEMENT_ARRAY_BUFFER);
+    a(this, "elemVertPerObj");
+    a(this, "objects", 0);
+    a(this, "vertexPerObject");
+    a(this, "dirty", !0);
+    this.elemVertPerObj = r, this.vertexPerObject = i;
+  }
+  addObject(t) {
+    this.objects++, this.resize(this.elemVertPerObj);
+  }
+  /**
+   * set number of objects
+   * @param obj 
+   */
+  setObjects(t) {
+    if (t > this.objects) {
+      for (; t > this.objects; )
+        this.addObject(this.objects * this.vertexPerObject);
+      this.dirty = !0;
+    }
+  }
+  /**
+   * array data to gpu
+   */
+  bufferData() {
+    this.dirty && super.bufferData(), this.dirty = !1;
+  }
+  clear() {
+    super.clear(), this.objects = 0;
+  }
+}
+const y = (s) => {
+  const e = s.getContext("webgl2") || s.getContext("webgl");
+  if (!e)
+    throw new Error("TODO");
+  return e;
+}, f = (s, e, t) => {
+  const r = s.createShader(t);
+  if (!r)
+    throw new Error("Unable to create webgl shader");
+  if (s.shaderSource(r, e), s.compileShader(r), !s.getShaderParameter(r, s.COMPILE_STATUS)) {
+    const h = s.getShaderInfoLog(r);
+    throw console.error("Shader compilation failed:", h), new Error("Unable to compile shader: " + h + e);
+  }
+  return r;
+}, m = (s, e, t) => {
+  var r = s.createProgram(), i = f(s, e, 35633), h = f(s, t, 35632);
+  if (!r)
+    throw new Error("Unable to create program shader");
+  return s.attachShader(r, i), s.attachShader(r, h), s.linkProgram(r), r;
+};
+function S(s, e, t) {
+  const r = s.createTexture();
+  if (s.bindTexture(s.TEXTURE_2D, r), s.texParameteri(s.TEXTURE_2D, s.TEXTURE_MIN_FILTER, t ? s.LINEAR : s.NEAREST), s.texParameteri(s.TEXTURE_2D, s.TEXTURE_MAG_FILTER, t ? s.LINEAR : s.NEAREST), s.texParameteri(s.TEXTURE_2D, s.TEXTURE_WRAP_S, s.CLAMP_TO_EDGE), s.texParameteri(s.TEXTURE_2D, s.TEXTURE_WRAP_T, s.CLAMP_TO_EDGE), s.texImage2D(s.TEXTURE_2D, 0, s.RGBA, s.RGBA, s.UNSIGNED_BYTE, e), !r)
+    throw new Error("unable to create texture");
+  return r;
+}
+class R {
+  constructor(e) {
+    /** shader to render */
+    a(this, "shader");
+    /** If there is no new shader, use the default shader  */
+    a(this, "defaultShader");
+    a(this, "render");
+    a(this, "gl");
+    /** buffer  */
+    a(this, "attributeBuffer");
+    /** shader attribute */
+    a(this, "attribute");
+    this.render = e, this.gl = e.gl, this.attributeBuffer = new T(this.gl, Float32Array);
+  }
+  /**
+   * Create a default shader that is called by subclasses
+   * @param options 
+   */
+  createDefaultShader(e) {
+    this.defaultShader = m(this.render.gl, e.vs, e.fs), this.attribute = e.attribute;
+  }
+  /**
+   * add a vertex
+   * @param x 
+   * @param y 
+   */
+  addVertex(e, t, ...r) {
+    const [i, h] = this.render.matrix.apply(e, t);
+    this.attributeBuffer.push(i), this.attributeBuffer.push(h);
+  }
+  flush() {
+    this.doFlush(), this.reset();
+  }
+  doFlush() {
+    this.attributeBuffer.bufferData();
+  }
+  /**
+   * reset this region
+   * called when flush or entering this region
+   */
+  reset() {
+    this.attributeBuffer.clear();
+  }
+  /**
+   * enter this region
+   * @param shader costum shader
+   */
+  enter(e) {
+    this.shader = e || this.defaultShader;
+    const t = this.gl;
+    t.useProgram(this.shader), this.attributeBuffer.bindBuffer(), this.attribute.forEach((i) => {
+      const h = t.getAttribLocation(this.shader, i.name);
+      t.enableVertexAttribArray(h), t.vertexAttribPointer(
+        h,
+        i.size,
+        i.type,
+        i.normalized || !1,
+        i.stride,
+        i.offset || 0
+      );
+    });
+    const r = t.getUniformLocation(this.shader, "uProjectionMatrix");
+    t.uniformMatrix4fv(
+      r,
+      !1,
+      this.render.projection
+    );
+  }
+  /**
+   * exit this reigon
+   */
+  exit() {
+  }
+}
+const x = `precision mediump float;\r
+\r
+uniform vec4 uColor;\r
+\r
+void main(void) {\r
+    gl_FragColor = uColor;\r
+}\r
+`, I = `precision mediump float;\r
+\r
+attribute vec2 aPosition;\r
+uniform mat4 uProjectionMatrix;\r
+uniform vec4 uColor;\r
+\r
+void main(void) {\r
+    gl_Position = uProjectionMatrix * vec4(aPosition, 0.0, 1.0);\r
+}\r
+`;
+class v extends R {
+  constructor(t) {
+    super(t);
+    /** color to draw shapes */
+    a(this, "color", new o(0, 0, 0, 1));
+    /** is the color needs to be updated */
+    a(this, "colorDirty", !0);
+    /** number of vertex to render */
+    a(this, "count", 0);
+    const r = this.gl, i = 2 * Float32Array.BYTES_PER_ELEMENT;
+    this.createDefaultShader({
+      fs: x,
+      vs: I,
+      attribute: [
+        { name: "aPosition", size: 2, type: r.FLOAT, stride: i }
+      ]
+    });
+  }
+  /**
+   * set a color
+   * @param color 
+   */
+  setColor(t) {
+    t.equals(this.color) || (this.color = t, this.colorDirty = !0);
+  }
+  /**
+   * draw a shape
+   * @param vertexs 
+   * @param color 
+   */
+  drawShape(t, r = new o(0, 0, 0, 1)) {
+    this.setColor(r);
+    for (let i = 0; i < t.length; i += 2)
+      this.addVertex(t[i], t[i + 1]), this.count++;
+    this.flush();
+  }
+  /**
+   * render
+   */
+  doFlush() {
+    if (this.count > 0) {
+      super.doFlush();
+      const t = this.gl;
+      if (this.colorDirty) {
+        const r = this.color, i = this.gl, h = i.getUniformLocation(this.shader, "uColor");
+        i.uniform4f(h, r.r, r.g, r.b, r.a), this.colorDirty = !1;
+      }
+      t.drawArrays(t.TRIANGLE_FAN, 0, this.count);
+    }
+  }
+  /**
+   * reset this region
+   * called when flush or entering this region
+   */
+  reset() {
+    super.reset(), this.count = 0;
+  }
+  /**
+   * enter this region
+   * @param shader costum shader
+   */
+  enter(t) {
+    super.enter(t), this.colorDirty = !0;
+  }
+}
+const P = `precision lowp float;\r
+uniform sampler2D uTextures[%TEXTURE_NUM%];\r
+\r
+uniform vec4 uColor;\r
+varying vec2 vRegion;\r
+varying float vTextureId;\r
+\r
+void main(void) {\r
+    vec4 color;\r
+    %GET_COLOR%\r
+    \r
+    gl_FragColor = color;\r
+}`, w = `precision lowp float;\r
+attribute vec2 aPosition;\r
+attribute vec2 aRegion;\r
+attribute float aTextureId;\r
+\r
+uniform mat4 uProjectionMatrix;\r
+varying vec2 vRegion;\r
+varying float vTextureId;\r
+\r
+void main(void) {\r
+    gl_Position = uProjectionMatrix * vec4(aPosition, 0.0, 1.0);\r
+    vRegion = aRegion;\r
+    vTextureId = aTextureId;\r
+}`;
+class N extends A {
+  constructor(e) {
+    super(e, 6, 4);
+  }
+  addObject(e) {
+    super.addObject(), this.push(e), this.push(e + 3), this.push(e + 2), this.push(e), this.push(e + 1), this.push(e + 2);
+  }
+}
+class M extends R {
+  constructor(t) {
+    super(t);
+    a(this, "objects", 0);
+    a(this, "usedTextures", []);
+    a(this, "elementArray", new N(this.gl));
+    a(this, "textureUnits");
+    const r = this.gl, i = 5 * Float32Array.BYTES_PER_ELEMENT;
+    this.createDefaultShader({
+      fs: this.generateFragShader(P, t.MAX_TEXTURE_IMAGE_UNITS),
+      vs: w,
+      attribute: [
+        { name: "aPosition", size: 2, type: r.FLOAT, stride: i },
+        { name: "aRegion", size: 2, type: r.FLOAT, stride: i, offset: 2 * Float32Array.BYTES_PER_ELEMENT },
+        { name: "aTextureId", size: 1, type: r.FLOAT, stride: i, offset: 4 * Float32Array.BYTES_PER_ELEMENT }
+      ]
+    }), this.textureUnits = Array.from({ length: t.MAX_TEXTURE_IMAGE_UNITS }, (h, n) => n);
+  }
+  addVertex(t, r, i, h, n) {
+    super.addVertex(t, r), this.attributeBuffer.push(i), this.attributeBuffer.push(h), this.attributeBuffer.push(n);
+  }
+  /**
+   * draw a sprite
+   * @param texture sprite texture 
+   * @param offsetX 
+   * @param offsetY 
+   */
+  drawSprite(t, r, i) {
+    this.objects > 10922 && this.flush();
+    const h = t.base, n = this.useTexture(h.texture);
+    this.objects++, this.elementArray.setObjects(this.objects), this.attributeBuffer.resize(2 * 6), this.addVertex(r, i, t.clipX, t.clipY, n), this.addVertex(r + t.width, i, t.clipW, t.clipY, n), this.addVertex(r + t.width, i + t.height, t.clipW, t.clipH, n), this.addVertex(r, i + t.height, t.clipX, t.clipH, n);
+  }
+  /**
+   * use a texture
+   * @return texture unit id
+   */
+  useTexture(t) {
+    let r = this.usedTextures.indexOf(t);
+    return r === -1 && (this.usedTextures.length >= this.render.MAX_TEXTURE_IMAGE_UNITS && this.flush(), this.usedTextures.push(t), r = this.usedTextures.length - 1), r;
+  }
+  /**
+   * render
+   */
+  doFlush() {
+    if (this.objects > 0) {
+      super.doFlush();
+      const t = this.gl;
+      for (let r = 0; r < this.usedTextures.length; r++) {
+        const i = this.usedTextures[r];
+        t.activeTexture(t.TEXTURE0 + r), t.bindTexture(t.TEXTURE_2D, i);
+      }
+      this.elementArray.bufferData(), t.drawElements(t.TRIANGLES, this.objects * 6, t.UNSIGNED_SHORT, 0);
+    }
+  }
+  /**
+   * reset this region
+   */
+  reset() {
+    super.reset(), this.elementArray.clear(), this.objects = 0, this.usedTextures = [];
+  }
+  /**
+   * enter this region
+   * @param shader costum shader
+   */
+  enter(t) {
+    super.enter(t);
+    const r = this.gl, i = r.getUniformLocation(this.shader, "uTextures");
+    r.uniform1iv(i, this.textureUnits), this.elementArray.bindBuffer();
+  }
+  /**
+   * Generate shader based on the maximum texture units supported by the GPU
+   * @param fs 
+   * @param max 
+   * @returns 
+   */
+  generateFragShader(t, r) {
+    let i = "";
+    t = t.replace("%TEXTURE_NUM%", r.toString());
+    for (let h = 0; h < r; h++)
+      h == 0 ? i += `if(vTextureId == ${h}.0)` : h == r - 1 ? i += "else" : i += `else if(vTextureId == ${h}.0)`, i += `{color = texture2D(uTextures[${h}], vRegion);}`;
+    return t = t.replace("%GET_COLOR%", i), t;
+  }
+}
+class U {
+  constructor(e) {
+    a(this, "render");
+    a(this, "cache", /* @__PURE__ */ new Map());
+    this.render = e;
+  }
+  /**
+   * create texture from url
+   * Equivalent to {@link Texture.fromUrl} method
+   * @param url 
+   * @param antialias 
+   * @returns 
+   */
+  async textureFromUrl(e, t = !1) {
+    let r = this.cache.get(e);
+    if (!r) {
+      const i = await this.loadImage(e);
+      r = u.fromImageSource(this.render, i, t), this.cache.set(e, r);
+    }
+    return new c(r);
+  }
+  async loadImage(e) {
+    return new Promise((t) => {
+      const r = new Image();
+      r.onload = () => {
+        t(r);
+      }, r.src = e;
+    });
+  }
+}
+class u {
+  constructor(e, t, r) {
+    a(this, "texture");
+    a(this, "width");
+    a(this, "height");
+    this.texture = e, this.width = t, this.height = r;
+  }
+  static fromImageSource(e, t, r = !1) {
+    return new u(
+      S(e.gl, t, r),
+      t.width,
+      t.height
+    );
+  }
+}
+class c {
+  /**
+   * Creates a new `Texture` instance with the specified base texture reference.
+   * @param base - The {@link BaseTexture} to be used by the texture.
+   */
+  constructor(e) {
+    /**
+     * Reference to the {@link BaseTexture} used by this texture.
+     */
+    a(this, "base");
+    /**
+     * The x-coordinate of the top-left corner of the clipped region.
+     */
+    a(this, "clipX");
+    /**
+     * The y-coordinate of the top-left corner of the clipped region.
+     */
+    a(this, "clipY");
+    /**
+     * The width of the clipped region.
+     */
+    a(this, "clipW");
+    /**
+     * The height of the clipped region.
+     */
+    a(this, "clipH");
+    /**
+     * The width of the texture.
+     */
+    a(this, "width");
+    /**
+     * The height of the texture.
+     */
+    a(this, "height");
+    this.base = e, this.setClipRegion(0, 0, e.width, e.height), console.log(this);
+  }
+  /**
+   * Sets the region of the texture to be used for rendering.
+   * @param x - The x-coordinate of the top-left corner of the region.
+   * @param y - The y-coordinate of the top-left corner of the region.
+   * @param w - The width of the region.
+   * @param h - The height of the region.
+   */
+  setClipRegion(e, t, r, i) {
+    this.clipX = e / this.base.width, this.clipY = t / this.base.width, this.clipW = this.clipX + r / this.base.width, this.clipH = this.clipY + i / this.base.width, this.width = r, this.height = i;
+  }
+  /**
+   * Creates a new `Texture` instance from the specified image source.
+   * @param rapid - The Rapid instance to use.
+   * @param image - The image source to create the texture from.
+   * @param antialias - Whether to enable antialiasing for the texture. Default is `false`.
+   * @returns A new `Texture` instance created from the image source.
+   */
+  static fromImageSource(e, t, r = !1) {
+    return new c(
+      u.fromImageSource(e, t, r)
+    );
+  }
+  /**
+   * Creates a new `Texture` instance from the specified URL.
+   * @param rapid - The Rapid instance to use.
+   * @param url - The URL of the image to create the texture from.
+   * @returns A new `Texture` instance created from the specified URL.
+   */
+  static fromUrl(e, t) {
+    return e.texture.textureFromUrl(t);
+  }
+}
+class C {
+  constructor(e) {
+    /**
+     * canvas element
+     */
+    a(this, "canvas");
+    /**
+     * WebGLContext
+     */
+    a(this, "gl");
+    /**
+     * projection matrix
+     */
+    a(this, "projection");
+    /**
+     * matrix stack
+     */
+    a(this, "matrix", new b());
+    /**
+     * texture manager
+     */
+    a(this, "texture", new U(this));
+    a(this, "devicePixelRatio");
+    a(this, "nativeWdith");
+    a(this, "nativeHeight");
+    /** background color */
+    a(this, "backgroundColor");
+    a(this, "currentRegion");
+    a(this, "regions", /* @__PURE__ */ new Map());
+    a(this, "MAX_TEXTURE_IMAGE_UNITS");
+    this.canvas = e.canvas;
+    const t = y(this.canvas);
+    this.gl = t, this.backgroundColor = e.backgroundColor || new o(0.2, 0.2, 0.2, 1), this.devicePixelRatio = e.pixelDensity || window.devicePixelRatio || 1, this.projection = this.createOrthMatrix(0, this.canvas.width, this.canvas.height, 0), this.nativeHeight = e.height || 500, this.nativeWdith = e.width || 500, this.updateNativeSize(), this.resize(), t.enable(t.BLEND), t.blendFunc(t.SRC_ALPHA, t.ONE_MINUS_SRC_ALPHA), this.MAX_TEXTURE_IMAGE_UNITS = this.gl.getParameter(this.gl.MAX_TEXTURE_IMAGE_UNITS), this.registerRegion("sprite", M), this.registerRegion("graphic", v);
+  }
+  /**
+   * register a region, use {@link setRegion} to use it
+   * @param name 
+   * @param region 
+   */
+  registerRegion(e, t) {
+    this.regions.set(e, new t(this));
+  }
+  /**
+   * Sets the current render region and its associated shader.
+   *
+   * @param regionName - The name of the render region to use.
+   * @param shader - The shader to use with the render region, or undefined to use the default shader.
+   */
+  setRegion(e, t) {
+    var i, h;
+    const r = this.regions.get(e);
+    (r != this.currentRegion || t && t !== this.currentRegion.shader) && ((i = this.currentRegion) == null || i.flush(), (h = this.currentRegion) == null || h.exit(), this.currentRegion = r, r.enter(t));
+  }
+  /**
+   * Draws a sprite on the screen.
+   *
+   * @param texture - The texture to use for the sprite.
+   * @param offsetX - The horizontal offset of the sprite from the origin.
+   * @param offsetY - The vertical offset of the sprite from the origin.
+   */
+  drawSprite(e, t = 0, r = 0, i) {
+    this.setRegion("sprite", i), this.currentRegion.drawSprite(e, t, r);
+  }
+  /**
+   * Draws a shape on the screen.
+   *
+   * @param vertexs - An array of vertex coordinates, where each vertex is a 2-element array of X and Y coordinates.
+   * @param color - The color of the shape
+   */
+  drawShape(e, t, r) {
+    this.setRegion("graphic", r), this.currentRegion.drawShape(e, t);
+  }
+  /**
+   * render
+   */
+  flush() {
+    this.currentRegion && this.currentRegion.flush();
+  }
+  /**
+   * Saves the current state
+   */
+  save() {
+    this.matrix.pushMat();
+  }
+  /**
+   * Call this before rendering
+   */
+  start() {
+    this.matrix.clear(), this.matrix.pushIdentity(), this.currentRegion = void 0, this.clear();
+  }
+  /**
+   * Call this after rendering
+   */
+  end() {
+    var e;
+    (e = this.currentRegion) == null || e.flush();
+  }
+  /**
+   * Restore to the previous saved state
+   */
+  restore() {
+    this.matrix.popMat();
+  }
+  /**
+   * clear the canvas
+   */
+  clear() {
+    const e = this.gl, t = this.backgroundColor;
+    e.clearColor(t.r, t.g, t.b, t.a), e.clear(e.COLOR_BUFFER_BIT);
+  }
+  resize() {
+    const e = this.canvas, t = this.devicePixelRatio;
+    e.width = this.nativeWdith * t, e.height = this.nativeHeight * t, this.gl.viewport(0, 0, e.width, e.height);
+  }
+  updateNativeSize() {
+    this.projection = this.createOrthMatrix(
+      0,
+      this.nativeWdith,
+      this.nativeHeight,
+      0
+    );
+  }
+  setNativeSize(e, t) {
+    this.nativeWdith = e / this.devicePixelRatio, this.nativeHeight = t / this.devicePixelRatio, this.updateNativeSize();
+  }
+  createOrthMatrix(e, t, r, i) {
+    return new Float32Array([
+      2 / (t - e),
+      0,
+      0,
+      0,
+      0,
+      2 / (i - r),
+      0,
+      0,
+      0,
+      0,
+      -1,
+      0,
+      -(t + e) / (t - e),
+      -(i + r) / (i - r),
+      0,
+      1
+    ]);
+  }
+  createShader(e, t) {
+    return m(this.gl, e, t);
+  }
+}
+export {
+  u as BaseTexture,
+  T as BufferArray,
+  o as Color,
+  p as DynamicArrayBuffer,
+  A as ElementArray,
+  v as GraphicRegion,
+  b as MatrixStack,
+  C as Rapid,
+  R as RenderRegion,
+  M as SpriteRegion,
+  c as Texture,
+  U as TextureCache,
+  f as compileShader,
+  m as createShaderProgram,
+  S as createTexture,
+  y as getContext
+};