@babylonjs/lite-gl 0.1.0 → 0.2.0

package/effect-BxxwfB_O.js

@@ -1,737 +0,0 @@
-import { A as createGLState, B as resetGLState, C as resetGLStateCache } from "./state--j_ncWIi.js";
-import { b as bindTexture } from "./texture-DaMd1gGm.js";
-function createGLEngine(canvas, options) {
-  const o = options ?? {};
-  const attrs = {
-    alpha: o.alpha ?? true,
-    premultipliedAlpha: o.premultipliedAlpha ?? true,
-    antialias: o.antialias ?? false,
-    preserveDrawingBuffer: o.preserveDrawingBuffer ?? false,
-    depth: o.depth ?? false,
-    stencil: o.stencil ?? false,
-    powerPreference: o.powerPreference ?? "default",
-    failIfMajorPerformanceCaveat: o.failIfMajorPerformanceCaveat ?? false
-  };
-  const gl = canvas.getContext("webgl2", attrs);
-  if (gl === null) {
-    throw new Error("lite-gl: WebGL2 is not supported on this canvas");
-  }
-  const parallelExt = gl.getExtension("KHR_parallel_shader_compile");
-  const colorBufferFloat = gl.getExtension("EXT_color_buffer_float") !== null;
-  const colorBufferHalfFloat = gl.getExtension("EXT_color_buffer_half_float") !== null;
-  const floatLinear = gl.getExtension("OES_texture_float_linear") !== null;
-  const caps = {
-    maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
-    maxTextureUnits: gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    parallelShaderCompile: parallelExt,
-    textureFloatRender: colorBufferFloat,
-    textureFloatLinearFiltering: floatLinear,
-    // In WebGL2, EXT_color_buffer_float also makes RGBA16F renderable; the
-    // half-float-only extension is the fallback for drivers exposing just it.
-    textureHalfFloatRender: colorBufferFloat || colorBufferHalfFloat,
-    // Half-float linear filtering is core in WebGL2 (no extension needed).
-    textureHalfFloatLinearFiltering: true,
-    // NPOT textures are core in WebGL2 — mips/wrap work at any size.
-    needPOTTextures: false
-  };
-  const engine = {
-    canvas,
-    gl,
-    caps,
-    _hsl: 1,
-    _rafId: 0,
-    _loops: [],
-    _prevNow: 0,
-    _state: createGLState(caps.maxTextureUnits),
-    _effects: [],
-    _effectCache: /* @__PURE__ */ new Map(),
-    _textures: [],
-    _renderTargets: [],
-    _currentRenderTarget: null,
-    _buffers: [],
-    _onLost: [],
-    _onRestored: [],
-    _isLost: false,
-    _disposed: false,
-    _lostHandler: () => {
-    },
-    _restoredHandler: () => {
-    },
-    _wasLoopActive: false,
-    _scheduleFrame: null
-  };
-  engine._lostHandler = (e) => handleContextLost(engine, e);
-  engine._restoredHandler = () => handleContextRestored(engine);
-  canvas.addEventListener("webglcontextlost", engine._lostHandler, false);
-  canvas.addEventListener("webglcontextrestored", engine._restoredHandler, false);
-  return engine;
-}
-function disposeGLEngine(engine) {
-  if (engine._disposed) {
-    return;
-  }
-  engine._disposed = true;
-  if (engine._rafId !== 0) {
-    cancelAnimationFrame(engine._rafId);
-    engine._rafId = 0;
-  }
-  engine._loops.length = 0;
-  engine.canvas.removeEventListener("webglcontextlost", engine._lostHandler, false);
-  engine.canvas.removeEventListener("webglcontextrestored", engine._restoredHandler, false);
-  const gl = engine.gl;
-  const effects = engine._effects.slice();
-  for (const eff of effects) {
-    if (!eff._disposed) {
-      eff._disposed = true;
-      eff.isReady = false;
-      gl.deleteProgram(eff.program);
-      gl.deleteShader(eff._vs);
-      gl.deleteShader(eff._fs);
-    }
-  }
-  engine._effects.length = 0;
-  engine._effectCache.clear();
-  const textures = engine._textures.slice();
-  for (const tex of textures) {
-    if (!tex._disposed) {
-      tex._disposed = true;
-      gl.deleteTexture(tex.handle);
-    }
-  }
-  engine._textures.length = 0;
-  const rts = engine._renderTargets.slice();
-  for (const rt of rts) {
-    if (!rt._disposed) {
-      rt._disposed = true;
-      rt._deleteGpu(gl);
-    }
-  }
-  engine._renderTargets.length = 0;
-  const buffers = engine._buffers.slice();
-  for (const buf of buffers) {
-    if (!buf._disposed) {
-      buf._disposed = true;
-      buf._deleteGpu(gl);
-    }
-  }
-  engine._buffers.length = 0;
-  resetGLState(engine._state);
-  engine._currentRenderTarget = null;
-  engine._onLost.length = 0;
-  engine._onRestored.length = 0;
-}
-function resizeGLEngine(engine) {
-  if (engine._disposed || engine._isLost) {
-    return;
-  }
-  const canvas = engine.canvas;
-  if (!("clientWidth" in canvas)) {
-    return;
-  }
-  const dpr = typeof devicePixelRatio === "number" ? devicePixelRatio : 1;
-  const w = Math.max(1, Math.floor(canvas.clientWidth * dpr / engine._hsl));
-  const h = Math.max(1, Math.floor(canvas.clientHeight * dpr / engine._hsl));
-  if (canvas.width !== w) {
-    canvas.width = w;
-  }
-  if (canvas.height !== h) {
-    canvas.height = h;
-  }
-}
-function setGLEngineSize(engine, width, height) {
-  if (engine._disposed) {
-    return;
-  }
-  const canvas = engine.canvas;
-  const w = Math.max(1, Math.floor(width / engine._hsl));
-  const h = Math.max(1, Math.floor(height / engine._hsl));
-  if (canvas.width !== w) {
-    canvas.width = w;
-  }
-  if (canvas.height !== h) {
-    canvas.height = h;
-  }
-}
-function wipeGLStateCache(engine) {
-  if (engine._disposed || engine._isLost) {
-    return;
-  }
-  resetGLStateCache(engine._state);
-}
-function getRenderWidth(engine) {
-  return engine.canvas.width;
-}
-function getRenderHeight(engine) {
-  return engine.canvas.height;
-}
-function getHardwareScalingLevel(engine) {
-  return engine._hsl;
-}
-function setHardwareScalingLevel(engine, level) {
-  if (level <= 0 || !isFinite(level)) {
-    return;
-  }
-  engine._hsl = level;
-  resizeGLEngine(engine);
-}
-function getRenderingCanvas(engine) {
-  return engine.canvas;
-}
-function onContextLost(engine, cb) {
-  if (engine._onLost.indexOf(cb) === -1) {
-    engine._onLost.push(cb);
-  }
-}
-function offContextLost(engine, cb) {
-  const i = engine._onLost.indexOf(cb);
-  if (i !== -1) {
-    engine._onLost.splice(i, 1);
-  }
-}
-function onContextRestored(engine, cb) {
-  if (engine._onRestored.indexOf(cb) === -1) {
-    engine._onRestored.push(cb);
-  }
-}
-function offContextRestored(engine, cb) {
-  const i = engine._onRestored.indexOf(cb);
-  if (i !== -1) {
-    engine._onRestored.splice(i, 1);
-  }
-}
-function handleContextLost(engine, e) {
-  e.preventDefault();
-  if (engine._isLost || engine._disposed) {
-    return;
-  }
-  engine._isLost = true;
-  engine._wasLoopActive = engine._rafId !== 0;
-  if (engine._rafId !== 0) {
-    cancelAnimationFrame(engine._rafId);
-    engine._rafId = 0;
-  }
-  resetGLState(engine._state);
-  engine._currentRenderTarget = null;
-  for (const eff of engine._effects) {
-    eff.isReady = false;
-    eff._samplersAssigned = false;
-    eff.uniformLocations = {};
-    eff.attributeLocations = {};
-    clearObject(eff._lastF1);
-    clearObject(eff._lastVec);
-    clearObject(eff._lastI1);
-  }
-  for (const tex of engine._textures) {
-    tex._wasReady = tex.isReady;
-    tex.isReady = false;
-  }
-  const cbs = engine._onLost.slice();
-  for (const cb of cbs) {
-    try {
-      cb();
-    } catch (err) {
-      console.error("lite-gl: onLost callback threw", err);
-    }
-  }
-}
-function handleContextRestored(engine) {
-  if (engine._disposed) {
-    return;
-  }
-  for (const eff of engine._effects) {
-    if (!eff._disposed) {
-      eff._restore(engine);
-    }
-  }
-  for (const tex of engine._textures) {
-    if (!tex._disposed) {
-      const newHandle = engine.gl.createTexture();
-      if (newHandle !== null) {
-        tex.handle = newHandle;
-        tex._upload(engine);
-        tex.isReady = tex._wasReady;
-      }
-    }
-  }
-  engine._isLost = false;
-  for (const rt of engine._renderTargets) {
-    if (!rt._disposed) {
-      rt._restore(engine);
-    }
-  }
-  for (const buf of engine._buffers) {
-    if (!buf._disposed) {
-      buf._restore(engine);
-    }
-  }
-  if (engine._wasLoopActive && engine._loops.length > 0 && engine._scheduleFrame !== null) {
-    engine._scheduleFrame(engine);
-  }
-  const cbs = engine._onRestored.slice();
-  for (const cb of cbs) {
-    try {
-      cb();
-    } catch (err) {
-      console.error("lite-gl: onRestored callback threw", err);
-    }
-  }
-}
-function clearObject(o) {
-  for (const key in o) {
-    delete o[key];
-  }
-}
-function compileShader(gl, source, stage, errorOut) {
-  const shader = gl.createShader(stage);
-  if (shader === null) {
-    errorOut[0] = "gl.createShader returned null";
-    return null;
-  }
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    errorOut[0] = gl.getShaderInfoLog(shader) ?? "shader compile failed";
-    gl.deleteShader(shader);
-    return null;
-  }
-  return shader;
-}
-function linkProgram(gl, vs, fs, attributeNames) {
-  const program = gl.createProgram();
-  if (program === null) {
-    return null;
-  }
-  gl.attachShader(program, vs);
-  gl.attachShader(program, fs);
-  for (let i = 0; i < attributeNames.length; i++) {
-    const name = attributeNames[i];
-    if (name !== void 0) {
-      gl.bindAttribLocation(program, i, name);
-    }
-  }
-  gl.linkProgram(program);
-  return program;
-}
-function isLinkComplete(gl, program, parallel) {
-  if (parallel === null) {
-    return true;
-  }
-  return Boolean(gl.getProgramParameter(program, parallel.COMPLETION_STATUS_KHR));
-}
-function getLinkError(gl, program) {
-  if (gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    return null;
-  }
-  return gl.getProgramInfoLog(program) ?? "link failed";
-}
-function createEffect(engine, options) {
-  const attribs = options.attributeNames ?? ["position"];
-  const gl = engine.gl;
-  const cacheKey = [options.vertexSource, options.fragmentSource, options.defines ?? "", attribs.join(","), options.uniformNames.join(","), options.samplerNames.join(",")].join(
-    "\0"
-  );
-  const cached = engine._effectCache.get(cacheKey);
-  if (cached !== void 0 && !cached._disposed) {
-    cached._refCount++;
-    return cached;
-  }
-  const compileErr = [null];
-  const finalVS = applyDefines(options.vertexSource, options.defines);
-  const finalFS = applyDefines(options.fragmentSource, options.defines);
-  const vs = compileShader(gl, finalVS, gl.VERTEX_SHADER, compileErr);
-  if (vs === null) {
-    throw new Error(`lite-gl: ${options.name} vertex compile failed: ${compileErr[0] ?? "unknown"}`);
-  }
-  const fs = compileShader(gl, finalFS, gl.FRAGMENT_SHADER, compileErr);
-  if (fs === null) {
-    gl.deleteShader(vs);
-    throw new Error(`lite-gl: ${options.name} fragment compile failed: ${compileErr[0] ?? "unknown"}`);
-  }
-  const program = linkProgram(gl, vs, fs, attribs);
-  if (program === null) {
-    gl.deleteShader(vs);
-    gl.deleteShader(fs);
-    throw new Error(`lite-gl: ${options.name} program allocation failed`);
-  }
-  const effect = {
-    name: options.name,
-    options,
-    program,
-    _vs: vs,
-    _fs: fs,
-    uniformLocations: {},
-    samplerUnits: {},
-    _samplersAssigned: false,
-    attributeLocations: {},
-    _lastF1: {},
-    _lastVec: {},
-    _lastI1: {},
-    isReady: false,
-    _compileError: null,
-    _disposed: false,
-    _refCount: 1,
-    _cacheKey: cacheKey,
-    _onCompiled: [],
-    _restore: () => {
-    }
-  };
-  effect._restore = (target) => {
-    const g = target.gl;
-    const newVS = compileShader(g, applyDefines(options.vertexSource, options.defines), g.VERTEX_SHADER, [null]);
-    const newFS = compileShader(g, applyDefines(options.fragmentSource, options.defines), g.FRAGMENT_SHADER, [null]);
-    if (newVS === null || newFS === null) {
-      effect._compileError = "context-restore: shader compile failed";
-      return;
-    }
-    const newProg = linkProgram(g, newVS, newFS, attribs);
-    if (newProg === null) {
-      g.deleteShader(newVS);
-      g.deleteShader(newFS);
-      effect._compileError = "context-restore: program allocation failed";
-      return;
-    }
-    effect.program = newProg;
-    effect._vs = newVS;
-    effect._fs = newFS;
-    effect.isReady = false;
-    effect._samplersAssigned = false;
-    effect.uniformLocations = {};
-    effect.attributeLocations = {};
-    effect._compileError = null;
-  };
-  engine._effects.push(effect);
-  engine._effectCache.set(cacheKey, effect);
-  return effect;
-}
-function isEffectReady(engine, effect) {
-  if (effect.isReady) {
-    return true;
-  }
-  if (effect._disposed || engine._isLost || engine._disposed) {
-    return false;
-  }
-  if (effect._compileError !== null) {
-    return false;
-  }
-  if (!isLinkComplete(engine.gl, effect.program, engine.caps.parallelShaderCompile)) {
-    return false;
-  }
-  const linkErr = getLinkError(engine.gl, effect.program);
-  if (linkErr !== null) {
-    effect._compileError = linkErr;
-    console.error(`lite-gl: ${effect.name} link failed:`, linkErr);
-    return false;
-  }
-  finalizeEffect(engine, effect);
-  return true;
-}
-function finalizeEffect(engine, effect) {
-  const gl = engine.gl;
-  const program = effect.program;
-  for (const name of effect.options.uniformNames) {
-    effect.uniformLocations[name] = gl.getUniformLocation(program, name);
-  }
-  const attribs = effect.options.attributeNames ?? ["position"];
-  for (const name of attribs) {
-    effect.attributeLocations[name] = gl.getAttribLocation(program, name);
-  }
-  useEffect(engine, effect);
-  let unit = 0;
-  for (const name of effect.options.samplerNames) {
-    const loc = gl.getUniformLocation(program, name);
-    if (loc !== null) {
-      gl.uniform1i(loc, unit);
-    }
-    effect.samplerUnits[name] = unit;
-    unit++;
-  }
-  effect._samplersAssigned = true;
-  effect.isReady = true;
-  const cbs = effect._onCompiled.slice();
-  effect._onCompiled.length = 0;
-  for (const cb of cbs) {
-    try {
-      cb(effect);
-    } catch (err) {
-      console.error(`lite-gl: ${effect.name} onCompiled callback threw`, err);
-    }
-  }
-}
-function executeWhenCompiled(engine, effect, cb) {
-  if (isEffectReady(engine, effect)) {
-    cb(effect);
-    return;
-  }
-  effect._onCompiled.push(cb);
-}
-function disposeEffect(engine, effect) {
-  if (effect._disposed) {
-    return;
-  }
-  if (--effect._refCount > 0) {
-    return;
-  }
-  effect._disposed = true;
-  effect.isReady = false;
-  const i = engine._effects.indexOf(effect);
-  if (i !== -1) {
-    engine._effects.splice(i, 1);
-  }
-  engine._effectCache.delete(effect._cacheKey);
-  if (!engine._isLost && !engine._disposed) {
-    engine.gl.deleteProgram(effect.program);
-    engine.gl.deleteShader(effect._vs);
-    engine.gl.deleteShader(effect._fs);
-  }
-  if (engine._state.currentProgram === effect.program) {
-    engine._state.currentProgram = null;
-  }
-  effect._onCompiled.length = 0;
-}
-function useEffect(engine, effect) {
-  if (engine._isLost || engine._disposed || effect._disposed) {
-    return;
-  }
-  if (engine._state.currentProgram === effect.program) {
-    return;
-  }
-  engine.gl.useProgram(effect.program);
-  engine._state.currentProgram = effect.program;
-}
-function setEffectFloat(engine, effect, name, x) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  if (effect._lastF1[name] === x) {
-    return;
-  }
-  effect._lastF1[name] = x;
-  engine.gl.uniform1f(loc, x);
-}
-function setEffectFloat2(engine, effect, name, x, y) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  let v = effect._lastVec[name];
-  if (v !== void 0 && v[0] === x && v[1] === y) {
-    return;
-  }
-  if (v === void 0) {
-    v = [x, y];
-    effect._lastVec[name] = v;
-  } else {
-    v[0] = x;
-    v[1] = y;
-  }
-  engine.gl.uniform2f(loc, x, y);
-}
-function setEffectFloat3(engine, effect, name, x, y, z) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  let v = effect._lastVec[name];
-  if (v !== void 0 && v[0] === x && v[1] === y && v[2] === z) {
-    return;
-  }
-  if (v === void 0) {
-    v = [x, y, z];
-    effect._lastVec[name] = v;
-  } else {
-    v[0] = x;
-    v[1] = y;
-    v[2] = z;
-  }
-  engine.gl.uniform3f(loc, x, y, z);
-}
-function setEffectFloat4(engine, effect, name, x, y, z, w) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  let v = effect._lastVec[name];
-  if (v !== void 0 && v[0] === x && v[1] === y && v[2] === z && v[3] === w) {
-    return;
-  }
-  if (v === void 0) {
-    v = [x, y, z, w];
-    effect._lastVec[name] = v;
-  } else {
-    v[0] = x;
-    v[1] = y;
-    v[2] = z;
-    v[3] = w;
-  }
-  engine.gl.uniform4f(loc, x, y, z, w);
-}
-function setEffectColor3(engine, effect, name, c) {
-  setEffectFloat3(engine, effect, name, c.r, c.g, c.b);
-}
-function setEffectColor4(engine, effect, name, c) {
-  setEffectFloat4(engine, effect, name, c.r, c.g, c.b, c.a);
-}
-function setEffectVector2(engine, effect, name, v) {
-  setEffectFloat2(engine, effect, name, v.x, v.y);
-}
-function setEffectDirectColor4(engine, effect, name, c) {
-  setEffectFloat4(engine, effect, name, c.r, c.g, c.b, c.a);
-}
-function setEffectInt(engine, effect, name, x) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  if (effect._lastI1[name] === x) {
-    return;
-  }
-  effect._lastI1[name] = x;
-  engine.gl.uniform1i(loc, x);
-}
-function setEffectMatrix(engine, effect, name, matrix) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  engine.gl.uniformMatrix4fv(loc, false, matrix);
-}
-function setEffectMatrix3x3(engine, effect, name, matrix) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  engine.gl.uniformMatrix3fv(loc, false, matrix);
-}
-function setEffectFloatArray(engine, effect, name, array) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  engine.gl.uniform1fv(loc, array);
-}
-function setEffectFloatArray4(engine, effect, name, array) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  engine.gl.uniform4fv(loc, array);
-}
-function setEffectIntArray(engine, effect, name, array) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const loc = effect.uniformLocations[name];
-  if (loc === null || loc === void 0) {
-    return;
-  }
-  engine.gl.uniform1iv(loc, array);
-}
-function setEffectTexture(engine, effect, samplerName, tex) {
-  if (engine._isLost || !effect.isReady) {
-    return;
-  }
-  const unit = effect.samplerUnits[samplerName];
-  if (unit === void 0) {
-    return;
-  }
-  bindTexture(engine, unit, tex);
-}
-function getEffectAttributeLocation(engine, effect, name) {
-  const cached = effect.attributeLocations[name];
-  if (cached !== void 0) {
-    return cached;
-  }
-  const loc = engine.gl.getAttribLocation(effect.program, name);
-  effect.attributeLocations[name] = loc;
-  return loc;
-}
-function applyDefines(source, defines) {
-  if (defines === void 0 || defines.length === 0) {
-    return source;
-  }
-  const marker = "// __DEFINES__";
-  const idx = source.indexOf(marker);
-  if (idx !== -1) {
-    return source.slice(0, idx) + defines + source.slice(idx + marker.length);
-  }
-  const lines = source.split("\n");
-  let insertAt = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line === void 0) {
-      continue;
-    }
-    const trimmed = line.trim();
-    if (trimmed.startsWith("#version") || trimmed.startsWith("precision ")) {
-      insertAt = i + 1;
-    }
-  }
-  lines.splice(insertAt, 0, defines);
-  return lines.join("\n");
-}
-export {
-  setEffectIntArray as A,
-  setEffectMatrix as B,
-  setEffectMatrix3x3 as C,
-  setEffectTexture as D,
-  setEffectVector2 as E,
-  setGLEngineSize as F,
-  setHardwareScalingLevel as G,
-  wipeGLStateCache as H,
-  getEffectAttributeLocation as I,
-  createGLEngine as a,
-  disposeGLEngine as b,
-  createEffect as c,
-  disposeEffect as d,
-  executeWhenCompiled as e,
-  getRenderHeight as f,
-  getHardwareScalingLevel as g,
-  getRenderWidth as h,
-  getRenderingCanvas as i,
-  isEffectReady as j,
-  offContextRestored as k,
-  onContextLost as l,
-  onContextRestored as m,
-  setEffectColor4 as n,
-  offContextLost as o,
-  setEffectDirectColor4 as p,
-  setEffectFloat as q,
-  resizeGLEngine as r,
-  setEffectColor3 as s,
-  setEffectFloat2 as t,
-  useEffect as u,
-  setEffectFloat3 as v,
-  setEffectFloat4 as w,
-  setEffectFloatArray as x,
-  setEffectFloatArray4 as y,
-  setEffectInt as z
-};
-//# sourceMappingURL=effect-BxxwfB_O.js.map