rename uniformBuffer to Ubo for consistency

scripts/utils/autoGenerateUnsafeEvalFunctions.ts

@@ -4,9 +4,9 @@ import {
     UNIFORM_TO_SINGLE_SETTERS
 } from '../../src/rendering/renderers/gl/shader/utils/generateUniformsSyncTypes';
 import {
-    uniformBufferSyncFunctionsSTD40,
-    uniformBufferSyncFunctionsWGSL
-} from '../../src/rendering/renderers/shared/shader/utils/uniformBufferSyncFunctions';
+    uboSyncFunctionsSTD40,
+    uboSyncFunctionsWGSL
+} from '../../src/rendering/renderers/shared/shader/utils/uboSyncFunctions';
 import { uniformParsers } from '../../src/rendering/renderers/shared/shader/utils/uniformParsers';
 
 /**
@@ -51,7 +51,7 @@ function autoGenerateUnsafeEvalFunctions()
     // eslint-disable-next-line max-len
     out.push(`export type UniformUploadFunction = (name: string, cu: any, cv: any, v: any, ud: any, uv: any, gl: any) => void;`);
 
-    out.push('export const UNIFORM_TO_SINGLE_FUNCTIONS:Record<UNIFORM_TYPES|string, UniformUploadFunction> = {');
+    out.push('export const uniformSingleParserFunctions:Record<UNIFORM_TYPES|string, UniformUploadFunction> = {');
     for (const i in UNIFORM_TO_SINGLE_SETTERS)
     {
         const fn = UNIFORM_TO_SINGLE_SETTERS[i];
@@ -60,7 +60,7 @@ function autoGenerateUnsafeEvalFunctions()
     }
     out.push('};\n');
 
-    out.push('export const UNIFORM_TO_ARRAY_FUNCTIONS:Record<UNIFORM_TYPES|string, UniformUploadFunction> = {');
+    out.push('export const uniformArrayParserFunctions:Record<UNIFORM_TYPES|string, UniformUploadFunction> = {');
     for (const i in UNIFORM_TO_ARRAY_SETTERS)
     {
         const fn = UNIFORM_TO_ARRAY_SETTERS[i];
@@ -70,7 +70,7 @@ function autoGenerateUnsafeEvalFunctions()
     out.push('};\n');
 
     // now add the uniform parsers..
-    out.push('export const uniformParsersFunctions:UniformUploadFunction[] = [');
+    out.push('export const uniformParserFunctions:UniformUploadFunction[] = [');
     for (const i in uniformParsers)
     {
         const fn = uniformParsers[i].uniform;
@@ -92,7 +92,7 @@ function autoGenerateUboUnsafeEvalFunctions()
     const out: string[] = [header];
 
     // eslint-disable-next-line max-len
-    out.push(`export type UniformBufferUploadFunction = (name:string, data:Float32Array, offset:number, uv:any, v:any) => void;`);
+    out.push(`export type UboUploadFunction = (name:string, data:Float32Array, offset:number, uv:any, v:any) => void;`);
 
     function convertToFunction(body: string)
     {
@@ -103,7 +103,7 @@ function autoGenerateUboUnsafeEvalFunctions()
     }
 
     // now add the uniform parsers..
-    out.push('export const uniformBufferParsersFunctions:UniformBufferUploadFunction[] = [');
+    out.push('export const uboParserFunctions:UboUploadFunction[] = [');
     for (const i in uniformParsers)
     {
         const fn = uniformParsers[i].uboWgsl ?? uniformParsers[i].ubo;
@@ -115,21 +115,21 @@ function autoGenerateUboUnsafeEvalFunctions()
     // and the basic uploads
 
     // now add the uniform parsers..
-    out.push('export const uniformBufferFunctionsWGSL:Record<UNIFORM_TYPES|string, UniformBufferUploadFunction> = {');
-    for (const i in uniformBufferSyncFunctionsWGSL)
+    out.push('export const uboSingleFunctionsWGSL:Record<UNIFORM_TYPES|string, UboUploadFunction> = {');
+    for (const i in uboSyncFunctionsWGSL)
     {
-        const fn = uniformBufferSyncFunctionsWGSL[i as keyof typeof uniformBufferSyncFunctionsWGSL];
+        const fn = uboSyncFunctionsWGSL[i as keyof typeof uboSyncFunctionsWGSL];
 
         out.push(`'${i}': ${convertToFunction(fn)},`);
     }
 
     out.push('};');
 
     // now add the uniform parsers..
-    out.push('export const uniformBufferSyncFunctionsSTD40:Record<UNIFORM_TYPES|string, UniformBufferUploadFunction> = {');
-    for (const i in uniformBufferSyncFunctionsSTD40)
+    out.push('export const uboSingleFunctionsSTD40:Record<UNIFORM_TYPES|string, UboUploadFunction> = {');
+    for (const i in uboSyncFunctionsSTD40)
     {
-        const fn = uniformBufferSyncFunctionsSTD40[i as keyof typeof uniformBufferSyncFunctionsSTD40];
+        const fn = uboSyncFunctionsSTD40[i as keyof typeof uboSyncFunctionsSTD40];
 
         out.push(`'${i}': ${convertToFunction(fn)},`);
     }
@@ -138,7 +138,7 @@ function autoGenerateUboUnsafeEvalFunctions()
 
     const final = out.join('\n');
 
-    const path = 'src/unsafe-eval/uniformBufferSyncFunctions.ts';
+    const path = 'src/unsafe-eval/uboSyncFunctions.ts';
 
     writeFileSync(path, final, 'utf8');
 }

src/filters/FilterSystem.ts

@@ -533,7 +533,7 @@ export class FilterSystem implements System
         if ((renderer as WebGPURenderer).renderPipes.uniformBatch)
         {
             const batchUniforms = (renderer as WebGPURenderer).renderPipes.uniformBatch
-                .getUniformBufferResource(this._filterGlobalUniforms);
+                .getUboResource(this._filterGlobalUniforms);
 
             this._globalFilterBindGroup.setResource(batchUniforms, 0);
         }

src/rendering/renderers/gl/GlUboSystem.ts

@@ -0,0 +1,25 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { UboSystem } from '../shared/shader/UboSystem';
+import { createUboElementsSTD40 } from './shader/utils/createUboElementsSTD40_';
+import { createUboSyncFunctionSTD40 } from './shader/utils/createUboSyncSTD40';
+
+/**
+ * System plugin to the renderer to manage uniform buffers. But with an WGSL adaptor.
+ * @memberof rendering
+ */
+export class GlUboSystem extends UboSystem
+{
+    /** @ignore */
+    public static extension = {
+        type: [ExtensionType.WebGLSystem],
+        name: 'ubo',
+    } as const;
+
+    constructor()
+    {
+        super({
+            createUboElements: createUboElementsSTD40,
+            generateUboSync: createUboSyncFunctionSTD40,
+        });
+    }
+}

