@fonsecabarreto/genesis-gl-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucas Fonseca Barreto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# GenesisGL
+
+GenesisGL is a lightweight browser-side WebGL 3D engine written in TypeScript.
+
+## Installation
+
+```bash
+npm install @fonsecabarreto/genesis-gl-core
+```
+
+## Usage
+
+```ts
+import { WebGLCore, Scene, Renderer, Viewport } from '@fonsecabarreto/genesis-gl-core';
+
+const canvas = document.getElementById('glcanvas') as HTMLCanvasElement;
+const webglCore = new WebGLCore(canvas);
+const viewport = new Viewport(canvas, window.innerWidth, window.innerHeight, webglCore);
+const renderer = new Renderer(webglCore, viewport);
+const scene = Scene.withDefaultLights(webglCore);
+
+// Add models and render loop...
+```
+
+## Build
+
+```bash
+yarn build
+```
+
+## License
+
+MIT

package/dist/Camera-DY_8gx3C.d.ts

@@ -0,0 +1,45 @@
+import { vec3, mat4 } from 'gl-matrix';
+import { Vector3 } from './Core/domain/interfaces/Vectors.js';
+
+/**
+ * Perspective camera with orbit (yaw/pitch), zoom, and viewport controls.
+ */
+declare class Camera {
+    viewportWidth: number;
+    viewportHeight: number;
+    target: Vector3;
+    position: Vector3;
+    zoom: number;
+    minZoom: number;
+    maxZoom: number;
+    zoomSpeed: number;
+    yaw: number;
+    pitch: number;
+    near: number;
+    far: number;
+    lastViewMatrix?: Float32Array;
+    lastProjectionMatrix?: Float32Array;
+    constructor(viewportWidth: number, viewportHeight: number);
+    /** Translate the camera by a delta. */
+    move(dx: number, dy: number, dz?: number): void;
+    /** Clamp-set the zoom level. */
+    setZoom(zoom: number): void;
+    /** Zoom by a signed delta (positive = zoom in). */
+    zoomBy(delta: number): void;
+    worldToNDC(x: number, y: number): [number, number];
+    worldScale(scale: [number, number]): [number, number];
+    setViewport(width: number, height: number): void;
+    /** Compute the eye position from yaw/pitch/distance to target. */
+    getComputedPosition(): vec3;
+    /** Build the view matrix (lookAt). */
+    getViewMatrix(): mat4;
+    /** Build the perspective projection matrix. */
+    getProjectionMatrix(): mat4;
+    worldToNDC3D(x: number, y: number, z?: number): [number, number, number];
+    worldScale3D(scale: [number, number, number]): [number, number, number];
+    minPitch: number;
+    maxPitch: number;
+    rotate(deltaYaw: number, deltaPitch: number): void;
+}
+
+export { Camera as C };

package/dist/Core/classes/Material.d.ts

@@ -0,0 +1,3 @@
+import '../domain/interfaces/Vectors.js';
+export { M as MAX_LIGHTS, b as Material } from '../../Material-BGLkldxv.js';
+import '../../WebGLCore-DR7ZHJB0.js';

package/dist/Core/classes/Material.js

@@ -0,0 +1,9 @@
+import {
+  MAX_LIGHTS,
+  Material
+} from "../../chunk-6LS6AO5H.js";
+export {
+  MAX_LIGHTS,
+  Material
+};
+//# sourceMappingURL=Material.js.map

package/dist/Core/classes/Material.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/classes/Model.d.ts

@@ -0,0 +1,5 @@
+export { i as Model } from '../../Model-CQvDXd-b.js';
+import '../domain/interfaces/Vectors.js';
+import '../../WebGLCore-DR7ZHJB0.js';
+import '../../Material-BGLkldxv.js';
+import 'gl-matrix';

package/dist/Core/classes/Model.js

@@ -0,0 +1,7 @@
+import {
+  Model
+} from "../../chunk-JK2HEZAT.js";
+export {
+  Model
+};
+//# sourceMappingURL=Model.js.map

package/dist/Core/classes/Model.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/classes/Renderer.d.ts

