@fonsecabarreto/genesis-gl-core 0.1.0

package/dist/Model-CQvDXd-b.d.ts

@@ -0,0 +1,302 @@
+import { Vector3 } from './Core/domain/interfaces/Vectors.js';
+import { W as WebGLCore } from './WebGLCore-DR7ZHJB0.js';
+import { b as Material } from './Material-BGLkldxv.js';
+import { vec3, quat, mat4 } from 'gl-matrix';
+
+interface AABB {
+    min: Vector3;
+    max: Vector3;
+}
+type ColliderType = 'box' | 'sphere' | 'capsule';
+declare class Collider {
+    type: ColliderType;
+    offset: Vector3;
+    size: Vector3;
+    constructor(type: ColliderType, offset?: Vector3, size?: Vector3);
+}
+
+/** WebGL draw-mode constants. */
+declare const GL_LINES = 1;
+declare const GL_TRIANGLES = 4;
+declare const INITIAL_BOUNDING_BOX: AABB;
+/**
+ * A single renderable mesh: vertex data, normals, indices, a material, and an
+ * optional bounding box used for collision detection.
+ *
+ * For skinned meshes, set {@link jointIndices} and {@link jointWeights} to
+ * enable GPU skeletal animation.
+ */
+declare class Mesh {
+    name: string;
+    vertices: Float32Array;
+    normals: Float32Array;
+    texCoords: Float32Array;
+    indices: Uint16Array | Uint32Array | null;
+    mode: number;
+    material: Material;
+    /** Per-vertex joint indices (vec4 per vertex, 4 influences). */
+    jointIndices: Float32Array | null;
+    /** Per-vertex joint weights (vec4 per vertex, 4 influences). */
+    jointWeights: Float32Array | null;
+    buffers: MeshBuffers | null;
+    boundingBox: AABB;
+    isCollidable: boolean;
+    isInitialized: boolean;
+    constructor(name: string, vertices: Float32Array, normals: Float32Array, material: Material, texCoords?: Float32Array, indices?: Uint16Array | Uint32Array | null);
+    setMode(newMode: number): void;
+    /** Whether this mesh has skinning data for skeletal animation. */
+    get isSkinned(): boolean;
+    computeBounds(): void;
+    clone(): Mesh;
+    /** Initialize GPU buffers safely */
+    initBuffer(webglCore: WebGLCore): void;
+    /** Dispose of GPU buffers safely */
+    dispose(webglCore: WebGLCore): void;
+}
+declare class MeshBuffers {
+    vao: WebGLVertexArrayObject | null;
+    vertexBuffer: WebGLBuffer | null;
+    normalBuffer: WebGLBuffer | null;
+    texCoordBuffer: WebGLBuffer | null;
+    indexBuffer: WebGLBuffer | null;
+    jointIndexBuffer: WebGLBuffer | null;
+    jointWeightBuffer: WebGLBuffer | null;
+    init(gl: WebGLRenderingContext, mesh: Mesh): void;
+    dispose(gl: WebGL2RenderingContext): void;
+}
+
+/** Maximum number of joints supported per skeleton (must match shader). */
+declare const MAX_JOINTS = 128;
+/**
+ * Describes a single joint (bone) inside a {@link Skeleton}.
+ *
+ * Each joint stores its default bind-pose transform (translation, rotation,
+ * scale) and the inverse bind matrix used to transform vertices from model
+ * space into joint-local space.
+ */
+interface Joint {
+    /** Human-readable name (e.g. "Hips", "LeftArm"). */
+    name: string;
+    /** Original glTF node index this joint references. */
+    nodeIndex: number;
+    /** Index of the parent joint in the skeleton's joint array (-1 = root). */
+    parentIndex: number;
+    /** Bind-pose translation. */
+    localTranslation: vec3;
+    /** Bind-pose rotation (quaternion). */
+    localRotation: quat;
+    /** Bind-pose scale. */
+    localScale: vec3;
+    /** Inverse bind matrix from the glTF skin. */
+    inverseBindMatrix: mat4;
+}
+/**
+ * Per-joint local transform produced by animation sampling.
+ * Any undefined component falls back to the bind-pose value.
+ */
+interface JointPose {
+    t?: vec3;
+    r?: quat;
+    s?: vec3;
+}
+/**
+ * A skeleton representing a hierarchy of {@link Joint}s.
+ *
+ * Call {@link computeJointMatrices} each frame with the current animation pose
+ * to produce a flat `Float32Array` of `mat4`s ready for upload as a shader
+ * uniform.
+ */
+declare class Skeleton {
+    /** Ordered joint list (parent always precedes child). */
+    readonly joints: Joint[];
+    /**
+     * Flat `Float32Array` of `joints.length` column-major `mat4` values.
+     * Updated by {@link computeJointMatrices} — upload directly to
+     * `uJointMatrices[0]`.
+     */
+    readonly jointMatrices: Float32Array;
+    /**
+     * Global transform of the non-joint ancestor nodes above the skeleton
+     * root.  In many exported models the armature sits under a scene-root
+     * node that carries scale / rotation (e.g. cm → m conversion).  This
+     * transform is pre-multiplied into root-joint globals so that
+     * `global * inverseBindMatrix` evaluates to identity in the bind pose.
+     */
+    readonly rootTransform: mat4;
+    constructor(joints: Joint[], rootTransform?: mat4);
+    /** Number of joints in the skeleton. */
+    get jointCount(): number;
+    /**
+     * Walk the joint hierarchy, composing global transforms, then multiply by
+     * each joint's inverse-bind matrix.  The result is stored in
+     * {@link jointMatrices} ready for shader upload.
+     *
+     * @param animatedPoses - Optional per-joint local transforms from an
+     *   {@link AnimationClip}.  Map keys are **joint array indices** (not glTF
+     *   node indices).
+     */
+    computeJointMatrices(animatedPoses?: Map<number, JointPose>): void;
+    /**
+     * Create a deep clone of this skeleton (useful when instancing models).
+     */
+    clone(): Skeleton;
+}
+
+/** Interpolation mode as defined by glTF 2.0. */
+type InterpolationMode = 'STEP' | 'LINEAR' | 'CUBICSPLINE';
+/** Which transform component the channel drives. */
+type AnimationPath = 'translation' | 'rotation' | 'scale';
+/**
+ * Stores the raw keyframe data for one animated property and performs
+ * interpolation between keyframes.
+ */
+interface AnimationSampler {
+    /** Keyframe timestamps (seconds). */
+    times: Float32Array;
+    /** Flattened keyframe output values (3 or 4 components per key). */
+    values: Float32Array;
+    /** Interpolation mode (default `LINEAR`). */
+    interpolation: InterpolationMode;
+}
+/**
+ * Links a {@link AnimationSampler} to a specific joint property.
+ */
+interface AnimationChannel {
+    /** Index into the owning {@link Skeleton}'s joint array. */
+    jointIndex: number;
+    /** Transform component this channel drives. */
+    path: AnimationPath;
+    /** The sampler that holds keyframe data. */
+    sampler: AnimationSampler;
+}
+/**
+ * A named animation clip containing one or more {@link AnimationChannel}s.
+ *
+ * Call {@link update} each frame to advance the playhead, then {@link sample}
+ * to obtain per-joint local transforms that feed into
+ * `Skeleton.computeJointMatrices()`.
+ *
+ * ```ts
+ * clip.play();
+ * // game loop:
+ * clip.update(deltaTime);
+ * const poses = clip.sample();
+ * skeleton.computeJointMatrices(poses);
+ * ```
+ */
+declare class AnimationClip {
+    /** Human-readable name (e.g. "Walk", "Idle"). */
+    readonly name: string;
+    /** All channels in this clip. */
+    readonly channels: AnimationChannel[];
+    /** Total duration in seconds (derived from the maximum keyframe time). */
+    readonly duration: number;
+    /** Current playback time in seconds. */
+    currentTime: number;
+    /** Whether the clip loops when it reaches the end. */
+    loop: boolean;
+    /** Playback speed multiplier (1 = normal, 2 = double, −1 = reverse). */
+    speed: number;
+    /** Whether the clip is currently advancing. */
+    playing: boolean;
+    constructor(name: string, channels: AnimationChannel[], duration: number);
+    /** Start / resume playback. */
+    play(): void;
+    /** Pause playback (keeps current time). */
+    pause(): void;
+    /** Stop and rewind to the beginning. */
+    stop(): void;
+    /** Rewind to the beginning without changing play state. */
+    reset(): void;
+    /**
+     * Advance the playhead by `deltaTime` seconds (respects {@link speed}).
+     * Automatically loops or clamps depending on {@link loop}.
+     */
+    update(deltaTime: number): void;
+    /**
+     * Sample every channel at the current playhead and return a map of
+     * joint-index → local pose.
+     */
+    sample(): Map<number, JointPose>;
+    /**
+     * Create an independent copy of this clip (shares the underlying sampler
+     * data but has its own playback state).
+     */
+    clone(): AnimationClip;
+}
+
+/**
+ * A high-level renderable object composed of one or more {@link Mesh}es.
+ * Provides transform, bounding-box, AABB collision, and optional skeletal
+ * animation utilities.
+ */
+declare class Model {
+    name: string;
+    meshes: Mesh[];
+    collider: Collider;
+    translation: Vector3;
+    rotation: Vector3;
+    scale: Vector3;
+    boundingBox: AABB;
+    /** The skeleton driving skinned meshes (set after GLB load if present). */
+    skeleton: Skeleton | null;
+    /** Named animation clips available on this model. */
+    animations: Map<string, AnimationClip>;
+    /** The currently playing animation clip (if any). */
+    activeAnimation: AnimationClip | null;
+    private _boundsDefinedManually;
+    private _modelMatrix;
+    private _matrixDirty;
+    /** When `false` the model is excluded from collision detection. */
+    collidable: boolean;
+    constructor(meshes: Mesh[], translation?: Vector3, scale?: Vector3, _name?: string, skeleton?: Skeleton | null);
+    /** Set absolute position. Marks matrix dirty and updates bounding box. */
+    setTranslation(x: number, y: number, z: number): void;
+    /** Set absolute rotation (radians per axis). */
+    setRotation(x: number, y: number, z: number): void;
+    /** Set absolute scale. */
+    setScale(x: number, y: number, z: number): void;
+    /** Translate the model by a delta. */
+    move(dx: number, dy: number, dz?: number): void;
+    private getModelMatrix;
+    /**
+     * Manually define the collision bounding box relative to the model's
+     * current translation.
+     */
+    setBounds(xOffset: number, yOffset: number, zOffset: number, width: number, height: number, depth: number): void;
+    private computeBoundingBox;
+    /** Recompute the world-space AABB from mesh data (unless manually set). */
+    updateBoundingBox(): void;
+    /** World-space centre of the bounding box. */
+    getCenter(): Vector3;
+    /** Extents of the bounding box in each axis. */
+    getSize(): Vector3;
+    /** Test for intersection with another model using their colliders. */
+    intersects(other: Model): boolean;
+    private intersectAABB;
+    /** Release all GPU resources held by this model's meshes. */
+    dispose(glCore: WebGLCore): void;
+    /** Deep-clone the model including all meshes. Materials are shared. */
+    clone(): Model;
+    /**
+     * Start playing a named animation clip.
+     * @param name - Must match a key in {@link animations}.
+     * @param loop - Whether the clip should loop (default `true`).
+     */
+    playAnimation(name: string, loop?: boolean): void;
+    /** Pause the active animation without rewinding. */
+    pauseAnimation(): void;
+    /** Stop the active animation and rewind. */
+    stopAnimation(): void;
+    /** List the names of all available animations. */
+    getAnimationNames(): string[];
+    /**
+     * Advance animation and recompute joint matrices.
+     * Call this every frame from your game loop.
+     *
+     * @param deltaTime - Elapsed time in seconds since the last frame.
+     */
+    update(deltaTime: number): void;
+}
+
+export { type AnimationChannel as A, GL_LINES as G, INITIAL_BOUNDING_BOX as I, type Joint as J, MAX_JOINTS as M, Skeleton as S, AnimationClip as a, type AnimationPath as b, type AnimationSampler as c, GL_TRIANGLES as d, type InterpolationMode as e, type JointPose as f, Mesh as g, MeshBuffers as h, Model as i };

