bg2e-js 2.1.1 → 2.2.0

package/src/shaders/PresentTextureShader.ts

@@ -0,0 +1,99 @@
+
+import { TextureTargetName } from '../base/Texture';
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Shader from '../render/Shader';
+import ShaderProgram from '../render/webgl/ShaderProgram';
+import Mat4 from "../math/Mat4";
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLTextureRenderer from "../render/webgl/TextureRenderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+
+        attribute vec3 position;
+        attribute vec2 texCoord;
+        
+        varying vec2 fragTexCoord;
+
+        void main() {
+            fragTexCoord = texCoord;
+            gl_Position = vec4(position, 1.0);
+        }`,
+
+        fragment: `precision mediump float;
+        
+        varying vec2 fragTexCoord;
+        
+        uniform sampler2D uTexture;
+        
+        void main() {
+            vec4 texColor = texture2D(uTexture, fragTexCoord);
+            gl_FragColor = vec4(texColor.rgb, 1.0);
+        }`
+    }
+}
+
+export default class PresentTextureShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("PresentTextureShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "DefaultPresentTextureShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("PresentTextureShader: shader program is not loaded");
+        }
+
+        const rend = this.renderer as WebGLRenderer;
+        const { gl } = rend;
+
+        rend.state.shaderProgram = this._program;
+
+        gl.activeTexture(gl.TEXTURE0);
+        this._program.uniform1i('uTexture', 0);
+
+        const material = materialRenderer.material;
+        const webglTexture = (materialRenderer.getTextureRenderer('albedoTexture') as WebGLTextureRenderer)?.getApiObject();
+        if (webglTexture && material.albedoTexture) {
+            const target = TextureTargetName[material.albedoTexture.target];
+            gl.bindTexture((gl as any)[target], webglTexture);
+        }
+        else {
+            throw new Error("PresentTextureShader: invalid material setup. The albedoTexture material attribute must to be a texture");
+        }
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("position"));
+        this._program.texCoordAttribPointer((plistRenderer as WebGLPolyListRenderer).texCoord0AttribParams("texCoord"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}

package/src/shaders/SelectionHighlightShader.ts

@@ -0,0 +1,127 @@
+
+import { TextureTargetName } from '../base/Texture';
+import Shader from '../render/Shader';
+import ShaderProgram from '../render/webgl/ShaderProgram';
+import ShaderFunction from './ShaderFunction';
+import { applyConvolution } from './webgl_shader_lib';
+import Vec from '../math/Vec';
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Mat4 from "../math/Mat4";
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLTextureRenderer from "../render/webgl/TextureRenderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+
+        attribute vec3 position;
+        attribute vec2 texCoord;
+        
+        varying vec2 fragTexCoord;
+
+        void main() {
+            fragTexCoord = texCoord;
+            gl_Position = vec4(position, 1.0);
+        }`,
+
+        fragment: ShaderFunction.GetShaderCode(`precision mediump float;
+            varying vec2 fragTexCoord;
+            
+            uniform sampler2D uTexture;
+            uniform float uConvMatrix[9];
+            uniform vec4 uBorderColor;
+            uniform float uBorderWidth;
+            uniform vec2 uTexSize;
+            `,
+            [
+                new ShaderFunction('void','main','',`{
+                    vec4 selectionColor = applyConvolution(uTexture, fragTexCoord, uTexSize, uConvMatrix, uBorderWidth);
+                    if (selectionColor.r!=0.0 && selectionColor.g!=0.0 && selectionColor.b!=0.0) {
+                        gl_FragColor = uBorderColor;
+                    }
+                    else {
+                        discard;
+                    }
+                }`, [applyConvolution])
+            ])
+    }
+}
+
+export default class SelectionHighlightShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+    protected _borderWidth!: number;
+    protected _borderColor!: Vec;
+    protected _convMatrix!: number[];
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("SelectionHighlightShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "SelectionHighlightShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+
+        this._borderWidth = 3;
+        this._borderColor = new Vec([0.0, 0.7, 1, 1.0]);
+        this._convMatrix = [
+            0, 1, 0,
+            1,-4, 1,
+            0, 1, 0
+        ];
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("SelectionHighlightShader: shader program is not loaded");
+        }
+
+        const rend = this.renderer as WebGLRenderer;
+        const { gl, viewport } = rend;
+
+        rend.state.shaderProgram = this._program;
+
+        gl.activeTexture(gl.TEXTURE0);
+        this._program.uniform1i('uTexture', 0);
+        this._program.uniform2f('uTexSize', viewport[2], viewport[3]);
+        this._program.uniform1f('uBorderWidth', this._borderWidth);
+        this._program.uniform4fv('uBorderColor', this._borderColor);
+        this._program.uniform1fv('uConvMatrix', this._convMatrix);
+
+        const material = materialRenderer.material;
+        const webglTexture = (materialRenderer.getTextureRenderer('albedoTexture') as WebGLTextureRenderer)?.getApiObject();
+        if (webglTexture && material.albedoTexture) {
+            const target = TextureTargetName[material.albedoTexture.target];
+            gl.bindTexture((gl as any)[target], webglTexture);
+        }
+        else {
+            throw new Error("SelectionHighlightShader: invalid material setup. The albedoTexture material attribute must to be a texture");
+        }
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("position"));
+        this._program.texCoordAttribPointer((plistRenderer as WebGLPolyListRenderer).texCoord0AttribParams("texCoord"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}

package/src/shaders/ShaderFunction.ts

@@ -0,0 +1,318 @@
+interface FunctionLike {
+    name: string;
+}
+
+export type DependencyItem = string | ShaderFunction;
+
+export interface ConstantDefinition {
+    name: string;
+    value: string;
+}
+
+const isRequired = (candidateFunction: FunctionLike, includedFunctions: FunctionLike[]): boolean => {
+    return !includedFunctions.find(includedFunc => includedFunc.name === candidateFunction.name);
+}
+
+const getAllDependencies = (fn: ShaderFunction, result: ShaderFunction[] = []): void => {
+    fn.dependencies
+        .filter((depFn): depFn is ShaderFunction => typeof depFn !== 'string')
+        .forEach(depFn => {
+            getAllDependencies(depFn, result);
+            result.push(depFn);
+        });
+    result.push(fn);
+}
+
+const getDependencies = (fn: ShaderFunction): ShaderFunction[] => {
+    const allFunctions: ShaderFunction[] = [];
+    getAllDependencies(fn, allFunctions);
+    const includedFunctions: string[] = [];
+    return allFunctions.filter(candidateFn => {
+        if (includedFunctions.indexOf(candidateFn.name) === -1) {
+            includedFunctions.push(candidateFn.name);
+            return true;
+        }
+    });
+}
+
+const getDefinitions = (requiredFunctions: (string | ShaderFunction)[]): string => {
+    const includedDefinitions: string[] = [];
+    requiredFunctions.flatMap(req => typeof req === 'string' ? [] : req.dependencies).forEach(req => {
+        if (typeof req === 'string') {
+            includedDefinitions.push(req);
+        }
+    });
+    return Array.from(new Set(includedDefinitions)).join('\n\n');
+}
+export default class ShaderFunction {
+    private _returnType: string;
+    private _name: string;
+    private _params: string;
+    private _body: string;
+    private _deps: DependencyItem[];
+
+    constructor(returnType: string, name: string, params: string, body: string, deps: DependencyItem[] = []) {
+        this._returnType = returnType;
+        this._name = name;
+        this._params = params;
+        this._body = body;
+        this._deps = deps;
+    }
+
+    get returnType(): string {
+        return this._returnType;
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    get params(): string {
+        return this._params;
+    }
+
+    get body(): string {
+        return this._body;
+    }
+
+    get dependencies(): DependencyItem[] {
+        return this._deps;
+    }
+
+    getFunctionText(): string {
+        return `${this.returnType} ${this.name}(${this.params}) ${this.body}`;
+    }
+
+    static GetShaderCode(header: string, requiredFunctions: (string | ShaderFunction)[]): string {
+        let allFunctions: ShaderFunction[] = [];
+        let rawCode = '';
+        let definitions = getDefinitions(requiredFunctions);
+        requiredFunctions.forEach(req => {
+            if (typeof req === 'string') {
+                // Add directly the string to the code
+                rawCode += req + '\n\n';
+            }
+            else {
+                allFunctions = [...allFunctions, ...getDependencies(req)];
+            }
+        });
+        let code = header + '\n\n' + definitions + '\n\n' + rawCode + '\n\n';
+        allFunctions.forEach(fn => {
+            code += fn.getFunctionText() + "\n\n";
+        });
+
+        return code;
+    }
+}
+
+// This utility function generate an array of ShaderFunction objects from a block of GLSL code
+export function generateShaderLibrary(glslCode: string): (string | ShaderFunction)[] {
+    return [
+        ...splitStructs(glslCode),
+        ...splitFunctions(glslCode)
+            .map(func => createShaderFunctionObject(func))
+    ];
+}
+
+// Extracts #define constants from a block of GLSL code
+export function extractConstants(glslCode: string): ConstantDefinition[] {
+    const constants: ConstantDefinition[] = [];
+    const lines = glslCode.split('\n');
+    
+    for (let line of lines) {
+        const trimmedLine = line.trim();
+        
+        // Check if line is a #define directive
+        if (trimmedLine.startsWith('#define')) {
+            // Remove #define and split by whitespace
+            const parts = trimmedLine.substring(7).trim().split(/\s+/);
+            
+            if (parts.length >= 2) {
+                const name = parts[0];
+                // Join remaining parts as the value (in case value contains spaces)
+                const value = parts.slice(1).join(' ');
+                
+                constants.push({
+                    name: name,
+                    value: value
+                });
+            }
+        }
+    }
+    
+    return constants;
+}
+
+export function splitStructs(glslCode: string): string[] {
+    const structs: string[] = [];
+    const lines = glslCode.split('\n');
+    let currentStruct = '';
+    let braceCount = 0;
+    let inStruct = false;
+    
+    for (let line of lines) {
+        const trimmedLine = line.trim();
+        
+        // Skip empty lines, comments, and preprocessor directives
+        if (!trimmedLine || 
+            trimmedLine.startsWith('//') || 
+            trimmedLine.startsWith('/*') || 
+            trimmedLine.startsWith('#')) {
+            continue;
+        }
+        
+        // Check if this line starts a struct definition
+        if (!inStruct && trimmedLine.startsWith('struct')) {
+            inStruct = true;
+            currentStruct = line + '\n';
+            braceCount += (line.match(/\{/g) || []).length;
+            braceCount -= (line.match(/\}/g) || []).length;
+            
+            // Check if struct ends on the same line (unlikely but possible)
+            if (braceCount === 0 && trimmedLine.includes('{') && trimmedLine.includes('}')) {
+                structs.push(currentStruct.trim());
+                currentStruct = '';
+                inStruct = false;
+            }
+            continue;
+        }
+        
+        if (inStruct) {
+            currentStruct += line + '\n';
+            braceCount += (line.match(/\{/g) || []).length;
+            braceCount -= (line.match(/\}/g) || []).length;
+            
+            // Struct definition ends when we reach the closing brace and optional semicolon
+            if (braceCount === 0) {
+                structs.push(currentStruct.trim());
+                currentStruct = '';
+                inStruct = false;
+            }
+        }
+    }
+    
+    return structs;
+}
+
+// Replace the constants in the GLSL code with their values
+export function processConstants(glslCode: string, constants: ConstantDefinition[]): string {
+    let processedCode = glslCode;
+    
+    // Sort constants by name length (descending) to avoid partial replacements
+    // For example, if we have PI and PI_2, we want to replace PI_2 first
+    const sortedConstants = [...constants].sort((a, b) => b.name.length - a.name.length);
+    
+    sortedConstants.forEach(constant => {
+        // Create a regex that matches the constant name as a whole word
+        // This prevents partial matches (e.g., PI matching inside PIRATE)
+        const regex = new RegExp(`\\b${escapeRegExp(constant.name)}\\b`, 'g');
+        processedCode = processedCode.replace(regex, constant.value);
+    });
+    
+    return processedCode;
+}
+
+/////  Private helper functions
+
+// Helper function to escape special regex characters
+function escapeRegExp(string: string): string {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function splitFunctions(shaderCode: string): string[] {
+    const functions: string[] = [];
+    const lines = shaderCode.split('\n');
+    let currentFunction = '';
+    let braceCount = 0;
+    let inFunction = false;
+    
+    for (let line of lines) {
+        const trimmedLine = line.trim();
+        
+        // Skip empty lines, comments, preprocessor directives, and global variables
+        if (!trimmedLine || 
+            trimmedLine.startsWith('//') || 
+            trimmedLine.startsWith('/*') || 
+            trimmedLine.startsWith('#') ||
+            (trimmedLine.includes(';') && !inFunction && !trimmedLine.includes('{'))) {
+            continue;
+        }
+        
+        // Check if this line starts a function (contains parentheses and opening brace pattern)
+        if (!inFunction && trimmedLine.includes('(') && trimmedLine.includes(')')) {
+            // Look for function pattern: type name(params) or name(params)
+            const functionPattern = /^\s*\w+\s+\w+\s*\([^)]*\)\s*\{?|^\s*\w+\s*\([^)]*\)\s*\{?/;
+            if (functionPattern.test(trimmedLine)) {
+                inFunction = true;
+                currentFunction = line + '\n';
+                braceCount += (line.match(/\{/g) || []).length;
+                braceCount -= (line.match(/\}/g) || []).length;
+                
+                if (braceCount === 0 && trimmedLine.includes('{') && trimmedLine.includes('}')) {
+                    // Single line function
+                    functions.push(currentFunction.trim());
+                    currentFunction = '';
+                    inFunction = false;
+                }
+                continue;
+            }
+        }
+        
+        if (inFunction) {
+            currentFunction += line + '\n';
+            braceCount += (line.match(/\{/g) || []).length;
+            braceCount -= (line.match(/\}/g) || []).length;
+            
+            if (braceCount === 0) {
+                functions.push(currentFunction.trim());
+                currentFunction = '';
+                inFunction = false;
+            }
+        }
+    }
+    
+    return functions;
+}
+
+function createShaderFunctionObject(functionCode: string): ShaderFunction {
+    const trimmedCode = functionCode.trim();
+    
+    // Find the opening brace to separate signature from body
+    const openBraceIndex = trimmedCode.indexOf('{');
+    if (openBraceIndex === -1) {
+        throw new Error('Invalid function: no opening brace found');
+    }
+    
+    // Extract function signature and body
+    const signature = trimmedCode.substring(0, openBraceIndex).trim();
+    const body = trimmedCode.substring(openBraceIndex + 1, trimmedCode.lastIndexOf('}')).trim();
+    
+    // Parse the signature to extract return type, name, and parameters
+    const parenIndex = signature.indexOf('(');
+    const closeParenIndex = signature.lastIndexOf(')');
+    
+    if (parenIndex === -1 || closeParenIndex === -1) {
+        throw new Error('Invalid function signature: missing parentheses');
+    }
+    
+    // Extract parameters
+    const parameters = signature.substring(parenIndex + 1, closeParenIndex).trim();
+    
+    // Extract return type and function name from the part before parentheses
+    const beforeParens = signature.substring(0, parenIndex).trim();
+    const parts = beforeParens.split(/\s+/);
+    
+    let returnType, functionName;
+    if (parts.length >= 2) {
+        // Format: "returnType functionName"
+        returnType = parts.slice(0, -1).join(' ');
+        functionName = parts[parts.length - 1];
+    } else {
+        // Format: "functionName" (assuming void return type)
+        returnType = 'void';
+        functionName = parts[0];
+    }
+    
+    return new ShaderFunction(returnType, functionName, parameters, ` {\n\t${body}\n}`);
+}
+

package/src/shaders/SkyCubeShader.ts

@@ -0,0 +1,94 @@
+import Mat4 from "../math/Mat4";
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import Shader from "../render/Shader";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+import WebGLTextureRenderer from "../render/webgl/TextureRenderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+
+        attribute vec3 vertPosition;
+
+        uniform mat4 uMVP;
+
+        varying vec3 fragNormal;
+
+        void main() {
+            gl_Position = uMVP * vec4(vertPosition,1.0);
+
+            // The normal can be extracted from the position
+            // since this shader is designed to be used with
+            // a cube centered in 0,0,0
+            fragNormal = normalize(vertPosition);
+        }
+        `,
+
+        fragment: `precision mediump float;
+        varying vec3 fragNormal;
+        
+        uniform samplerCube uCubemap;
+        
+        void main() {
+            gl_FragColor = textureCube(uCubemap, normalize(fragNormal));
+        }`
+    }
+};
+
+export default class SkyCubeShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("SkyCubeShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "SkyCubeShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("SkyCubeShader: shader program is not loaded");
+        }
+
+        const rend = this.renderer as WebGLRenderer;
+        const { gl } = rend;
+        rend.state.shaderProgram = this._program;
+
+        const mvp = Mat4.Mult(projectionMatrix, viewMatrix);
+        this._program.uniformMatrix4fv('uMVP', false, mvp);
+
+        gl.activeTexture(gl.TEXTURE0);
+        this._program.uniform1i('uCubemap', 0);
+        const webglTexture = (materialRenderer.getTextureRenderer('albedoTexture') as WebGLTextureRenderer)?.getApiObject();
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, webglTexture);
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("vertPosition"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}