@@ -0,0 +1,30 @@
+import { mat4 } from 'gl-matrix';
+import { W as WebGLCore } from '../../WebGLCore-DR7ZHJB0.js';
+import { Scene } from './Scene.js';
+import { i as Model } from '../../Model-CQvDXd-b.js';
+import { Viewport } from './Viewport.js';
+import '../../Material-BGLkldxv.js';
+import '../domain/interfaces/Vectors.js';
+import '../../Camera-DY_8gx3C.js';
+
+declare class Renderer {
+    private webglCore;
+    viewport: Viewport;
+    /** Set to `true` to render wireframe bounding boxes for debugging. */
+    debug: boolean;
+    private _modelHitboxMaterial;
+    private _meshHitboxMaterial;
+    constructor(webglCore: WebGLCore, viewport: Viewport);
+    /** Lazily-created material for model-level hitboxes (red). */
+    private get modelHitboxMaterial();
+    /** Lazily-created material for mesh-level hitboxes (green). */
+    private get meshHitboxMaterial();
+    clearFrame(color?: [number, number, number, number]): void;
+    render(scene: Scene): void;
+    private drawModel;
+    private drawMesh;
+    drawHitBox(model: Model, modelMatrix: mat4, activeProgram: WebGLProgram | null): void;
+    private drawHitBoxForMesh;
+}
+
+export { Renderer };

package/dist/Core/classes/Renderer.js

@@ -0,0 +1,11 @@
+import {
+  Renderer
+} from "../../chunk-QCQVJCSR.js";
+import "../../chunk-6LS6AO5H.js";
+import "../../chunk-JK2HEZAT.js";
+import "../../chunk-3ULETMWF.js";
+import "../../chunk-5TAAXI6S.js";
+export {
+  Renderer
+};
+//# sourceMappingURL=Renderer.js.map

package/dist/Core/classes/Renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/classes/Scene.d.ts

@@ -0,0 +1,37 @@
+import { L as Light } from '../../Material-BGLkldxv.js';
+import { i as Model } from '../../Model-CQvDXd-b.js';
+import { W as WebGLCore } from '../../WebGLCore-DR7ZHJB0.js';
+import '../domain/interfaces/Vectors.js';
+import 'gl-matrix';
+
+declare class Scene {
+    private webglCore;
+    private models;
+    private modelsMap;
+    lights: Light[];
+    constructor(webglCore: WebGLCore);
+    /**
+     * Create a Scene pre-loaded with a classic **3-point lighting** rig
+     * (ambient + key + fill + back).
+     *
+     * Use this for quick prototyping; for production, create a plain Scene and
+     * add your own lights.
+     */
+    static withDefaultLights(webglCore: WebGLCore): Scene;
+    /** Register a light source in the scene. */
+    addLight(id: string, light: Light): void;
+    /** Add a model to the scene with a unique key. */
+    add(id: string, model: Model): void;
+    /** Remove a model from the scene by key. */
+    remove(key: string): void;
+    getModels(): Model[];
+    getLights(): Light[];
+    /** Retrieve a model by its key. */
+    getModel(key: string): Model | undefined;
+    hasMesh(key: string): boolean;
+    /** Returns all [id, model] pairs — useful for debug/inspector tools. */
+    getEntries(): [string, Model][];
+    dispose(webglCore: WebGLCore): void;
+}
+
+export { Scene };

package/dist/Core/classes/Scene.js

@@ -0,0 +1,7 @@
+import {
+  Scene
+} from "../../chunk-3ULETMWF.js";
+export {
+  Scene
+};
+//# sourceMappingURL=Scene.js.map

package/dist/Core/classes/Scene.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/classes/Viewport.d.ts

@@ -0,0 +1,37 @@
+import { C as Camera } from '../../Camera-DY_8gx3C.js';
+import { W as WebGLCore } from '../../WebGLCore-DR7ZHJB0.js';
+import 'gl-matrix';
+import '../domain/interfaces/Vectors.js';
+
+declare class Viewport {
+    width: number;
+    height: number;
+    private static zoomInterval;
+    private wheelControl;
+    private dragControl;
+    private moveControl;
+    private lastZoomTime;
+    private canvas;
+    private scale;
+    private webglCore;
+    private resizeHandler;
+    camera: Camera;
+    /**
+     * @param canvasOrId - An HTMLCanvasElement or the `id` attribute of one.
+     * @param width      - Logical viewport width.
+     * @param height     - Logical viewport height.
+     * @param webglCore  - Optional WebGLCore instance. When provided, the existing
+     *                     GL context is reused for viewport resize instead of
+     *                     requesting a new one.
+     */
+    constructor(canvasOrId: string | HTMLCanvasElement, width: number, height: number, webglCore?: WebGLCore);
+    private setupControls;
+    isDraggingCamera(): boolean;
+    private resizeCanvas;
+    getCanvas(): HTMLCanvasElement;
+    getScale(): number;
+    /** Release event listeners. Call when the viewport is no longer needed. */
+    dispose(): void;
+}
+
+export { Viewport };

package/dist/Core/classes/Viewport.js

