bg2e-js 2.3.12 → 2.3.13

package/src/shaders/PickSelectionShader.ts

@@ -1,101 +1,101 @@
-import Shader from "../render/Shader";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-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 WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
-
-const g_code = {
-    webgl: {
-        vertex: `precision mediump float;
-        
-        attribute vec3 vertPosition;
-        
-        uniform mat4 mWorld;
-        uniform mat4 mView;
-        uniform mat4 mProj;
-        
-        void main() {
-            gl_Position = mProj * mView * mWorld * vec4(vertPosition, 1.0);
-        }`,
-
-        fragment: `precision mediump float;
-        
-        uniform vec4 uPickColor;
-        uniform bool uSelected;
-        
-        void main() {
-            if (uSelected) {
-                gl_FragColor = vec4(uPickColor);
-            }
-            else {
-                discard;
-            }
-        }`
-    }
-}
-
-export default class PickSelectionShader extends Shader {
-    protected _program: ShaderProgram | null = null;
-    protected _forceDraw: boolean = false;
-
-    constructor(renderer: Renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("PickSelectionShader is only compatible with WebGL renderer");
-        }
-    }
-
-    async load() {
-        const { gl } = (this.renderer as WebGLRenderer);
-
-        this._program = new ShaderProgram(gl, "PickSelectionShader");
-        this._program.attachVertexSource(g_code.webgl.vertex);
-        this._program.attachFragmentSource(g_code.webgl.fragment);
-        this._program.link();
-
-        this._forceDraw = true;
-    }
-
-    set forceDraw(d: boolean) {
-        this._forceDraw = d;
-    }
-
-    get forceDraw() {
-        return this._forceDraw;
-    }
-
-    setup(
-        plistRenderer: PolyListRenderer,
-        materialRenderer: MaterialRenderer,
-        modelMatrix: Mat4,
-        viewMatrix: Mat4,
-        projectionMatrix: Mat4
-    ) {
-        if (!this._program) {
-            throw new Error("PickSelectionShader: shader program is not loaded");
-        }
-
-        const rend = this.renderer as WebGLRenderer;
-        rend.state.shaderProgram = this._program;
-        this._program.uniformMatrix4fv('mWorld', false, modelMatrix);
-        this._program.uniformMatrix4fv('mView', false, viewMatrix);
-        this._program.uniformMatrix4fv('mProj', false, projectionMatrix);
-        this._program.uniform1i('uSelected', (this._forceDraw || plistRenderer.polyList.isSelected) ? 1 : 0);
-
-        const { polyList } = plistRenderer;
-        this._program.uniform4fv('uPickColor', polyList.colorCode);
-
-        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("vertPosition"));
-    }
-
-    destroy() {
-        if (this._program) {
-            ShaderProgram.Delete(this._program);
-            this._program = null;
-        }
-    }
-}
+import Shader from "../render/Shader";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+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 WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+        
+        attribute vec3 vertPosition;
+        
+        uniform mat4 mWorld;
+        uniform mat4 mView;
+        uniform mat4 mProj;
+        
+        void main() {
+            gl_Position = mProj * mView * mWorld * vec4(vertPosition, 1.0);
+        }`,
+
+        fragment: `precision mediump float;
+        
+        uniform vec4 uPickColor;
+        uniform bool uSelected;
+        
+        void main() {
+            if (uSelected) {
+                gl_FragColor = vec4(uPickColor);
+            }
+            else {
+                discard;
+            }
+        }`
+    }
+}
+
+export default class PickSelectionShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+    protected _forceDraw: boolean = false;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("PickSelectionShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "PickSelectionShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+
+        this._forceDraw = true;
+    }
+
+    set forceDraw(d: boolean) {
+        this._forceDraw = d;
+    }
+
+    get forceDraw() {
+        return this._forceDraw;
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("PickSelectionShader: shader program is not loaded");
+        }
+
+        const rend = this.renderer as WebGLRenderer;
+        rend.state.shaderProgram = this._program;
+        this._program.uniformMatrix4fv('mWorld', false, modelMatrix);
+        this._program.uniformMatrix4fv('mView', false, viewMatrix);
+        this._program.uniformMatrix4fv('mProj', false, projectionMatrix);
+        this._program.uniform1i('uSelected', (this._forceDraw || plistRenderer.polyList.isSelected) ? 1 : 0);
+
+        const { polyList } = plistRenderer;
+        this._program.uniform4fv('uPickColor', polyList.colorCode);
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("vertPosition"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}

package/src/shaders/PresentDebugFramebufferShader.ts

@@ -1,118 +1,118 @@
-
-import { TextureTargetName } from '../base/Texture';
-import Shader from '../render/Shader';
-import ShaderProgram from '../render/webgl/ShaderProgram';
-import ShaderFunction from './ShaderFunction';
-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;
-            `,
-            [
-                new ShaderFunction('void','main','',`{
-                    vec3 color = texture2D(uTexture, fragTexCoord).rgb;
-                    if (color.r!=0.0 || color.g!=0.0 || color.b!=0.0) {
-                        gl_FragColor = vec4(color, 1.0);
-                    }
-                    else {
-                        discard;
-                    }
-                }`)
-            ])
-    }
-}
-
-export default class PresentDebugFramebufferShader 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("PresentDebugFramebufferShader is only compatible with WebGL renderer");
-        }
-    }
-
-    async load() {
-        const { gl } = (this.renderer as WebGLRenderer);
-
-        this._program = new ShaderProgram(gl, "PresentDebugFramebufferShader");
-        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("PresentDebugFramebufferShader: 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("PresentDebugFramebufferShader: 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;
-        }
-    }
-}
+
+import { TextureTargetName } from '../base/Texture';
+import Shader from '../render/Shader';
+import ShaderProgram from '../render/webgl/ShaderProgram';
+import ShaderFunction from './ShaderFunction';
+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;
+            `,
+            [
+                new ShaderFunction('void','main','',`{
+                    vec3 color = texture2D(uTexture, fragTexCoord).rgb;
+                    if (color.r!=0.0 || color.g!=0.0 || color.b!=0.0) {
+                        gl_FragColor = vec4(color, 1.0);
+                    }
+                    else {
+                        discard;
+                    }
+                }`)
+            ])
+    }
+}
+
+export default class PresentDebugFramebufferShader 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("PresentDebugFramebufferShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "PresentDebugFramebufferShader");
+        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("PresentDebugFramebufferShader: 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("PresentDebugFramebufferShader: 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/PresentTextureShader.ts

@@ -1,99 +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;
-        }
-    }
-}
+
+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;
+        }
+    }
+}