chorama 0.0.0

package/src/constants/texture.js

@@ -0,0 +1,183 @@
+/**
+ * @enum {number}
+ */
+export const TextureFormat = /** @type {const} */({
+  // --- 8-bit ---
+  R8Unorm: 1,
+  R8Snorm: 2,
+  R8Uint: 3,
+  R8Sint: 4,
+
+  // --- 16-bit ---
+  R16Uint: 5,
+  R16Sint: 6,
+  R16Float: 7,
+  RG8Unorm: 8,
+  RG8Snorm: 9,
+  RG8Uint: 10,
+  RG8Sint: 11,
+
+  // --- 32-bit ---
+  R32Uint: 12,
+  R32Sint: 13,
+  R32Float: 14,
+  RG16Uint: 15,
+  RG16Sint: 16,
+  RG16Float: 17,
+  RGBA8Unorm: 18,
+  RGBA8UnormSRGB: 19,
+  RGBA8Snorm: 20,
+  RGBA8Uint: 21,
+  RGBA8Sint: 22,
+
+  // --- 64-bit ---
+  RG32Uint: 23,
+  RG32Sint: 24,
+  RG32Float: 25,
+  RGBA16Uint: 26,
+  RGBA16Sint: 27,
+  RGBA16Float: 28,
+
+  // --- 128-bit ---
+  RGBA32Uint: 29,
+  RGBA32Sint: 30,
+  RGBA32Float: 31,
+
+  // --- Depth / Stencil ---
+  Stencil8: 32,
+  Depth16Unorm: 33,
+  Depth24Plus: 34,
+  Depth24PlusStencil8: 35,
+  Depth32Float: 36,
+  Depth32FloatStencil8: 37,
+})
+
+/**
+ * @enum {number}
+ */
+export const TextureFilter = /** @type {const} */({
+  Nearest: 0x2600,
+  Linear: 0x2601
+})
+
+/**
+ * @enum {number}
+ */
+export const TextureWrap = /** @type {const} */({
+  Repeat: 0x2901,
+  Clamp: 0x812F,
+  MirrorRepeat: 0x8370
+})
+
+/**
+ * @enum {number}
+ * Texture binding targets
+ */
+export const TextureType = /** @type {const} */({
+  Texture2D: 0x0DE1,         // gl.TEXTURE_2D
+  Texture2DArray: 0x8C1A,    // gl.TEXTURE_2D_ARRAY
+  Texture3D: 0x806F,         // gl.TEXTURE_3D
+  TextureCubeMap: 0x8513     // gl.TEXTURE_CUBE_MAP
+})
+
+/**
+ * Returns the size in bytes per texel for a given TextureFormat.
+ * @param {TextureFormat} format
+ * @returns {number}
+ */
+export function getTextureFormatSize(format) {
+  switch (format) {
+    // 8-bit = 1 byte
+    case TextureFormat.R8Unorm:
+    case TextureFormat.R8Snorm:
+    case TextureFormat.R8Uint:
+    case TextureFormat.R8Sint:
+      return 1;
+
+    // 16-bit = 2 bytes
+    case TextureFormat.R16Uint:
+    case TextureFormat.R16Sint:
+    case TextureFormat.R16Float:
+    case TextureFormat.RG8Unorm:
+    case TextureFormat.RG8Snorm:
+    case TextureFormat.RG8Uint:
+    case TextureFormat.RG8Sint:
+      return 2;
+
+    // 32-bit = 4 bytes
+    case TextureFormat.R32Uint:
+    case TextureFormat.R32Sint:
+    case TextureFormat.R32Float:
+    case TextureFormat.RG16Uint:
+    case TextureFormat.RG16Sint:
+    case TextureFormat.RG16Float:
+    case TextureFormat.RGBA8Unorm:
+    case TextureFormat.RGBA8UnormSRGB:
+    case TextureFormat.RGBA8Snorm:
+    case TextureFormat.RGBA8Uint:
+    case TextureFormat.RGBA8Sint:
+      return 4;
+
+    // 64-bit = 8 bytes
+    case TextureFormat.RG32Uint:
+    case TextureFormat.RG32Sint:
+    case TextureFormat.RG32Float:
+    case TextureFormat.RGBA16Uint:
+    case TextureFormat.RGBA16Sint:
+    case TextureFormat.RGBA16Float:
+      return 8;
+
+    // 128-bit = 16 bytes
+    case TextureFormat.RGBA32Uint:
+    case TextureFormat.RGBA32Sint:
+    case TextureFormat.RGBA32Float:
+      return 16;
+
+    // Depth/stencil formats — size varies and is implementation-specific
+    case TextureFormat.Stencil8:
+      return 1;
+    case TextureFormat.Depth16Unorm:
+      return 2;
+    case TextureFormat.Depth24Plus:
+    case TextureFormat.Depth24PlusStencil8:
+      return 4; // Typically 3 or 4 bytes — assume 4
+    case TextureFormat.Depth32Float:
+      return 4;
+    case TextureFormat.Depth32FloatStencil8:
+      return 5; // 4 (depth) + 1 (stencil) — approximate
+
+    default:
+      throw new Error(`Unknown or unsupported texture format: ${format}`);
+  }
+}
+
+/**
+ * @param {TextureFormat} format
+ */
+export function hasDepthComponent(format) {
+  switch (format) {
+    case TextureFormat.Depth16Unorm:
+    case TextureFormat.Depth24Plus:
+    case TextureFormat.Depth24PlusStencil8:
+    case TextureFormat.Depth32Float:
+    case TextureFormat.Depth32FloatStencil8:
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Checks if a format has a stencil component
+ * @param {TextureFormat} format
+ */
+export function hasStencilComponent(format) {
+  switch (format) {
+    case TextureFormat.Stencil8:
+    case TextureFormat.Depth24PlusStencil8:
+    case TextureFormat.Depth32FloatStencil8:
+      return true;
+    default:
+      return false;
+  }
+}

package/src/core/constants.js

@@ -0,0 +1,14 @@
+/**
+ * @enum {number}
+ * Comparison functions for depth, stencil, and sampler tests
+ */
+export const CompareFunction = /** @type {const} */({
+  Never: 0x0200,      // gl.NEVER
+  Less: 0x0201,       // gl.LESS
+  Equal: 0x0202,      // gl.EQUAL
+  Lequal: 0x0203,     // gl.LEQUAL
+  Greater: 0x0204,    // gl.GREATER
+  NotEqual: 0x0205,   // gl.NOTEQUAL
+  Gequal: 0x0206,     // gl.GEQUAL
+  Always: 0x0207      // gl.ALWAYS
+})

package/src/core/extensions.js

@@ -0,0 +1,42 @@
+export class WebGLExtensions {
+  /**
+   * @param {WebGL2RenderingContext} gl
+   */
+  constructor(gl) {
+    this.gl = gl;
+    this.supported = gl.getSupportedExtensions() || [];
+    this.cache = new Map();
+  }
+
+  /**
+   * Check if an extension is supported.
+   * @param {string} name
+   * @returns {boolean}
+   */
+  has(name) {
+    return this.supported.includes(name);
+  }
+
+  /**
+   * Get (and cache) an extension object.
+   * @param {string} name
+   * @returns {object | undefined}
+   */
+  get(name) {
+    if (this.cache.has(name))
+      return this.cache.get(name);
+
+    const ext = this.has(name) ? this.gl.getExtension(name) : undefined;
+    this.cache.set(name, ext);
+    return ext;
+  }
+
+  /**
+   * Initialize all supported extensions at once
+   */
+  initAll() {
+    for (const name of this.supported) {
+      this.get(name);
+    }
+  }
+}

package/src/core/index.js

@@ -0,0 +1,7 @@
+export * from "./layouts/index.js"
+export * from "./shader.js"
+export * from "./limits.js"
+export * from "./extensions.js"
+export * from "./resources/index.js"
+export * from "./webgl/index.js"
+export * from "./constants.js"

package/src/core/layouts/index.js

@@ -0,0 +1,4 @@
+export * from './uniformbuffer.js'
+export * from './uniform.js'
+export * from './vertexbuffer.js'
+export * from './meshvertex.js'

package/src/core/layouts/meshvertex.js

@@ -0,0 +1,60 @@
+import { Mesh, Attribute } from "../../mesh/index.js"
+import { VertexBufferLayout } from "./vertexbuffer.js"
+
+export class MeshVertexLayout {
+  /**
+   * @type {readonly VertexBufferLayout[]}
+   */
+  layouts = []
+
+  /**
+   * @param {VertexBufferLayout[]} layouts
+   */
+  constructor(layouts) {
+    this.layouts = layouts
+  }
+
+  /**
+   * @param {Mesh} mesh
+   */
+  compatibleWithMesh(mesh) {
+    for (const attributeName of mesh.attributes.keys()) {
+      let found = false
+      for (const layout of this.layouts) {
+        found = layout.hasOnly([attributeName])
+        if (found) {
+          break
+        }
+      }
+
+      if (!found) {
+        return false
+      }
+    }
+    return true
+  }
+
+  /**
+   * @param {Attribute} attribute
+   */
+  hasAttribute(attribute){
+    return this.layouts.some((layout)=>layout.has(attribute))
+  }
+  /**
+   * @param {Mesh} mesh
+   * @param {ReadonlyMap<string, Attribute>} attributes
+   * @returns {MeshVertexLayout}
+   */
+  static fromMesh(mesh, attributes) {
+    const result = []
+    for (const name of mesh.attributes.keys()) {
+      const attribute = attributes.get(name)
+      if (!attribute) {
+        throw `The attribute "${name}" is not available in the attribute map`
+      }
+      result.push(new VertexBufferLayout([attribute]))
+    }
+
+    return new MeshVertexLayout(result)
+  }
+}

package/src/core/layouts/uniform.js

@@ -0,0 +1,21 @@
+import { UniformType } from "../../constants/index.js"
+
+export class Uniform {
+  location
+  size
+  type
+  /**
+   * @type {number | undefined}
+   */
+  texture_unit
+  /**
+   * @param {WebGLUniformLocation} location
+   * @param {number} size
+   * @param {UniformType} type
+  */
+  constructor(location,type,size){
+    this.location = location
+    this.type = type
+    this.size = size
+  }
+}

package/src/core/layouts/uniformbuffer.js

@@ -0,0 +1,15 @@
+export class UniformBufferLayout {
+  name
+  fields
+  size
+  /**
+   * @param {string} name
+   * @param {any} size
+   * @param {Map<string, {name:string,size:string}>} fields
+   */
+  constructor(name, size, fields) {
+    this.name = name
+    this.size = size
+    this.fields = fields
+  }
+}

package/src/core/layouts/vertexbuffer.js

@@ -0,0 +1,43 @@
+import { Attribute } from "../../mesh/index.js"
+
+export class VertexBufferLayout {
+  /**
+   * @type {readonly Attribute[]}
+   */
+  attributes = []
+
+  /**
+   * @param {Attribute[]} attributes
+   */
+  constructor(attributes) {
+    this.attributes = attributes
+  }
+
+  /**
+   * @param {Attribute} attribute
+   */
+  has(attribute){
+    for (let i = 0; i < this.attributes.length; i++) {
+      if(this.attributes[i]?.id === attribute.id){
+        return true
+      }
+      
+    }
+    return false
+  }
+  /**
+   * @param {string[]} attributeIds
+   * @returns {boolean}
+   */
+  hasOnly(attributeIds) {
+    if (attributeIds.length !== this.attributes.length) return false
+
+    for (let i = 0; i < attributeIds.length; i++) {
+      if (this.attributes.findIndex(value => value.name === attributeIds[i]) === -1) {
+        return false
+      }
+    }
+
+    return true
+  }
+}

package/src/core/limits.js

@@ -0,0 +1,247 @@
+/**
+ * Queries and stores WebGL 2.0 GPU capability limits in organized groups.
+ */
+export class WebGLDeviceLimits {
+  /**
+   * @type {WebGLTextureLimits}
+   */
+  textures
+
+  /**
+   * @type {WebGLBufferLimits}
+   */
+  buffers
+
+  /**
+   * @type {WebGLAttributeLimits}
+   */
+  attributes
+
+  /**
+   * @type {WebGLUniformLimits}
+   */
+  uniforms
+
+  /**
+   * @type {WebGLFramebufferLimits}
+   */
+  framebuffer
+
+  /**
+   * @type {WebGLTransformFeedbackLimits}
+   */
+  transformFeedback
+
+  /**
+   * @type {WebGLShaderPrecisionLimits}
+   */
+  precision
+
+  /**
+   * @type {WebGLExtensionLimits}
+   */
+  extensions
+
+  /**
+   * @type {WebGLDeviceInfo}
+   */
+  info
+
+  /**
+   * @param {WebGL2RenderingContext} gl
+   */
+  constructor(gl) {
+    // === Texture limits ===
+    this.textures = queryTextureLimits(gl)
+
+    // === Buffer and memory-related limits ===
+    this.buffers = {
+      maxRenderbufferSize: gl.getParameter(gl.MAX_RENDERBUFFER_SIZE),
+      maxUniformBufferBindings: gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS),
+      maxUniformBlockSize: gl.getParameter(gl.MAX_UNIFORM_BLOCK_SIZE),
+    }
+
+    // === Attribute / Vertex Shader limits ===
+    this.attributes = {
+      maxVertexAttribs: gl.getParameter(gl.MAX_VERTEX_ATTRIBS),
+      maxVertexOutputComponents: gl.getParameter(gl.MAX_VERTEX_OUTPUT_COMPONENTS),
+      aliasedPointSizeRange: gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE),
+      aliasedLineWidthRange: gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE),
+    }
+
+    // === Uniform / Shader limits ===
+    this.uniforms = {
+      maxVertexUniformVectors: gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS),
+      maxVertexUniformBlocks: gl.getParameter(gl.MAX_VERTEX_UNIFORM_BLOCKS),
+      maxFragmentUniformVectors: gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS),
+      maxFragmentUniformBlocks: gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_BLOCKS),
+      maxVaryingVectors: gl.getParameter(gl.MAX_VARYING_VECTORS),
+      maxFragmentInputComponents: gl.getParameter(gl.MAX_FRAGMENT_INPUT_COMPONENTS),
+    }
+
+    // === Framebuffer / Render Target limits ===
+    this.framebuffer = {
+      maxViewportDims: gl.getParameter(gl.MAX_VIEWPORT_DIMS),
+      maxDrawBuffers: gl.getParameter(gl.MAX_DRAW_BUFFERS),
+      maxColorAttachments: gl.getParameter(gl.MAX_COLOR_ATTACHMENTS),
+      maxSamples: gl.getParameter(gl.MAX_SAMPLES),
+    }
+
+    // === Transform Feedback limits ===
+    this.transformFeedback = {
+      maxInterleavedComponents: gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
+      maxSeparateAttribs: gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
+      maxSeparateComponents: gl.getParameter(gl.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
+    }
+
+    // === Precision limits ===
+    this.precision = {
+      vertex: {
+        highFloat: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT),
+        mediumFloat: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT),
+        lowFloat: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.LOW_FLOAT),
+        highInt: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_INT),
+        mediumInt: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_INT),
+        lowInt: gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.LOW_INT),
+      },
+      fragment: {
+        highFloat: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT),
+        mediumFloat: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT),
+        lowFloat: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.LOW_FLOAT),
+        highInt: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_INT),
+        mediumInt: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_INT),
+        lowInt: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.LOW_INT),
+      },
+    }
+
+    // === Extensions and optional limits ===
+    const extAniso =
+      gl.getExtension("EXT_texture_filter_anisotropic") ||
+      gl.getExtension("MOZ_EXT_texture_filter_anisotropic") ||
+      gl.getExtension("WEBKIT_EXT_texture_filter_anisotropic")
+
+    this.extensions = {
+      anisotropy: extAniso
+        ? gl.getParameter(extAniso.MAX_TEXTURE_MAX_ANISOTROPY_EXT)
+        : 1,
+    }
+
+    // === Debug info (vendor/renderer) ===
+    const dbgInfo = gl.getExtension("WEBGL_debug_renderer_info")
+    this.info = {
+      vendor: dbgInfo
+        ? gl.getParameter(dbgInfo.UNMASKED_VENDOR_WEBGL)
+        : gl.getParameter(gl.VENDOR),
+      renderer: dbgInfo
+        ? gl.getParameter(dbgInfo.UNMASKED_RENDERER_WEBGL)
+        : gl.getParameter(gl.RENDERER),
+    }
+  }
+}
+
+/**
+ * @typedef WebGLTextureLimits
+ * @property {number} maxTextureSize
+ * @property {number} maxCubeMapTextureSize
+ * @property {number} max3DTextureSize
+ * @property {number} maxArrayTextureLayers
+ * @property {number} maxCombinedTextureImageUnits
+ * @property {number} maxVertexTextureImageUnits
+ * @property {number} maxFragmentTextureImageUnits
+ * @property {number} maxTextureAnisotropy
+ */
+
+/**
+ * @typedef WebGLAttributeLimits
+ * @property {number} maxVertexAttribs
+ * @property {number} maxVertexOutputComponents
+ * @property {Float32Array} aliasedPointSizeRange
+ * @property {Float32Array} aliasedLineWidthRange
+ */
+
+/**
+ * @typedef WebGLUniformLimits
+ * @property {number} maxVertexUniformVectors
+ * @property {number} maxVertexUniformBlocks
+ * @property {number} maxFragmentUniformVectors
+ * @property {number} maxFragmentUniformBlocks
+ * @property {number} maxVaryingVectors
+ * @property {number} maxFragmentInputComponents
+ */
+
+/**
+ * @typedef WebGLBufferLimits
+ * @property {number} maxRenderbufferSize
+ * @property {number} maxUniformBufferBindings
+ * @property {number} maxUniformBlockSize
+ */
+
+/**
+ * @typedef WebGLFramebufferLimits
+ * @property {Int32Array} maxViewportDims
+ * @property {number} maxDrawBuffers
+ * @property {number} maxColorAttachments
+ * @property {number} maxSamples
+ */
+
+/**
+ * @typedef WebGLTransformFeedbackLimits
+ * @property {number} maxInterleavedComponents
+ * @property {number} maxSeparateAttribs
+ * @property {number} maxSeparateComponents
+ */
+
+/**
+ * @typedef WebGLDeviceInfo
+ * @property {string} vendor
+ * @property {string} renderer
+ */
+
+/**
+ * @typedef WebGLShaderPrecisionLimits
+ * @property {WebGLShaderPrecisionInfo} vertex
+ * @property {WebGLShaderPrecisionInfo} fragment
+ */
+
+/**
+ * @typedef WebGLShaderPrecisionInfo
+ * @property {WebGLShaderPrecisionFormat | null} highFloat
+ * @property {WebGLShaderPrecisionFormat | null} mediumFloat
+ * @property {WebGLShaderPrecisionFormat | null} lowFloat
+ * @property {WebGLShaderPrecisionFormat | null} highInt
+ * @property {WebGLShaderPrecisionFormat | null} mediumInt
+ * @property {WebGLShaderPrecisionFormat | null} lowInt
+ */
+
+/**
+ * @typedef WebGLExtensionLimits
+ * @property {number} anisotropy
+ */
+
+/**
+ * Query all texture-related limits and supported features.
+ * @param {WebGL2RenderingContext} gl
+ * @returns {WebGLTextureLimits}
+ */
+function queryTextureLimits(gl) {
+  const extAniso =
+    gl.getExtension("EXT_texture_filter_anisotropic") ||
+    gl.getExtension("WEBKIT_EXT_texture_filter_anisotropic") ||
+    gl.getExtension("MOZ_EXT_texture_filter_anisotropic")
+
+  return {
+    // === Core WebGL2 texture limits ===
+    maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
+    maxCubeMapTextureSize: gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE),
+    max3DTextureSize: gl.getParameter(gl.MAX_3D_TEXTURE_SIZE),
+    maxArrayTextureLayers: gl.getParameter(gl.MAX_ARRAY_TEXTURE_LAYERS),
+    maxCombinedTextureImageUnits: gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+    maxVertexTextureImageUnits: gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
+    maxFragmentTextureImageUnits: gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS),
+
+    // === Extension-based limits ===
+    maxTextureAnisotropy: extAniso
+      ? gl.getParameter(extAniso.MAX_TEXTURE_MAX_ANISOTROPY_EXT)
+      : 1
+  }
+}