package/dist/WebGLCore-DR7ZHJB0.d.ts

@@ -0,0 +1,22 @@
+type RenderCallback = (gl: WebGLRenderingContext, program: WebGLProgram) => void;
+declare class WebGLCore {
+    gl: WebGL2RenderingContext | WebGLRenderingContext;
+    program: WebGLProgram;
+    canvas: HTMLCanvasElement;
+    isWebGL2: boolean;
+    /**
+     * Initialise the WebGL rendering core.
+     *
+     * @param canvasOrId - An `HTMLCanvasElement` or the DOM `id` of one.
+     *                     Defaults to `'glcanvas'`.
+     */
+    constructor(canvasOrId?: string | HTMLCanvasElement);
+    getProgram(): WebGLProgram;
+    getRenderingContext(): WebGLRenderingContext;
+    private createProgram;
+    private compileShader;
+    resize(width: number, height: number): void;
+    dispose(): void;
+}
+
+export { type RenderCallback as R, WebGLCore as W };

package/dist/chunk-3ULETMWF.js

@@ -0,0 +1,144 @@
+// src/Core/classes/Light.ts
+var Light = class {
+  constructor(type = "directional", position = [0, 10, 0], direction = [0, -1, -1], color = [1, 1, 1], intensity = 1, constant = 1, linear = 0, quadratic = 0) {
+    this.type = type;
+    this.position = position;
+    this.direction = direction;
+    this.color = color;
+    this.intensity = intensity;
+    this.constant = constant;
+    this.linear = linear;
+    this.quadratic = quadratic;
+  }
+  type;
+  position;
+  direction;
+  color;
+  intensity;
+  // Attenuation factors are initialized to standard values (no falloff)
+  constant = 1;
+  linear = 0;
+  quadratic = 0;
+  move(dx, dy, dz) {
+    this.position[0] += dx;
+    this.position[1] += dy;
+    this.position[2] += dz;
+  }
+  rotateY(delta) {
+    if (this.type === "directional") {
+      const cos = Math.cos(delta);
+      const sin = Math.sin(delta);
+      const [x, y, z] = this.direction;
+      this.direction[0] = x * cos - z * sin;
+      this.direction[2] = x * sin + z * cos;
+    }
+  }
+};
+
+// src/Core/classes/Scene.ts
+var Scene = class _Scene {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  constructor(webglCore) {
+    this.webglCore = webglCore;
+  }
+  webglCore;
+  models = [];
+  modelsMap = /* @__PURE__ */ new Map();
+  lights = [];
+  // ─────────────────────────────────────────────
+  // ░░░ Factory: pre-configured 3-point lighting ░░░
+  // ─────────────────────────────────────────────
+  /**
+   * 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) {
+    const scene = new _Scene(webglCore);
+    scene.addLight(
+      "ambient_base",
+      new Light("ambient", [0, 0, 0], [0, 0, 0], [0.3, 0.3, 0.35], 0.5)
+    );
+    scene.addLight(
+      "directional_key",
+      new Light(
+        "directional",
+        [5, 10, 5],
+        [-0.5, -1, -0.5],
+        [1, 0.95, 0.9],
+        1.2
+      )
+    );
+    scene.addLight(
+      "directional_fill",
+      new Light(
+        "directional",
+        [-10, 5, 10],
+        [0.5, -0.2, -0.7],
+        [0.8, 0.8, 1],
+        0.5
+      )
+    );
+    scene.addLight(
+      "directional_back",
+      new Light(
+        "directional",
+        [0, 15, -10],
+        [0, -0.8, 1],
+        [1, 1, 1],
+        0.7
+      )
+    );
+    return scene;
+  }
+  /** Register a light source in the scene. */
+  addLight(id, light) {
+    this.lights.push(light);
+  }
+  /** Add a model to the scene with a unique key. */
+  add(id, model) {
+    this.models.push(model);
+    this.modelsMap.set(id, model);
+  }
+  /** Remove a model from the scene by key. */
+  remove(key) {
+    const mesh = this.modelsMap.get(key);
+    if (!mesh) return;
+    this.models = this.models.filter((m) => m !== mesh);
+    this.modelsMap.delete(key);
+  }
+  getModels() {
+    return this.models;
+  }
+  getLights() {
+    return this.lights;
+  }
+  /** Retrieve a model by its key. */
+  getModel(key) {
+    const mesh = this.modelsMap.get(key);
+    return mesh;
+  }
+  hasMesh(key) {
+    return this.modelsMap.has(key);
+  }
+  /** Returns all [id, model] pairs — useful for debug/inspector tools. */
+  getEntries() {
+    return [...this.modelsMap.entries()];
+  }
+  dispose(webglCore) {
+    for (const model of this.models) {
+      model.dispose(webglCore);
+    }
+    this.models.length = 0;
+    this.modelsMap.clear();
+    this.lights.length = 0;
+  }
+};
+
+export {
+  Light,
+  Scene
+};
+//# sourceMappingURL=chunk-3ULETMWF.js.map