src/rendering/renderers/gl/WebGLRenderer.ts

@@ -13,7 +13,7 @@ import { GlColorMaskSystem } from './GlColorMaskSystem';
 import { GlEncoderSystem } from './GlEncoderSystem';
 import { GlRenderTargetSystem } from './GlRenderTargetSystem';
 import { GlStencilSystem } from './GlStencilSystem';
-import { GlUniformBufferSystem } from './GlUniformBufferSystem';
+import { GlUboSystem } from './GlUboSystem';
 import { GlShaderSystem } from './shader/GlShaderSystem';
 import { GlUniformGroupSystem } from './shader/GlUniformGroupSystem';
 import { GlStateSystem } from './state/GlStateSystem';
@@ -27,7 +27,7 @@ import type { GlRenderingContext } from './context/GlRenderingContext';
 
 const DefaultWebGLSystems = [
     ...SharedSystems,
-    GlUniformBufferSystem,
+    GlUboSystem,
     GlBackBufferSystem,
     GlContextSystem,
     GlBufferSystem,

src/rendering/renderers/gl/shader/GlShaderSystem.ts

@@ -149,7 +149,7 @@ export class GlShaderSystem
 
         if (isBufferResource)
         {
-            this._renderer.uniformBuffer.updateUniformGroup(uniformGroup as UniformGroup);
+            this._renderer.ubo.updateUniformGroup(uniformGroup as UniformGroup);
         }
 
         bufferSystem.updateBuffer(uniformGroup.buffer);

src/rendering/renderers/gl/shader/program/generateProgram.ts

@@ -3,7 +3,7 @@ import { GlProgramData } from '../GlProgramData';
 import { compileShader } from './compileShader';
 import { defaultValue } from './defaultValue';
 import { extractAttributesFromGlProgram } from './extractAttributesFromGlProgram';
-import { getUniformBufferData } from './getUniformBufferData';
+import { getUboData } from './getUboData';
 import { getUniformData } from './getUniformData';
 import { logProgramError } from './logProgramError';
 
@@ -58,7 +58,7 @@ export function generateProgram(gl: GlRenderingContext, program: GlProgram): GlP
 
     program._attributeData = extractAttributesFromGlProgram(webGLProgram, gl);
     program._uniformData = getUniformData(webGLProgram, gl);
-    program._uniformBlockData = getUniformBufferData(webGLProgram, gl);
+    program._uniformBlockData = getUboData(webGLProgram, gl);
 
     gl.deleteShader(glVertShader);
     gl.deleteShader(glFragShader);

src/rendering/renderers/gl/shader/program/getUniformBufferData.ts → src/rendering/renderers/gl/shader/program/getUboData.ts

@@ -7,7 +7,7 @@ import type { GlUniformBlockData } from '../GlProgram';
  * @param gl - the WebGL context
  * @returns {object} the uniform data for this program
  */
-export function getUniformBufferData(program: WebGLProgram, gl: WebGL2RenderingContext): Record<string, GlUniformBlockData>
+export function getUboData(program: WebGLProgram, gl: WebGL2RenderingContext): Record<string, GlUniformBlockData>
 {
     // if uniform buffer data is not supported, early out
     if (!gl.ACTIVE_UNIFORM_BLOCKS) return {};

src/rendering/renderers/gl/shader/utils/createUBOElementsSTD40.ts → src/rendering/renderers/gl/shader/utils/createUboElementsSTD40_.ts

@@ -1,4 +1,4 @@
-import type { UBOElement, UniformBufferLayout, UniformData } from '../../../shared/shader/types';
+import type { UboElement, UboLayout, UniformData } from '../../../shared/shader/types';
 
 export const WGSL_TO_STD40_SIZE: Record<string, number> = {
     f32: 4,
@@ -31,9 +31,9 @@ export const WGSL_TO_STD40_SIZE: Record<string, number> = {
     // mat4:     16 * 4,
 };
 
-export function createUBOElementsSTD40(uniformData: UniformData[]): UniformBufferLayout
+export function createUboElementsSTD40(uniformData: UniformData[]): UboLayout
 {
-    const uboElements: UBOElement[] = uniformData.map((data: UniformData) =>
+    const uboElements: UboElement[] = uniformData.map((data: UniformData) =>
         ({
             data,
             offset: 0,

src/rendering/renderers/gl/shader/utils/createUboSyncSTD40.ts

@@ -0,0 +1,19 @@
+/* eslint-disable quote-props */
+
+import { createUboSyncFunction } from '../../../shared/shader/utils/createUboSyncFunction_';
+import { uboSyncFunctionsSTD40 } from '../../../shared/shader/utils/uboSyncFunctions';
+import { generateArraySyncSTD40 } from './generateArraySyncSTD40';
+
+import type { UboElement, UniformsSyncCallback } from '../../../shared/shader/types';
+
+export function createUboSyncFunctionSTD40(
+    uboElements: UboElement[],
+): UniformsSyncCallback
+{
+    return createUboSyncFunction(
+        uboElements,
+        'uboStd40',
+        generateArraySyncSTD40,
+        uboSyncFunctionsSTD40,
+    );
+}

src/rendering/renderers/gl/shader/utils/generateArraySyncSTD40.ts

@@ -1,6 +1,6 @@
-import { WGSL_TO_STD40_SIZE } from './createUBOElementsSTD40';
+import { WGSL_TO_STD40_SIZE } from './createUboElementsSTD40_';
 
-import type { UBOElement } from '../../../shared/shader/types';
+import type { UboElement } from '../../../shared/shader/types';
 
 /**
  * This generates a function that will sync an array to the uniform buffer
@@ -9,7 +9,7 @@ import type { UBOElement } from '../../../shared/shader/types';
  * @param offsetToAdd - the offset to append at the start of the code
  * @returns - the generated code
  */
-export function generateArraySyncSTD40(uboElement: UBOElement, offsetToAdd: number): string
+export function generateArraySyncSTD40(uboElement: UboElement, offsetToAdd: number): string
 {
     const rowSize = Math.max(WGSL_TO_STD40_SIZE[uboElement.data.type] / 16, 1);
     const elementSize = (uboElement.data.value as Array<number>).length / uboElement.data.size;// size / rowSize;

src/rendering/renderers/gpu/BindGroupSystem.ts

@@ -63,7 +63,7 @@ export class BindGroupSystem implements System
             {
                 const uniformGroup = resource as UniformGroup;
 
-                renderer.uniformBuffer.updateUniformGroup(uniformGroup as UniformGroup);
+                renderer.ubo.updateUniformGroup(uniformGroup as UniformGroup);
 
                 const buffer = uniformGroup.buffer;
 

src/rendering/renderers/gpu/GpuEncoderSystem.ts

@@ -173,7 +173,7 @@ export class GpuEncoderSystem implements System
 
             if ((resource as UniformGroup).isUniformGroup)
             {
-                this._renderer.uniformBuffer.updateUniformGroup(resource as UniformGroup);
+                this._renderer.ubo.updateUniformGroup(resource as UniformGroup);
             }
         }
     }

src/rendering/renderers/gpu/GpuUboSystem.ts

@@ -0,0 +1,25 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { UboSystem } from '../shared/shader/UboSystem';
+import { createUboElementsWGSL } from './shader/utils/createUboElementsWGSL_';
+import { createUboSyncFunctionWGSL } from './shader/utils/createUboSyncFunctionWGSL';
+
+/**
+ * System plugin to the renderer to manage uniform buffers. With a WGSL twist!
+ * @memberof rendering
+ */
+export class GpuUboSystem extends UboSystem
+{
+    /** @ignore */
+    public static extension = {
+        type: [ExtensionType.WebGPUSystem],
+        name: 'ubo',
+    } as const;
+
+    constructor()
+    {
+        super({
+            createUboElements: createUboElementsWGSL,
+            generateUboSync: createUboSyncFunctionWGSL,
+        });
+    }
+}

src/rendering/renderers/gpu/GpuUniformBatchPipe.ts

@@ -2,7 +2,7 @@ import { ExtensionType } from '../../../extensions/Extensions';
 import { Buffer } from '../shared/buffer/Buffer';
 import { BufferResource } from '../shared/buffer/BufferResource';
 import { BufferUsage } from '../shared/buffer/const';
-import { UniformBufferBatch } from './buffer/UniformBufferBatch';
+import { UboBatch } from './buffer/UboBatch';
 import { BindGroup } from './shader/BindGroup';
 
 import type { UniformGroup } from '../shared/shader/UniformGroup';
@@ -25,7 +25,7 @@ export class GpuUniformBatchPipe
     private _renderer: WebGPURenderer;
 
     private _bindGroupHash: Record<number, BindGroup> = Object.create(null);
-    private readonly _batchBuffer: UniformBufferBatch;
+    private readonly _batchBuffer: UboBatch;
 
     // number of buffers..
     private _buffers: Buffer[] = [];
@@ -37,7 +37,7 @@ export class GpuUniformBatchPipe
     {
         this._renderer = renderer;
 
-        this._batchBuffer = new UniformBufferBatch({ minUniformOffsetAlignment });
+        this._batchBuffer = new UboBatch({ minUniformOffsetAlignment });
 
         const totalBuffers = (256 / minUniformOffsetAlignment);
 
@@ -78,22 +78,22 @@ export class GpuUniformBatchPipe
             return this._bindGroupHash[group.uid];
         }
 
-        this._renderer.uniformBuffer.ensureUniformGroup(group);
+        this._renderer.ubo.ensureUniformGroup(group);
 
         const data = group.buffer.data as Float32Array;
 
         const offset = this._batchBuffer.addEmptyGroup(data.length);
 
-        this._renderer.uniformBuffer.syncUniformGroup(group, this._batchBuffer.data, offset / 4);
+        this._renderer.ubo.syncUniformGroup(group, this._batchBuffer.data, offset / 4);
 
         this._bindGroupHash[group.uid] = this._getBindGroup(offset / minUniformOffsetAlignment);
 
         return this._bindGroupHash[group.uid];
     }
 
-    public getUniformBufferResource(group: UniformGroup<any>): BufferResource
+    public getUboResource(group: UniformGroup<any>): BufferResource
     {
-        this._renderer.uniformBuffer.updateUniformGroup(group);
+        this._renderer.ubo.updateUniformGroup(group);
 
         const data = group.buffer.data as Float32Array;