@windycom/plugin-devtools 3.0.2 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@windycom/plugin-devtools",
-    "version": "3.0.2",
+    "version": "3.0.3",
     "description": "Developer tools and TS declarations for developers of Windy Plugins.",
     "main": "index.mjs",
     "module": "index.mjs",

package/types/client/Calendar.d.ts

@@ -33,6 +33,10 @@ export interface MinifestObject {
  * Main Calendar Day Object
  */
 export interface CalendarDay {
+    /**
+     * Translation ID for week day one letter/symbol abbreviation
+     */
+    displayShort: keyof LoadedTranslations;
     /**
      * Translation ID for week day abbreviation
      */

package/types/client/Color.d.ts

@@ -1,6 +1,6 @@
 import type { RGBA, RGBString, ColorGradient, NumValue, ColorGradientString } from '@windy/types.d';
-export type ColorIdent = 'temp' | 'wind' | 'rh' | 'pressure' | 'cclAltitude' | 'altitude' | 'deg0' | 'levels' | 'rain' | 'ptype' | 'rainClouds' | 'clouds' | 'lclouds' | 'hclouds' | 'mclouds' | 'cape' | 'lightDensity' | 'cbase' | 'snow' | 'rainAccu' | 'waves' | 'currents' | 'visibility' | 'gtco3' | 'aod550' | 'pm2p5' | 'no2' | 'tcso2' | 'go3' | 'cosc' | 'dust' | 'satellite' | 'radar' | 'radarPlus' | 'fog' | 'justGray' | 'efiWind' | 'efiTemp' | 'efiRain' | 'moistureAnom40' | 'moistureAnom100' | 'drought' | 'soilMoisture' | 'fwi' | 'dfm10h' | 'solarpower' | 'uvindex' | 'turbulence' | 'icing' | 'wetbulbtemp' | 'aqi' | 'dewpoint';
-export type PluginColorIdent = 'windDetail' | 'wavesDetail' | 'periodDetail' | 'altitudeDetail' | 'visibilityDetail' | 'dewpointSpreadDetail' | 'blitz' | 'radiation' | 'pmDetail' | 'dustDetail' | 'coscDetail' | 'no2Detail' | 'pollenDetail' | 'so2Detail' | 'aqiGradientDetail';
+export type ColorIdent = 'temp' | 'wind' | 'rh' | 'pressure' | 'cclAltitude' | 'altitude' | 'deg0' | 'levels' | 'rain' | 'ptype' | 'rainClouds' | 'clouds' | 'lclouds' | 'hclouds' | 'mclouds' | 'cape' | 'lightDensity' | 'cbase' | 'snow' | 'rainAccu' | 'waves' | 'currents' | 'visibility' | 'gtco3' | 'aod550' | 'pm2p5' | 'no2' | 'tcso2' | 'go3' | 'cosc' | 'dust' | 'satellite' | 'radar' | 'fog' | 'justGray' | 'efiWind' | 'efiTemp' | 'efiRain' | 'moistureAnom40' | 'moistureAnom100' | 'drought' | 'soilMoisture' | 'fwi' | 'dfm10h' | 'solarpower' | 'wavePower' | 'uvindex' | 'turbulence' | 'icing' | 'wetbulbtemp' | 'aqi' | 'dewpoint';
+export type PluginColorIdent = 'windDetail' | 'wavesDetail' | 'periodDetail' | 'altitudeDetail' | 'visibilityDetail' | 'dewpointSpreadDetail' | 'blitz' | 'radiation' | 'pmDetail' | 'dustDetail' | 'coscDetail' | 'no2Detail' | 'pollenDetail' | 'so2Detail' | 'aqiGradientDetail' | 'wavePowerDetail';
 export type AnyColorIdent = ColorIdent | PluginColorIdent | 'pressureIsolines' | 'temporary' | 'direction' | 'airgramColor' | 'tempFillColors' | 'tideGraphColors' | 'aqiFillColors';
 export interface UserColor {
     id: AnyColorIdent;
@@ -11,6 +11,12 @@ export type ColorInitParams = Pick<Color, 'ident'> & Partial<Pick<Color, 'qualit
     steps?: number;
     opaque?: boolean;
     prepare?: boolean;
+    /**
+     * Min and max gradient value override
+     *  - used for gradients with constant min and max values
+     *  - e.g. radar with [0,256] in all cases (gradient is not resized based on the current gradient extents)
+     */
+    minMaxValue?: [NumValue, NumValue];
 };
 export declare class Color {
     /**
@@ -37,6 +43,7 @@ export declare class Color {
     private defaultColorGradient?;
     /** Custom modified gradient */
     private customColorGradient?;
+    private minMaxValue?;
     /** Big interpolated RGBA Type array color table, generated when color is required */
     private colors?;
     /** Min value of associated numerical value  */

package/types/client/DataTiler.d.ts

@@ -1,6 +1,6 @@
 import { dataLoader } from '@windy/dataLoader';
-import type { FullRenderParameters } from './d.ts.files/interfaces';
-import type { DataTile } from './d.ts.files/dataLoader';
+import type { FullRenderParameters } from '@windy/interfaces';
+import type { DataTile } from '@windy/dataLoader';
 import type { ExtendedTileParams } from './DataTiler.d';
 export interface TilePoint {
     x: number;

package/types/client/EventManager.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="svelte" />
+import store from '@windy/store';
+import type { StoreTypes } from '@windy/store.d';
+import type { Evented as MaplibreEvented, Listener, MapEventType, MapLayerEventType, LeafletEventHandlerFn } from '@leafletGl';
+import type { Evented } from '@windy/Evented';
+import type { BcastTypes } from '@windy/broadcast.d';
+import type { Plugins } from '@windy/plugins.d';
+import type { Readable, Subscriber } from 'svelte/store';
+type MapLibreEventTypes = MapLayerEventType | MapEventType | string;
+type BcastEventTypes = keyof BcastTypes<keyof Plugins>;
+/**
+ * @class A class for managing event listeners
+ *  - used to safely bind AND unbind listeners by storing callback references
+ */
+export declare class EventManager {
+    private DOMCallbacks;
+    private MapLibreCallbacks;
+    private storeCallbacks;
+    private eventedCallbacks;
+    private broadcastCallbacks;
+    private mapCallbacks;
+    private unsubscribers;
+    /**
+     * @summary Registers specific event listener on a given DOM target with a given callback
+     * @param target    - target to listen on
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addDOMListener<T extends EventTarget>(target: T, topic: Parameters<T['addEventListener']>[0], callback: Parameters<T['addEventListener']>[1]): void;
+    /**
+     * @summary Registers specific event listener on a given MapLibre target with a given callback
+     * @param target    - target to listen on
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addMapLibreListener<T extends MapLibreEventTypes>(target: MaplibreEvented, topic: T, callback: Listener): void;
+    /**
+     * @summary Registers specific event listener on windy store with a given callback
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addStoreListener<T extends keyof StoreTypes>(topic: T, callback: Parameters<(typeof store)['on']>[1]): void;
+    /**
+     * @summary Registers specific event listener on a given windy/evented target with a given callback
+     * @param target    - target to listen on
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addEventedListener<T>(target: Evented<T>, topic: keyof T, callback: (typeof this.eventedCallbacks)[string][number]['ref']): void;
+    /**
+     * @summary Registers specific event listener on windy broadcast with a given callback
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addBroadcastListener(topic: BcastEventTypes, callback: (typeof this.broadcastCallbacks)[string][number]['ref']): void;
+    addMapListener(topic: string, callback: LeafletEventHandlerFn): void;
+    addSvelteStoreListener<T>(svelteStore: Readable<T>, callback: Subscriber<T>, onlyOnChange?: boolean): void;
+    /**
+     * Subscribe to DOM mutations using MutationObserver
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+     */
+    addMutationObserverListener(target: Node, options: MutationObserverInit, callback: MutationCallback): void;
+    /**
+     * @summary Cleanup method to remove (unregister) all registered listeners
+     */
+    removeListeners(): void;
+}
+export {};

package/types/client/ExternalSveltePlugin.d.ts

@@ -2,7 +2,8 @@ import { SveltePlugin, type ExternalSvelteApp } from '@windy/SveltePlugin';
 import type { WindowPluginInitParams } from '@windy/WindowPlugin';
 import type { SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
 import type { CompiledExternalPluginConfig, ExternalPluginConfig, InstalledExternalPluginConfig, PluginOpeningOptions } from '@windy/interfaces';
-import type { PluginPane } from './Plugin';
+import type { PluginPane } from '@windy/Plugin';
+import type { SemVersion } from '@windy/types';
 /** Allowed params to SveltePlugin constructor (private and protected props are omitted by default) */
 export type ExternalSveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
 export type LoadeExternalSveltePlugin = {
@@ -22,12 +23,12 @@ export declare class ExternalSveltePlugin extends SveltePlugin<'windy-external-p
     mobileConfig: Record<InstalledExternalPluginConfig['mobileUI'], Config2config>;
     desktopConfig: Record<InstalledExternalPluginConfig['desktopUI'], Config2config>;
     widthOfRhPane: number;
-    version: string;
+    version: SemVersion;
     listenToSingleclick: ExternalPluginConfig['listenToSingleclick'];
     addToContextmenu: ExternalPluginConfig['addToContextmenu'];
     constructor(params: WindowPluginInitParams<'windy-external-plugin'>, { desktopUI, title, mobileUI, desktopWidth, routerPath, listenToSingleclick, addToContextmenu, url, version, }: InstalledExternalPluginConfig);
     open({ params, disableOpeningAnimation, qs, }: PluginOpeningOptions<'windy-external-plugin'>): Promise<void | boolean>;
-    hasNewerVersion(latestVersion: string): boolean;
+    hasNewerVersion(latestVersion: SemVersion): boolean;
     showConfirmationWindow(): Promise<boolean>;
     getDayDiff(timestamp: string): number;
     uninstallPlugin(): Promise<void>;

package/types/client/GlBuffer.d.ts

@@ -0,0 +1,45 @@
+import type { TypedArray } from '@windy/glUtils.d';
+export declare enum GlBufferType {
+    VERTEX,
+    INDEX
+}
+export declare enum GlBufferUsage {
+    STATIC,
+    DYNAMIC
+}
+/**
+ * @class A wrapper class over WebGLBuffer
+ */
+export declare class GlBuffer {
+    private static idCounter;
+    /** Reference to the WebGL buffer on the GPU */
+    protected readonly buffer: WebGLBuffer;
+    protected type: GlBufferType;
+    /** Length of uploaded data array in the buffer */
+    protected _dataLength: number;
+    /** Class instance unique id, for debug, tracks number of created instances */
+    protected readonly bufferId: number;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, type: GlBufferType);
+    /**
+     * @summary Resets buffer instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Binds buffer for subsequent operations
+     */
+    bind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Unbinds the buffer
+     */
+    unbind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Updates data in the GPU buffer
+     * @param data Data to be uploaded to the GPU buffer
+     * @param usage Buffer update frequency (how the buffer will be updated)
+     */
+    update(gl: WebGLRenderingContext | WebGL2RenderingContext, data: TypedArray, usage?: GlBufferUsage): void;
+    /** @summary Returns number of elements inside the buffer */
+    get length(): number;
+    /** @summary Deletes the WebGL buffer */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+}

package/types/client/GlMesh.d.ts

@@ -0,0 +1,147 @@
+import type { TypedArray } from '@windy/glUtils.d';
+import type { GlProgram } from '@windy/GlProgram';
+/**
+ * @class A class that represents abstraction of a renderable logical geometry chunk
+ *          - (geometry with the same properties, requiring same rendering approach)
+ */
+export declare class GlMesh {
+    private static numMeshes;
+    /**
+     * Array of vertex streams (Vertex Buffer Objects) used for rendering the mesh
+     *  - GPU buffer references | Key-value map in the future (multiple geometry buffers)
+     */
+    private readonly vbos;
+    /** Size of the GPU buffer | Key-value map in the future (multiple geometry buffers) */
+    private vertexCount;
+    /**
+     * Array of vertex attributes mapping
+     *  - one map for each vertex stream, since every stream has at least one attribute defined by layout index and size
+     *  - maps attributes bound to the given GPU buffer (VBO)
+     */
+    private readonly attributes;
+    /**
+     * Size of all attributes for one vertex in the given vertex stream
+     *  e.g. one vertex has Vec3 position, Vec2 uv, and Vec3 color --> stride is 3+2+3 = 8 bytes
+     * */
+    private readonly buffersStride;
+    /** Element Buffer Object for storing vertex indices for indexed rendering */
+    private ebo?;
+    /**
+     * Map of Vertex Array Objects
+     *  VAO - represents binding of geometry layout with a given shader program
+     *  - one VAO is for given GlProgram (not per vertex stream)
+     *  - one VAO handles binding of all vertex streams, but for every GlProgram, new VAO should be created since each shader can have different layout
+     */
+    private readonly vaos;
+    private readonly meshId;
+    private instanceBuffer?;
+    private instanceAttributes?;
+    private instanceBufferStride;
+    private instancingInitialized;
+    private drawElementsCall;
+    private drawArraysCall;
+    private vertexDivisorCall;
+    /**
+     * @param vertexData Default vertex stream data (can be interleaved - defined by layout)
+     * @param indexData Optional index buffer data (in case of indexed data rendering)
+     * @param dynamic Signals, whether the geometry will be updated frequently or is static
+     */
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, vertexData: Float32Array, indexData?: Uint16Array, dynamic?: boolean);
+    /**
+     * @summary Resets mesh instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Performs draw call of the mesh w.r.t. current state defined by VAO / attributes layout + given shader program
+     *          - WARNING: this call assumes, that GlProgram.use() / gl.useProgram(programId) was already called!
+     *          - automatically performs the appropriate call -> instanced/non-instanced + indexed/non-indexed - all based on the state given by the supplied data
+     * @param program Shader program used to identify the render/geometry state
+     * @param primType Which primitives to draw with the vertex data
+     * @param offset Offset in the geometry buffer (defaults to 0)
+     * @param count Number of vertices / elements to draw from the buffer (defaults to full size of the geometry)
+     * @param numInstances When instanced rendering used, signals, how many instances to draw
+     */
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, program: GlProgram, primitiveType?: GLenum, numInstances?: number): void;
+    /**
+     * @summary Creates new geometry layout binding / (new VAO if available) w.r.t. supplied shader program
+     *          - goal: the same mesh geometry can be reused by many shaders with different layouts (we are binding to the given shader)
+     *          - TODO: currently works with only one buffer (interleaved/joined data), extend this to support multiple buffers (streams) + per-buffer layout setup
+     * @param shaderProgram Shader program for which to setup the layout
+     * @param vertexAttribLayout Specifies, how the mesh data should be mapped to the given shader (VS)
+     *          - e.g. {a_pos : 3, a_uv : 2} defines two attributes, first vertex position with three components, second texture coordinates vector with two components
+     *          - the object keys must respect names of the attribute variables in the Vertex Shader
+     * @param vertexStreamIndex Index of vertex stream (VBO) for which the layout is being registered. Default one is 0
+     */
+    registerShaderGeometryLayout(gl: WebGLRenderingContext | WebGL2RenderingContext, shaderProgram: GlProgram, vertexAttribLayout: Record<string, number>, vertexStreamIndex?: number): void;
+    /**
+     * @summary Destructor
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Appends vertex stream to the mesh.
+     *      Do not forget to register vertex layout for this stream via {@link registerShaderGeometryLayout} method
+     * @param vertexData Typed array (Float32Array) with vertex data (position, tex. coordinates etc.)
+     * @param dynamic Whether the data will be updated frequently or not
+     * @returns Index of the newly registered vertex stream
+     */
+    addVertexStream(gl: WebGLRenderingContext | WebGL2RenderingContext, vertexData: Float32Array, dynamic?: boolean): number;
+    /**
+     * @summary Dynamically updates content of the given vertex stream. Assumes, that the layout remains the same
+     * @param streamIndex Which stream data to update
+     * @param vertexData New vertex data
+     */
+    updateVertexStream(gl: WebGLRenderingContext | WebGL2RenderingContext, streamIndex: number, vertexData: Float32Array): boolean;
+    /**
+     * @summary Initializes instancing-related methods based on used WebGL context
+     *  - if not called explicitly, it is called during instanced rendering (however in that case we don't get the status, whether instancing is available)
+     * @returns Status, whether instancing was successfully initialized or whether it failed (extension not supported...)
+     */
+    initInstancing(gl: WebGL2RenderingContext | WebGLRenderingContext): boolean;
+    /**
+     * @summary Adds / updates instance data, binds instance buffer with the given shader
+     *          - signals, that further rendering will be performed as instanced (based on thw supplied "numInstances" parameter in the render method)
+     * @param program Shader program used for instanced rendering
+     * @param instanceData Per-instance data (buffer with elements, where each element is assigned to one instance (defined by "gl.vertexAttribDivisor"))
+     * @returns true/false, whether update was successful (can fail, when WebGL2 not available together with 'ANGLE_instanced_arrays' extension not available)
+     */
+    setInstanceStream(gl: WebGLRenderingContext | WebGL2RenderingContext, program: GlProgram, instanceData: TypedArray, instanceAttribLayout: Record<string, [number, number]>): boolean;
+    /**
+     * @summary Dynamically updates content of the mesh instance stream.
+     *  - Assumes, that the layout remains the same
+     *  - Currently only one instance stream is supported
+     * @param instanceData New instance data
+     */
+    updateInstanceStream(gl: WebGLRenderingContext | WebGL2RenderingContext, instanceData: TypedArray): boolean;
+    /**
+     * @returns {boolean} Flag, that instance stream was already created, so subsequent data uploads should call {@link updateInstanceStream}
+     */
+    hasInstanceStream(): boolean;
+    /**
+     * @summary Binds geometry (and index if available) buffer for following operations (e.g. rendering)
+     *  - Also used for layout definition when creating VAO {@link GlVertexArray}
+     */
+    private bindGeometry;
+    /**
+     * @summary Performs rendering of the mesh numInstances-times using WebGL2 context or WebGL1 extension
+     */
+    private renderInstanced;
+}
+/**
+ * @class A container with common geometries
+ */
+export declare class MeshFactory {
+    /** 2D Quad geometry containing only unique vertices (for indexed rendering / triangle fan)
+     * Contains vertex coordinates + UV coordinates
+     *  - an appropriate vertex layout should be {a_pos: 2, u_uv: 2}
+     */
+    static quadMeshUniqueVtxUv: number[];
+    /** 2D Quad mesh with unique vertices with only vertex positions
+     *  - an appropriate vertex layout should be {a_pos: 2}
+     */
+    static quadMeshUniqueVtx: number[];
+    /** 2D Quad mesh with defined as two triangles - 6 vertices (not - unique)
+     *  - basically geometry for drawArrays as gl.TRIANGLE
+     *  - an appropriate vertex layout should be {a_pos: 2}
+     */
+    static quadMeshTrianglesVtx: number[];
+}

package/types/client/GlProgram.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @class A wrapper class for WebGLProgram
+ *        - used for creating shader programs (compilation of shaders, linking of shader programs etc.)
+ */
+export declare class GlProgram {
+    private static numPrograms;
+    private _program;
+    /** Class instance unique id, tracks number of created instances */
+    private _programId;
+    private _programName;
+    private constructor();
+    /**
+     * @summary Resets program instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @returns Unique program id
+     */
+    get programId(): number;
+    /**
+     * @summary Creates shader program from shader sources in strings (vertex and fragment shader source codes)
+     * @param vertexShaderSourceCode String with VS shader code
+     * @param fragmentShaderSourceCode String with FS shader code
+     * @param name String with program name, required for proper error reporting
+     * @returns {GlProgram} Created GlProgram instance
+     * @throws {GlError} When shader compilation fails or program linking fails
+     */
+    static constructWithSources(gl: WebGLRenderingContext, vertexShaderSourceCode: string, fragmentShaderSourceCode: string, name: string): GlProgram;
+    /**
+     * @summary Sets the program as current for rendering
+     */
+    use(gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    /**
+     * @returns {WebGLProgram} WebGLProgram handle (id)
+     */
+    getProgram(): WebGLProgram;
+    /**
+     * @summary Safely deletes the shader program including its shaders
+     */
+    destroy(gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+}

package/types/client/GlRenderer.d.ts

@@ -0,0 +1,95 @@
+import { GlProgram, GlslDataType, type GlMesh } from '@windy/glUtils';
+import type { UniformDataType, UniformRecord } from '@windy/glUtils.d';
+import type { MapLibreMap as MaplibreGlMap } from '@leafletGl';
+import type { Vector4 } from '@windy/math';
+/**
+ * @class WebGL renderer abstraction class
+ *        - class the should provide simple setup and usage of WebGL renderer
+ */
+export declare class GlRenderer {
+    private ident;
+    protected static numRenderers: number;
+    /** List of meshes to be rendered by the renderer */
+    protected readonly meshes: GlMesh[];
+    /** Map of uniform variables used for rendering */
+    protected readonly uniforms: Map<string, UniformRecord>;
+    /** Set of uniform ids which values recently changed and therefore should be re-uploaded to the GPU */
+    protected readonly dirtyUniforms: Set<string>;
+    /** Textures must be treated separately since they must be bound each frame */
+    protected readonly uniformTextures: Map<string, UniformRecord>;
+    /** Program used for rendering */
+    protected program: GlProgram;
+    protected renderReady: boolean;
+    /** Color used to clear the bound framebuffer before rendering the content */
+    protected clearColor?: Vector4;
+    protected readonly rendererId: number;
+    constructor(ident: string);
+    /**
+     * @summary Resets renderer instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Initializes the renderer together with creating its shader program using the already fetched shader sources (strings)
+     * @param vsSrc String with source code of the Vertex Shader
+     * @param fsSrc String with source code of the Fragment Shader
+     */
+    initFromSources(gl: WebGLRenderingContext | WebGL2RenderingContext, vsSrc: string, fsSrc: string): void;
+    /**
+     * @summary Rerenders content into the currently bound framebuffer
+     * @param primitiveType Which primitives to draw (points, lines, triangles,..)
+     * @param numInstances If set >0, geometry is rendered as N instances
+     */
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, primitiveType?: GLenum, numInstances?: number): void;
+    /**
+     * @summary Updates value of the given uniform (global value sent to the GPU)
+     * @param uniformId Which uniform to update
+     * @param value New uniform value
+     */
+    updateUniformValue(uniformId: string, value: UniformDataType): void;
+    /**
+     * @summary Registers new uniform value to be used during rendering (uniform must be defined in the shader)
+     * @param uniformId Name of the uniform variable in the shader code
+     * @param dataType Data type of the uniform variable
+     * @returns {boolean} Whether the uniform was successfully registered or not
+     *  - it can fail, for example, when the passed uniformId does not match its name defined in the program
+     *      (or simply when it is not defined in the program)
+     *
+     */
+    registerUniformRecord(gl: WebGLRenderingContext | WebGL2RenderingContext, uniformId: string, dataType: GlslDataType, defaultValue?: UniformDataType): boolean;
+    /**
+     *  @summary Checks whether the uniform record is already registered (to prevent multi registering)
+     */
+    isUniformRecordRegistered(uniformId: string): boolean;
+    /**
+     * @summary Adds mesh to the list of meshes to be rendered
+     * @param mesh
+     */
+    addMesh(mesh: GlMesh): void;
+    /**
+     * @summary Retrieves shader program owned by the renderer
+     */
+    getAttachedShader(): GlProgram;
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext, map?: MaplibreGlMap): void;
+    /**
+     * @summary Sets color used for clearing the framebuffer
+     * @param color Values in range <0.0, 1.0>, if undefined, the color is unset
+     */
+    setClearColor(color: Vector4 | undefined): void;
+    /**
+     * @summary Clears the framebuffer with previously set clear-color
+     */
+    clear(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Binds dirty uniform variables for rendering
+     *  - dirty uniform is when its value has changed and must be re-uploaded to the GPU
+     *  - when value does not change, there is no need to upload it in every frame
+     */
+    protected bindUniforms(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Binds all textures that are registered in the shader for rendering
+     *  - texture uniforms (more specifically texture units and textures) must be bound for every frame since it changes global WebGL state
+     *  - texture unit id uniform is already set by "bindUniforms" method (this does not have to be updated each frame in case the texture unit does not change)
+     *  - texture activation and binding must be preformed each frame (in case we are using multiple programs because texture binding changes global WebGL state)
+     */
+    private bindTextures;
+}

package/types/client/GlTexture.d.ts

@@ -0,0 +1,98 @@
+import type { Vector2 } from '@windy/math';
+import type { GlColorFormat } from '@windy/glUtils.d';
+/**
+ * @class A wrapper class for WebGL Texture
+ */
+export declare class GlTexture {
+    private static numTextures;
+    static reset(): void;
+    /**
+     * @summary Creates texture instance using remote image
+     * @param url Url of the image to fetch
+     */
+    static createFromUrl(gl: WebGLRenderingContext | WebGL2RenderingContext, url: string): Promise<GlTexture>;
+    /** Texture target (e.g. TEXTURE_2D) */
+    private readonly _target;
+    /** WebGL texture object */
+    private readonly _texture;
+    /** Class instance unique id, for debug, tracks number of created instances */
+    private readonly _textureId;
+    /** Texture color WebGL format */
+    private _internalFormat;
+    /** Current texture dimension (pixels) */
+    private _dimensions;
+    private _uvDownScale;
+    /** Texture uv coordinates wrapping strategy (how to handle uv coordinates out of <0.0,1.0> range) */
+    private wrap;
+    /** Texture magnification and minification filtering */
+    private filter;
+    private _usedMemory;
+    /**
+     * @param format Texture internal format (data representation, e.g. RGB, RGBA, LUMINANCE_ALPHA etc.)
+     * @param target Target - TEXTURE_2D, cubemap, array texture etc.
+     */
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, format?: GlColorFormat, target?: GLenum, fromTexture?: WebGLTexture);
+    /**
+     * @returns The original WebGL texture object handle
+     */
+    get texture(): WebGLTexture;
+    /**
+     * @returns Class instance unique identifier
+     */
+    get textureId(): number;
+    /**
+     * @returns Texture target / type (TEXTURE_2D, array texture, cubemap, etc.)
+     */
+    get target(): GLenum;
+    /**
+     * @returns {Vector2} Dimensions of the texture
+     */
+    get dimensions(): Vector2;
+    set format(format: GlColorFormat);
+    get format(): GlColorFormat;
+    get uvDownScale(): Vector2;
+    /**
+     * @summary Returns gpu memory size currently used by the texture (in bytes)
+     */
+    get usedMemory(): number;
+    /**
+     * @summary Uploads new image data into the texture
+     * @param data either HTMLImageElement or tuple of [RawData, Dimensions]
+     * @param wrap texture wrapping (clamp, repeat...)
+     * @param filter texture minification and magnification filtering (nearest, linear)
+     * @param premultiply flag, whether to premultiply RGB channels by Alpha channel before uploading data to the GPU (UNPACK_PREMULTIPLY_ALPHA_WEBGL)
+     * ToDo: mip-maps, per-coordinate wrap, per mag/min filtering
+     */
+    updateContent(gl: WebGLRenderingContext | WebGL2RenderingContext, data: HTMLImageElement | [Uint8Array, Vector2] | [Uint8ClampedArray, Vector2] | HTMLCanvasElement | ImageBitmap, wrap?: GLenum, filter?: GLenum, premultiply?: boolean): void;
+    /**
+     * @summary Binds the texture for rendering and other operations
+     * @param wrap Wrap settings, how to handle texture coordinates out of <0.0, 1.0> bounds (where to read)
+     * @param filter Texture minification and magnification filtering (nearest / interpolation)
+     */
+    bind(gl: WebGLRenderingContext | WebGL2RenderingContext, wrap?: GLenum, filter?: GLenum): void;
+    /**
+     * @summary Unbinds the texture
+     */
+    unbind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Destructor, releases WebGL texture
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Resizes the texture with null data and/or sets new texture format
+     *  - the reason of performing both in one method is to ideally perform both operations using single gl.texImage2D call
+     * @param newSize Dimensions in pixels
+     * @param disableDownscale Flag that disables the resize
+     *      (since there are multiple conditions, that can lead to preventing the resize from outer scope)
+     * @param newFormat Optional new color format to be set to the texture
+     * @returns {Vector2} A rescale vector representing the factor by which the original UV coordinates should be rescaled
+     *      in case texture down-scaling is disabled {@link disableDownscale} --> in this way the UV range is constrained only to the valid area
+     */
+    resize(gl: WebGLRenderingContext | WebGL2RenderingContext, newSize: Vector2, disableDownscale?: boolean, newFormat?: GlColorFormat): Vector2;
+    /**
+     * @summary Reallocates the texture based on the new dimensions and/or new color format
+     */
+    private reallocate;
+    private setupProfiling;
+    private updateProfilingStats;
+}

package/types/client/GlVertexArray.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @class A wrapper class for WebGL VertexArrayObject (VAO)
+ */
+export declare class GlVertexArray {
+    private static vaosCount;
+    private readonly vaoId;
+    private vao;
+    /**
+     * @summary Resets vao instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Tries to create WebGL VertexArrayObject
+     * @returns {GlVertexArray | null} GlVertexArray instance or null,
+     *      if WebGL1 used and VAO extension (OES_vertex_array_object) is not available
+     */
+    static create(gl: WebGLRenderingContext | WebGL2RenderingContext): GlVertexArray | null;
+    /**
+     * @summary Binds the Vertex Array for rendering
+     *          - Binds proper VAO (either by WebGL2 or by WebGL1 extension)
+     */
+    bind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Unbinds the Vertex Array
+     */
+    unbind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Destructor - releases all WebGL resources
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Tries to initialize the WebGL/WebGL2 VertexArrayObject
+     * @returns {boolean} Flag whether the initialization was successful
+     *  - it can fail in case the WebGL2 is not supported and
+     *    the WebGL1 extension "OES_vertex_array_object" is not available
+     */
+    private init;
+}