package/dist/chunk-3ULETMWF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Core/classes/Light.ts","../src/Core/classes/Scene.ts"],"sourcesContent":["import { Vector3 } from '../domain/interfaces/Vectors';\n\n/**\n * Supported light types.\n * - `directional` – parallel rays (sun-like).\n * - `point`       – omnidirectional with distance attenuation.\n * - `ambient`     – constant contribution everywhere.\n */\nexport type LightType = 'directional' | 'point' | 'ambient';\n\n/**\n * A scene light with type, position, direction, colour, intensity,\n * and attenuation factors (for point lights).\n */\nexport class Light {\n  // Attenuation factors are initialized to standard values (no falloff)\n  public constant: number = 1.0;\n  public linear: number = 0.0;\n  public quadratic: number = 0.0;\n\n  constructor(\n    public type: LightType = 'directional',\n    public position: Vector3 = [0, 10, 0], // for point lights\n    public direction: Vector3 = [0, -1, -1], // for directional lights\n    public color: Vector3 = [1, 1, 1],\n    public intensity: number = 1,\n    constant: number = 1.0,\n    linear: number = 0.0,\n    quadratic: number = 0.0,\n  ) {\n    this.constant = constant;\n    this.linear = linear;\n    this.quadratic = quadratic;\n  }\n\n  move(dx: number, dy: number, dz: number) {\n    this.position[0] += dx;\n    this.position[1] += dy;\n    this.position[2] += dz;\n  }\n\n  rotateY(delta: number) {\n    if (this.type === 'directional') {\n      const cos = Math.cos(delta);\n      const sin = Math.sin(delta);\n      const [x, y, z] = this.direction;\n      this.direction[0] = x * cos - z * sin;\n      this.direction[2] = x * sin + z * cos;\n    }\n  }\n}\n","import { Light } from './Light';\nimport { Model } from './Model';\nimport WebGLCore from './WebGLCore';\n\nexport class Scene {\n  private models: Model[] = [];\n  private modelsMap = new Map<string, Model>();\n  public lights: Light[] = [];\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  constructor(private webglCore: WebGLCore) {}\n\n  // ─────────────────────────────────────────────\n  // ░░░ Factory: pre-configured 3-point lighting ░░░\n  // ─────────────────────────────────────────────\n\n  /**\n   * Create a Scene pre-loaded with a classic **3-point lighting** rig\n   * (ambient + key + fill + back).\n   *\n   * Use this for quick prototyping; for production, create a plain Scene and\n   * add your own lights.\n   */\n  static withDefaultLights(webglCore: WebGLCore): Scene {\n    const scene = new Scene(webglCore);\n\n    // 🌈 AMBIENT LIGHT (Global Base Illumination)\n    scene.addLight(\n      'ambient_base',\n      new Light('ambient', [0, 0, 0], [0, 0, 0], [0.3, 0.3, 0.35], 0.5),\n    );\n\n    // 🔑 KEY LIGHT (Main Sun/Primary Source)\n    scene.addLight(\n      'directional_key',\n      new Light(\n        'directional',\n        [5, 10, 5],\n        [-0.5, -1.0, -0.5],\n        [1.0, 0.95, 0.9],\n        1.2,\n      ),\n    );\n\n    // ☁️ FILL LIGHT (Softens Shadows)\n    scene.addLight(\n      'directional_fill',\n      new Light(\n        'directional',\n        [-10, 5, 10],\n        [0.5, -0.2, -0.7],\n        [0.8, 0.8, 1.0],\n        0.5,\n      ),\n    );\n\n    // 💫 BACK LIGHT (Rim/Separation Light)\n    scene.addLight(\n      'directional_back',\n      new Light(\n        'directional',\n        [0, 15, -10],\n        [0.0, -0.8, 1.0],\n        [1.0, 1.0, 1.0],\n        0.7,\n      ),\n    );\n\n    return scene;\n  }\n\n  /** Register a light source in the scene. */\n  public addLight(id: string, light: Light) {\n    this.lights.push(light);\n\n    /* Debug only */\n    /* \n    const lightSphere = createSphereMesh(\n      this.webglCore,\n      0.25,\n      12,\n      12,\n      [1, 1, 0.8],\n    );\n\n    lightSphere.isCollidable = false;\n    lightSphere.translation = light.position;\n    this.add(id + '_sphere', lightSphere);\n\n    // Debug direction for directional lights\n    if (light.type === 'point' || light.type === 'directional') {\n      const dirMesh = createLightDirectionMesh(\n        this.webglCore,\n        light.position,\n        light.direction,\n        5, // length of the arrow\n        [1, 0, 0], // red arrow\n      );\n      this.add(id + '_dir', dirMesh);\n    } \n    */\n  }\n\n  /** Add a model to the scene with a unique key. */\n  add(id: string, model: Model) {\n    this.models.push(model);\n    this.modelsMap.set(id, model);\n  }\n\n  /** Remove a model from the scene by key. */\n  remove(key: string) {\n    const mesh = this.modelsMap.get(key);\n    if (!mesh) return;\n    this.models = this.models.filter((m) => m !== mesh);\n    this.modelsMap.delete(key);\n  }\n\n  getModels() {\n    return this.models;\n  }\n\n  getLights() {\n    return this.lights;\n  }\n\n  /** Retrieve a model by its key. */\n  public getModel(key: string) {\n    const mesh = this.modelsMap.get(key);\n    return mesh;\n  }\n\n  public hasMesh(key: string) {\n    return this.modelsMap.has(key);\n  }\n\n  /** Returns all [id, model] pairs — useful for debug/inspector tools. */\n  public getEntries(): [string, Model][] {\n    return [...this.modelsMap.entries()];\n  }\n\n  dispose(webglCore: WebGLCore) {\n    for (const model of this.models) {\n      model.dispose(webglCore);\n    }\n    this.models.length = 0;\n    this.modelsMap.clear();\n    this.lights.length = 0;\n  }\n}\n"],"mappings":"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","names":[]}