@@ -0,0 +1,7 @@
+import {
+  Viewport
+} from "../../chunk-5TAAXI6S.js";
+export {
+  Viewport
+};
+//# sourceMappingURL=Viewport.js.map

package/dist/Core/classes/Viewport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/domain/interfaces/Vectors.d.ts

@@ -0,0 +1,4 @@
+type Vector3 = [number, number, number];
+type Vector4 = [number, number, number, number];
+
+export type { Vector3, Vector4 };

package/dist/Core/domain/interfaces/Vectors.js

@@ -0,0 +1 @@
+//# sourceMappingURL=Vectors.js.map

package/dist/Core/domain/interfaces/Vectors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/index.d.ts

@@ -0,0 +1,10 @@
+export { A as AnimationChannel, a as AnimationClip, b as AnimationPath, c as AnimationSampler, G as GL_LINES, d as GL_TRIANGLES, I as INITIAL_BOUNDING_BOX, e as InterpolationMode, J as Joint, f as JointPose, M as MAX_JOINTS, g as Mesh, h as MeshBuffers, i as Model, S as Skeleton } from '../Model-CQvDXd-b.js';
+export { R as RenderCallback, W as WebGLCore } from '../WebGLCore-DR7ZHJB0.js';
+export { C as Camera } from '../Camera-DY_8gx3C.js';
+export { L as Light, a as LightType, M as MAX_LIGHTS, b as Material } from '../Material-BGLkldxv.js';
+export { Renderer } from './classes/Renderer.js';
+export { Scene } from './classes/Scene.js';
+export { Viewport } from './classes/Viewport.js';
+export { K as KeyboardControl } from '../KeyboardControl-5w7Vm0J0.js';
+import './domain/interfaces/Vectors.js';
+import 'gl-matrix';

package/dist/Core/index.js

@@ -0,0 +1,51 @@
+import {
+  KeyboardControl
+} from "../chunk-SUNYSY45.js";
+import {
+  AnimationClip,
+  GL_LINES,
+  GL_TRIANGLES,
+  INITIAL_BOUNDING_BOX,
+  MAX_JOINTS,
+  Mesh,
+  MeshBuffers,
+  Renderer,
+  Skeleton,
+  WebGLCore
+} from "../chunk-QCQVJCSR.js";
+import {
+  MAX_LIGHTS,
+  Material
+} from "../chunk-6LS6AO5H.js";
+import {
+  Model
+} from "../chunk-JK2HEZAT.js";
+import {
+  Light,
+  Scene
+} from "../chunk-3ULETMWF.js";
+import {
+  Camera,
+  Viewport
+} from "../chunk-5TAAXI6S.js";
+export {
+  AnimationClip,
+  Camera,
+  GL_LINES,
+  GL_TRIANGLES,
+  INITIAL_BOUNDING_BOX,
+  KeyboardControl,
+  Light,
+  MAX_JOINTS,
+  MAX_LIGHTS,
+  Material,
+  Mesh,
+  MeshBuffers,
+  Model,
+  Renderer,
+  Scene,
+  Skeleton,
+  Viewport,
+  WebGLCore
+};
+//# sourceMappingURL=index.js.map

package/dist/Core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Core/utils/get-overlap.d.ts

@@ -0,0 +1,3 @@
+declare function getOverlap(min1: number, max1: number, min2: number, max2: number): number;
+
+export { getOverlap };

package/dist/Core/utils/get-overlap.js

@@ -0,0 +1,11 @@
+// src/Core/utils/get-overlap.ts
+function getOverlap(min1, max1, min2, max2) {
+  if (max1 <= min2 || max2 <= min1) return 0;
+  const dist1 = max2 - min1;
+  const dist2 = min2 - max1;
+  return Math.abs(dist1) < Math.abs(dist2) ? dist1 : dist2;
+}
+export {
+  getOverlap
+};
+//# sourceMappingURL=get-overlap.js.map

package/dist/Core/utils/get-overlap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/Core/utils/get-overlap.ts"],"sourcesContent":["export function getOverlap(\n  min1: number,\n  max1: number,\n  min2: number,\n  max2: number,\n): number {\n  // No overlap (they are separated)\n  if (max1 <= min2 || max2 <= min1) return 0;\n\n  // Calculate the distance from mesh1's minimum to mesh2's maximum\n  const dist1 = max2 - min1;\n  // Calculate the distance from mesh2's minimum to mesh1's maximum\n  const dist2 = min2 - max1;\n\n  // Return the overlap that requires the smallest movement (smallest absolute value)\n  // The sign indicates the direction of movement.\n  return Math.abs(dist1) < Math.abs(dist2) ? dist1 : dist2;\n}\n"],"mappings":";AAAO,SAAS,WACd,MACA,MACA,MACA,MACQ;AAER,MAAI,QAAQ,QAAQ,QAAQ,KAAM,QAAO;AAGzC,QAAM,QAAQ,OAAO;AAErB,QAAM,QAAQ,OAAO;AAIrB,SAAO,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,QAAQ;AACrD;","names":[]}

package/dist/Core/utils/load-glb.d.ts

@@ -0,0 +1,101 @@
+import { W as WebGLCore } from '../../WebGLCore-DR7ZHJB0.js';
+import { i as Model, S as Skeleton, a as AnimationClip } from '../../Model-CQvDXd-b.js';
+import '../domain/interfaces/Vectors.js';
+import '../../Material-BGLkldxv.js';
+import 'gl-matrix';
+
+/** Everything parsed from a GLB file. */
+interface GLBLoadResult {
+    /** The composed model with all meshes. */
+    model: Model;
+    /** Skeleton (if the GLB contains a skin). */
+    skeleton: Skeleton | null;
+    /** Named animation clips (if the GLB contains animations). */
+    animations: Map<string, AnimationClip>;
+}
+/**
+ * Professional GLB (binary glTF 2.0) loader for the GenesisGL engine.
+ *
+ * Handles:
+ * - Strongly-typed glTF JSON parsing (no `any`)
+ * - Full PBR material extraction (base colour, textures, alpha, double-sided)
+ * - Embedded texture decoding from binary chunk
+ * - Complete node hierarchy traversal
+ * - Skeletal mesh data (JOINTS_0 / WEIGHTS_0)
+ * - Skin parsing (inverse bind matrices + joint hierarchy)
+ * - Animation parsing (TRS channels with LINEAR/STEP interpolation)
+ *
+ * @example
+ * ```ts
+ * const loader = new GLBLoader(core);
+ * const { model, skeleton, animations } = await loader.load('/models/character.glb', 'hero');
+ * if (skeleton) model.skeleton = skeleton;
+ * for (const [name, clip] of animations) model.animations.set(name, clip);
+ * scene.add(model);
+ * ```
+ */
+declare class GLBLoader {
+    private gl;
+    private core;
+    constructor(core: WebGLCore);
+    /**
+     * Fetch and parse a `.glb` file.
+     *
+     * @param url  - URL to the GLB resource.
+     * @param name - Logical name assigned to the resulting {@link Model}.
+     * @returns Parsed model, optional skeleton, and animation clips.
+     */
+    load(url: string, name?: string): Promise<GLBLoadResult>;
+    /**
+     * Parse a raw GLB `ArrayBuffer` that was already loaded (e.g. from drag-and-drop).
+     */
+    parse(arrayBuffer: ArrayBuffer, name?: string): Promise<GLBLoadResult>;
+    private parseGlbHeader;
+    /**
+     * Walk the active scene's node tree and return all renderable meshes.
+     *
+     * Each scene node that references a mesh is visited in hierarchy order.
+     * Non-skinned mesh nodes that are children of joint nodes (e.g. eyes /
+     * hair parented to the Head bone in Blender) are automatically handled:
+     * their vertex data is pre-transformed into skin-space and synthetic
+     * single-joint weights are generated so they deform with the parent bone.
+     *
+     * @param skeleton – already-parsed skin for this model (or null).
+     */
+    private parseMeshes;
+    /**
+     * Pre-transform a bone-parented non-skinned mesh into skin coordinate space
+     * and synthesise single-joint weights so it deforms with its parent bone.
+     *
+     * The transform applied to each vertex is:
+     *   T = inv(IBM_parentJoint) × nodeLocalTransform
+     *
+     * After this call `mesh.isSkinned` returns `true`.
+     */
+    private applyBoneParenting;
+    private parsePrimitive;
+    private parseMaterial;
+    /**
+     * Decode a texture embedded in the GLB binary chunk and upload to GPU.
+     */
+    private loadEmbeddedTexture;
+    private createTextureFromUrl;
+    private parseSkin;
+    /**
+     * Compute the accumulated global transform of all non-joint ancestor
+     * nodes above the skeleton's root joint(s).
+     */
+    private computeSkinRootTransform;
+    private parseAnimation;
+    /**
+     * Extract a typed array from a glTF accessor + bufferView.
+     * Handles byte-stride (interleaved buffers) and all glTF component types.
+     */
+    private getAccessorData;
+    /** Compute the local transform matrix from a glTF node's TRS or matrix. */
+    private getNodeLocalMatrix;
+    /** Generate flat face-normals when the mesh doesn't include them. */
+    private generateFlatNormals;
+}
+
+export { type GLBLoadResult, GLBLoader };