@babylonjs/core 7.37.0 → 7.37.2

package/Materials/GreasedLine/greasedLinePluginMaterialShadersGLSL.js

@@ -0,0 +1,158 @@
+/**
+ * Returns GLSL custom shader code
+ * @param shaderType vertex or fragment
+ * @param cameraFacing is in camera facing mode?
+ * @returns GLSL custom shader code
+ */
+/** @internal */
+export function GetCustomCode(shaderType, cameraFacing) {
+    if (shaderType === "vertex") {
+        const obj = {
+            CUSTOM_VERTEX_DEFINITIONS: `
+                attribute float grl_widths;
+                attribute vec3 grl_offsets;
+                attribute float grl_colorPointers;
+                varying float grlCounters;
+                varying float grlColorPointer;
+
+                #ifdef GREASED_LINE_CAMERA_FACING
+                    attribute vec4 grl_previousAndSide;
+                    attribute vec4 grl_nextAndCounters;
+
+                    vec2 grlFix( vec4 i, float aspect ) {
+                        vec2 res = i.xy / i.w;
+                        res.x *= aspect;
+                        return res;
+                    }
+                #else
+                    attribute vec3 grl_slopes;
+                    attribute float grl_counters;
+                #endif
+                `,
+            CUSTOM_VERTEX_UPDATE_POSITION: `
+                #ifdef GREASED_LINE_CAMERA_FACING
+                    vec3 grlPositionOffset = grl_offsets;
+                    positionUpdated += grlPositionOffset;
+                #else
+                    positionUpdated = (positionUpdated + grl_offsets) + (grl_slopes * grl_widths);
+                #endif
+                `,
+            CUSTOM_VERTEX_MAIN_END: `
+                grlColorPointer = grl_colorPointers;
+
+                #ifdef GREASED_LINE_CAMERA_FACING
+
+                    float grlAspect = grl_aspect_resolution_lineWidth.x;
+                    float grlBaseWidth = grl_aspect_resolution_lineWidth.w;
+
+                    vec3 grlPrevious = grl_previousAndSide.xyz;
+                    float grlSide = grl_previousAndSide.w;
+
+                    vec3 grlNext = grl_nextAndCounters.xyz;
+                    grlCounters = grl_nextAndCounters.w;
+
+                    mat4 grlMatrix = viewProjection * finalWorld;
+                    vec4 grlFinalPosition = grlMatrix * vec4(positionUpdated, 1.0);
+                    vec4 grlPrevPos = grlMatrix * vec4(grlPrevious + grlPositionOffset, 1.0);
+                    vec4 grlNextPos = grlMatrix * vec4(grlNext + grlPositionOffset, 1.0);
+
+                    vec2 grlCurrentP = grlFix(grlFinalPosition, grlAspect);
+                    vec2 grlPrevP = grlFix(grlPrevPos, grlAspect);
+                    vec2 grlNextP = grlFix(grlNextPos, grlAspect);
+
+                    float grlWidth = grlBaseWidth * grl_widths;
+
+                    vec2 grlDir;
+                    if (grlNextP == grlCurrentP) {
+                        grlDir = normalize(grlCurrentP - grlPrevP);
+                    } else if (grlPrevP == grlCurrentP) {
+                        grlDir = normalize(grlNextP - grlCurrentP);
+                    } else {
+                        vec2 grlDir1 = normalize(grlCurrentP - grlPrevP);
+                        vec2 grlDir2 = normalize(grlNextP - grlCurrentP);
+                        grlDir = normalize(grlDir1 + grlDir2);
+                    }
+                    vec4 grlNormal = vec4(-grlDir.y, grlDir.x, 0., 1.);
+
+                    #ifdef GREASED_LINE_RIGHT_HANDED_COORDINATE_SYSTEM
+                        grlNormal.xy *= -.5 * grlWidth;
+                    #else
+                        grlNormal.xy *= .5 * grlWidth;
+                    #endif
+
+                    grlNormal *= grl_projection;
+
+                    #ifdef GREASED_LINE_SIZE_ATTENUATION
+                        grlNormal.xy *= grlFinalPosition.w;
+                        grlNormal.xy /= (vec4(grl_aspect_resolution_lineWidth.yz, 0., 1.) * grl_projection).xy;
+                    #endif
+
+                    grlFinalPosition.xy += grlNormal.xy * grlSide;
+                    gl_Position = grlFinalPosition;
+
+                    vPositionW = vec3(grlFinalPosition);
+                #else
+                    grlCounters = grl_counters;
+                #endif
+                `,
+        };
+        cameraFacing && (obj["!gl_Position\\=viewProjection\\*worldPos;"] = "//"); // not needed for camera facing GRL
+        return obj;
+    }
+    if (shaderType === "fragment") {
+        return {
+            CUSTOM_FRAGMENT_DEFINITIONS: `
+                    varying float grlCounters;
+                    varying float grlColorPointer;
+                    uniform sampler2D grl_colors;
+                `,
+            CUSTOM_FRAGMENT_MAIN_END: `
+                    float grlColorMode = grl_colorMode_visibility_colorsWidth_useColors.x;
+                    float grlVisibility = grl_colorMode_visibility_colorsWidth_useColors.y;
+                    float grlColorsWidth = grl_colorMode_visibility_colorsWidth_useColors.z;
+                    float grlUseColors = grl_colorMode_visibility_colorsWidth_useColors.w;
+
+                    float grlUseDash = grl_dashOptions.x;
+                    float grlDashArray = grl_dashOptions.y;
+                    float grlDashOffset = grl_dashOptions.z;
+                    float grlDashRatio = grl_dashOptions.w;
+
+                    gl_FragColor.a *= step(grlCounters, grlVisibility);
+                    if(gl_FragColor.a == 0.) discard;
+
+                    if(grlUseDash == 1.){
+                        gl_FragColor.a *= ceil(mod(grlCounters + grlDashOffset, grlDashArray) - (grlDashArray * grlDashRatio));
+                        if (gl_FragColor.a == 0.) discard;
+                    }
+
+                    #ifdef GREASED_LINE_HAS_COLOR
+                        if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
+                            gl_FragColor.rgb = grl_singleColor;
+                        } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
+                            gl_FragColor.rgb += grl_singleColor;
+                        } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
+                            gl_FragColor.rgb *= grl_singleColor;
+                        }
+                    #else
+                        if (grlUseColors == 1.) {
+                            #ifdef GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE
+                                vec4 grlColor = texture2D(grl_colors, vec2(grlCounters, 0.), 0.);
+                            #else
+                                vec2 lookup = vec2(fract(grlColorPointer / grl_textureSize.x), 1.0 - floor(grlColorPointer / grl_textureSize.x) / max(grl_textureSize.y - 1.0, 1.0));
+                                vec4 grlColor = texture2D(grl_colors, lookup, 0.0);
+                            #endif
+                            if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
+                                gl_FragColor = grlColor;
+                            } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
+                                gl_FragColor += grlColor;
+                            } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
+                                gl_FragColor *= grlColor;
+                            }
+                        }
+                    #endif
+                `,
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=greasedLinePluginMaterialShadersGLSL.js.map

package/Materials/GreasedLine/greasedLinePluginMaterialShadersGLSL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greasedLinePluginMaterialShadersGLSL.js","sourceRoot":"","sources":["../../../../../dev/core/src/Materials/GreasedLine/greasedLinePluginMaterialShadersGLSL.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gBAAgB;AAChB,MAAM,UAAU,aAAa,CAAC,UAAkB,EAAE,YAAqB;IACnE,IAAI,UAAU,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAQ;YACb,yBAAyB,EAAE;;;;;;;;;;;;;;;;;;;;iBAoBtB;YACL,6BAA6B,EAAE;;;;;;;iBAO1B;YACL,sBAAsB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDnB;SACR,CAAC;QACF,YAAY,IAAI,CAAC,GAAG,CAAC,2CAA2C,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,mCAAmC;QAC9G,OAAO,GAAG,CAAC;IACf,CAAC;IAED,IAAI,UAAU,KAAK,UAAU,EAAE,CAAC;QAC5B,OAAO;YACH,2BAA2B,EAAE;;;;iBAIxB;YACL,wBAAwB,EAAE;;;;;;;;;;;;;;;;;;;;8CAoBQ,+CAAuC;;qDAEhC,+CAAuC;;qDAEvC,oDAA4C;;;;;;;;;;;kDAW/C,+CAAuC;;yDAEhC,+CAAuC;;yDAEvC,oDAA4C;;;;;iBAKpF;SACR,CAAC;IACN,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC","sourcesContent":["import type { Nullable } from \"../../types\";\nimport { GreasedLineMeshColorMode } from \"./greasedLineMaterialInterfaces\";\n\n/**\n * Returns GLSL custom shader code\n * @param shaderType vertex or fragment\n * @param cameraFacing is in camera facing mode?\n * @returns GLSL custom shader code\n */\n/** @internal */\nexport function GetCustomCode(shaderType: string, cameraFacing: boolean): Nullable<{ [pointName: string]: string }> {\n    if (shaderType === \"vertex\") {\n        const obj: any = {\n            CUSTOM_VERTEX_DEFINITIONS: `\n                attribute float grl_widths;\n                attribute vec3 grl_offsets;\n                attribute float grl_colorPointers;\n                varying float grlCounters;\n                varying float grlColorPointer;\n\n                #ifdef GREASED_LINE_CAMERA_FACING\n                    attribute vec4 grl_previousAndSide;\n                    attribute vec4 grl_nextAndCounters;\n\n                    vec2 grlFix( vec4 i, float aspect ) {\n                        vec2 res = i.xy / i.w;\n                        res.x *= aspect;\n                        return res;\n                    }\n                #else\n                    attribute vec3 grl_slopes;\n                    attribute float grl_counters;\n                #endif\n                `,\n            CUSTOM_VERTEX_UPDATE_POSITION: `\n                #ifdef GREASED_LINE_CAMERA_FACING\n                    vec3 grlPositionOffset = grl_offsets;\n                    positionUpdated += grlPositionOffset;\n                #else\n                    positionUpdated = (positionUpdated + grl_offsets) + (grl_slopes * grl_widths);\n                #endif\n                `,\n            CUSTOM_VERTEX_MAIN_END: `\n                grlColorPointer = grl_colorPointers;\n\n                #ifdef GREASED_LINE_CAMERA_FACING\n\n                    float grlAspect = grl_aspect_resolution_lineWidth.x;\n                    float grlBaseWidth = grl_aspect_resolution_lineWidth.w;\n\n                    vec3 grlPrevious = grl_previousAndSide.xyz;\n                    float grlSide = grl_previousAndSide.w;\n\n                    vec3 grlNext = grl_nextAndCounters.xyz;\n                    grlCounters = grl_nextAndCounters.w;\n\n                    mat4 grlMatrix = viewProjection * finalWorld;\n                    vec4 grlFinalPosition = grlMatrix * vec4(positionUpdated, 1.0);\n                    vec4 grlPrevPos = grlMatrix * vec4(grlPrevious + grlPositionOffset, 1.0);\n                    vec4 grlNextPos = grlMatrix * vec4(grlNext + grlPositionOffset, 1.0);\n\n                    vec2 grlCurrentP = grlFix(grlFinalPosition, grlAspect);\n                    vec2 grlPrevP = grlFix(grlPrevPos, grlAspect);\n                    vec2 grlNextP = grlFix(grlNextPos, grlAspect);\n\n                    float grlWidth = grlBaseWidth * grl_widths;\n\n                    vec2 grlDir;\n                    if (grlNextP == grlCurrentP) {\n                        grlDir = normalize(grlCurrentP - grlPrevP);\n                    } else if (grlPrevP == grlCurrentP) {\n                        grlDir = normalize(grlNextP - grlCurrentP);\n                    } else {\n                        vec2 grlDir1 = normalize(grlCurrentP - grlPrevP);\n                        vec2 grlDir2 = normalize(grlNextP - grlCurrentP);\n                        grlDir = normalize(grlDir1 + grlDir2);\n                    }\n                    vec4 grlNormal = vec4(-grlDir.y, grlDir.x, 0., 1.);\n\n                    #ifdef GREASED_LINE_RIGHT_HANDED_COORDINATE_SYSTEM\n                        grlNormal.xy *= -.5 * grlWidth;\n                    #else\n                        grlNormal.xy *= .5 * grlWidth;\n                    #endif\n\n                    grlNormal *= grl_projection;\n\n                    #ifdef GREASED_LINE_SIZE_ATTENUATION\n                        grlNormal.xy *= grlFinalPosition.w;\n                        grlNormal.xy /= (vec4(grl_aspect_resolution_lineWidth.yz, 0., 1.) * grl_projection).xy;\n                    #endif\n\n                    grlFinalPosition.xy += grlNormal.xy * grlSide;\n                    gl_Position = grlFinalPosition;\n\n                    vPositionW = vec3(grlFinalPosition);\n                #else\n                    grlCounters = grl_counters;\n                #endif\n                `,\n        };\n        cameraFacing && (obj[\"!gl_Position\\\\=viewProjection\\\\*worldPos;\"] = \"//\"); // not needed for camera facing GRL\n        return obj;\n    }\n\n    if (shaderType === \"fragment\") {\n        return {\n            CUSTOM_FRAGMENT_DEFINITIONS: `\n                    varying float grlCounters;\n                    varying float grlColorPointer;\n                    uniform sampler2D grl_colors;\n                `,\n            CUSTOM_FRAGMENT_MAIN_END: `\n                    float grlColorMode = grl_colorMode_visibility_colorsWidth_useColors.x;\n                    float grlVisibility = grl_colorMode_visibility_colorsWidth_useColors.y;\n                    float grlColorsWidth = grl_colorMode_visibility_colorsWidth_useColors.z;\n                    float grlUseColors = grl_colorMode_visibility_colorsWidth_useColors.w;\n\n                    float grlUseDash = grl_dashOptions.x;\n                    float grlDashArray = grl_dashOptions.y;\n                    float grlDashOffset = grl_dashOptions.z;\n                    float grlDashRatio = grl_dashOptions.w;\n\n                    gl_FragColor.a *= step(grlCounters, grlVisibility);\n                    if(gl_FragColor.a == 0.) discard;\n\n                    if(grlUseDash == 1.){\n                        gl_FragColor.a *= ceil(mod(grlCounters + grlDashOffset, grlDashArray) - (grlDashArray * grlDashRatio));\n                        if (gl_FragColor.a == 0.) discard;\n                    }\n\n                    #ifdef GREASED_LINE_HAS_COLOR\n                        if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_SET}.) {\n                            gl_FragColor.rgb = grl_singleColor;\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                            gl_FragColor.rgb += grl_singleColor;\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                            gl_FragColor.rgb *= grl_singleColor;\n                        }\n                    #else\n                        if (grlUseColors == 1.) {\n                            #ifdef GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE\n                                vec4 grlColor = texture2D(grl_colors, vec2(grlCounters, 0.), 0.);\n                            #else\n                                vec2 lookup = vec2(fract(grlColorPointer / grl_textureSize.x), 1.0 - floor(grlColorPointer / grl_textureSize.x) / max(grl_textureSize.y - 1.0, 1.0));\n                                vec4 grlColor = texture2D(grl_colors, lookup, 0.0);\n                            #endif\n                            if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_SET}.) {\n                                gl_FragColor = grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                                gl_FragColor += grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                                gl_FragColor *= grlColor;\n                            }\n                        }\n                    #endif\n                `,\n        };\n    }\n\n    return null;\n}\n"]}

package/Materials/GreasedLine/greasedLinePluginMaterialShadersWGSL.d.ts

@@ -0,0 +1,11 @@
+import type { Nullable } from "../../types";
+/**
+ * Returns WGSL custom shader code
+ * @param shaderType vertex or fragment
+ * @param cameraFacing is in camera facing mode?
+ * @returns WGSL custom shader code
+ */
+/** @internal */
+export declare function GetCustomCode(shaderType: string, cameraFacing: boolean): Nullable<{
+    [pointName: string]: string;
+}>;

package/Materials/GreasedLine/greasedLinePluginMaterialShadersWGSL.js

@@ -0,0 +1,177 @@
+/**
+ * Returns WGSL custom shader code
+ * @param shaderType vertex or fragment
+ * @param cameraFacing is in camera facing mode?
+ * @returns WGSL custom shader code
+ */
+/** @internal */
+export function GetCustomCode(shaderType, cameraFacing) {
+    if (shaderType === "vertex") {
+        const obj = {
+            CUSTOM_VERTEX_DEFINITIONS: `
+                attribute grl_widths: f32;
+                attribute grl_offsets: vec3f;
+                attribute grl_colorPointers: f32;
+                varying grlCounters: f32;
+                varying grlColorPointer: f32;
+
+                #ifdef GREASED_LINE_CAMERA_FACING
+                    attribute grl_previousAndSide : vec4f;
+                    attribute grl_nextAndCounters : vec4f;
+
+                    fn grlFix(i: vec4f, aspect: f32) -> vec2f {
+                        var res = i.xy / i.w;
+                        res.x *= aspect;
+                        return res;
+                    }
+                #else
+                    attribute grl_slopes: f32;
+                    attribute grl_counters: f32;
+                #endif
+
+
+                `,
+            CUSTOM_VERTEX_UPDATE_POSITION: `
+                #ifdef GREASED_LINE_CAMERA_FACING
+                    var grlPositionOffset: vec3f = input.grl_offsets;
+                    positionUpdated += grlPositionOffset;
+                #else
+                    positionUpdated = (positionUpdated + input.grl_offsets) + (input.grl_slopes * input.grl_widths);
+                #endif
+                `,
+            CUSTOM_VERTEX_MAIN_END: `
+                vertexOutputs.grlColorPointer = input.grl_colorPointers;
+
+                #ifdef GREASED_LINE_CAMERA_FACING
+
+                    let grlAspect: f32 = uniforms.grl_aspect_resolution_lineWidth.x;
+                    let grlBaseWidth: f32 = uniforms.grl_aspect_resolution_lineWidth.w;
+
+                    let grlPrevious: vec3f = input.grl_previousAndSide.xyz;
+                    let grlSide: f32 = input.grl_previousAndSide.w;
+
+                    let grlNext: vec3f = input.grl_nextAndCounters.xyz;
+                    vertexOutputs.grlCounters = input.grl_nextAndCounters.w;
+
+                    let grlMatrix: mat4x4f = uniforms.viewProjection * finalWorld;
+                    var grlFinalPosition: vec4f = grlMatrix * vec4f(positionUpdated, 1.0);
+                    let grlPrevPos: vec4f = grlMatrix * vec4f(grlPrevious + grlPositionOffset, 1.0);
+                    let grlNextPos: vec4f = grlMatrix * vec4f(grlNext + grlPositionOffset, 1.0);
+
+                    let grlCurrentP: vec2f = grlFix(grlFinalPosition, grlAspect);
+                    let grlPrevP: vec2f = grlFix(grlPrevPos, grlAspect);
+                    let grlNextP: vec2f = grlFix(grlNextPos, grlAspect);
+
+                    let grlWidth: f32 = grlBaseWidth * input.grl_widths;
+
+                    var grlDir: vec2f;
+                    if (all(grlNextP == grlCurrentP)) {
+                        grlDir = normalize(grlCurrentP - grlPrevP);
+                    } else if (all(grlPrevP == grlCurrentP)) {
+                        grlDir = normalize(grlNextP - grlCurrentP);
+                    } else {
+                        let grlDir1: vec2f = normalize(grlCurrentP - grlPrevP);
+                        let grlDir2: vec2f = normalize(grlNextP - grlCurrentP);
+                        grlDir = normalize(grlDir1 + grlDir2);
+                    }
+
+                    var grlNormal: vec4f = vec4f(-grlDir.y, grlDir.x, 0.0, 1.0);
+
+                    let grlHalfWidth: f32 = 0.5 * grlWidth;
+                    #if defined(GREASED_LINE_RIGHT_HANDED_COORDINATE_SYSTEM)
+                        grlNormal.x *= -grlHalfWidth;
+                        grlNormal.y *= -grlHalfWidth;
+                    #else
+                        grlNormal.x *= grlHalfWidth;
+                        grlNormal.y *= grlHalfWidth;
+                    #endif
+
+                    grlNormal *= uniforms.grl_projection;
+
+                    #if defined(GREASED_LINE_SIZE_ATTENUATION)
+                        grlNormal.x *= grlFinalPosition.w;
+                        grlNormal.y *= grlFinalPosition.w;
+
+                        let pr: f32 = vec4f(uniforms.grl_aspect_resolution_lineWidth.yz, 0.0, 1.0) * uniforms.grl_projection;
+                        grlNormal.x /= pr.x;
+                        grlNormal.y /= pr.y;
+                    #endif
+
+                    vertexOutputs.position = vec4f(grlFinalPosition.xy + grlNormal.xy * grlSide, grlFinalPosition.z, grlFinalPosition.w);
+                    vertexOutputs.vPositionW = vertexOutputs.position.xyz;
+                
+                #else
+                    vertexOutputs.grlCounters = input.grl_counters;
+                #endif
+                `,
+        };
+        cameraFacing && (obj["!vertexOutputs\\.position\\s=\\sscene\\.viewProjection\\s\\*\\sworldPos;"] = "//"); // not needed for camera facing GRL
+        return obj;
+    }
+    if (shaderType === "fragment") {
+        return {
+            CUSTOM_FRAGMENT_DEFINITIONS: `
+                    varying grlCounters: f32;
+                    varying grlColorPointer: 32;
+
+                    var grl_colors: texture_2d<f32>;
+                    var grl_colorsSampler: sampler;
+                `,
+            CUSTOM_FRAGMENT_MAIN_END: `
+                    let grlColorMode: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.x;
+                    let grlVisibility: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.y;
+                    let grlColorsWidth: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.z;
+                    let grlUseColors: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.w;
+
+                    let grlUseDash: f32 = uniforms.grl_dashOptions.x;
+                    let grlDashArray: f32 = uniforms.grl_dashOptions.y;
+                    let grlDashOffset: f32 = uniforms.grl_dashOptions.z;
+                    let grlDashRatio: f32 = uniforms.grl_dashOptions.w;
+
+                    fragmentOutputs.color.a *= step(fragmentInputs.grlCounters, grlVisibility);
+                    if (fragmentOutputs.color.a == 0.0) {
+                        discard;
+                    }
+
+                    if (grlUseDash == 1.0) {
+                        let dashPosition = (fragmentInputs.grlCounters + grlDashOffset) % grlDashArray;
+                        fragmentOutputs.color.a *= ceil(dashPosition - (grlDashArray * grlDashRatio));
+
+                        if (fragmentOutputs.color.a == 0.0) {
+                            discard;
+                        }
+                    }
+
+                    #ifdef GREASED_LINE_HAS_COLOR
+                        if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
+                            fragmentOutputs.color = vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);
+                        } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
+                            fragmentOutputs.color += vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);
+                        } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
+                            fragmentOutputs.color *= vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);
+                        }
+                    #else
+                        if (grlUseColors == 1.) {
+                            #ifdef GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE
+                                let grlColor: vec4f = textureSample(grl_colors, grl_colorsSampler, vec2f(fragmentInputs.grlCounters, 0.));
+                            #else
+                                let lookup: vec2f = vec2(fract(fragmentInputs.grlColorPointer / uniforms.grl_textureSize.x), 1.0 - floor(fragmentInputs.grlColorPointer / uniforms.grl_textureSize.x) / max(uniforms.grl_textureSize.y - 1.0, 1.0));
+                                let grlColor: vec4f = textureSample(grl_colors, grl_colorsSampler, lookup);
+                            #endif
+                            if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
+                                fragmentOutputs.color = grlColor;
+                            } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
+                                fragmentOutputs.color += grlColor;
+                            } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
+                                fragmentOutputs.color *= grlColor;
+                            }
+                        }
+                    #endif
+
+
+                `,
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=greasedLinePluginMaterialShadersWGSL.js.map

package/Materials/GreasedLine/greasedLinePluginMaterialShadersWGSL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greasedLinePluginMaterialShadersWGSL.js","sourceRoot":"","sources":["../../../../../dev/core/src/Materials/GreasedLine/greasedLinePluginMaterialShadersWGSL.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gBAAgB;AAChB,MAAM,UAAU,aAAa,CAAC,UAAkB,EAAE,YAAqB;IACnE,IAAI,UAAU,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAQ;YACb,yBAAyB,EAAE;;;;;;;;;;;;;;;;;;;;;;iBAsBtB;YACL,6BAA6B,EAAE;;;;;;;iBAO1B;YACL,sBAAsB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgEnB;SACR,CAAC;QAEF,YAAY,IAAI,CAAC,GAAG,CAAC,0EAA0E,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,mCAAmC;QAC7I,OAAO,GAAG,CAAC;IACf,CAAC;IAED,IAAI,UAAU,KAAK,UAAU,EAAE,CAAC;QAC5B,OAAO;YACH,2BAA2B,EAAE;;;;;;iBAMxB;YACL,wBAAwB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;8CA0BQ,+CAAuC;;qDAEhC,+CAAuC;;qDAEvC,oDAA4C;;;;;;;;;;;kDAW/C,+CAAuC;;yDAEhC,+CAAuC;;yDAEvC,oDAA4C;;;;;;;iBAOpF;SACR,CAAC;IACN,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC","sourcesContent":["import type { Nullable } from \"../../types\";\nimport { GreasedLineMeshColorMode } from \"./greasedLineMaterialInterfaces\";\n\n/**\n * Returns WGSL custom shader code\n * @param shaderType vertex or fragment\n * @param cameraFacing is in camera facing mode?\n * @returns WGSL custom shader code\n */\n/** @internal */\nexport function GetCustomCode(shaderType: string, cameraFacing: boolean): Nullable<{ [pointName: string]: string }> {\n    if (shaderType === \"vertex\") {\n        const obj: any = {\n            CUSTOM_VERTEX_DEFINITIONS: `\n                attribute grl_widths: f32;\n                attribute grl_offsets: vec3f;\n                attribute grl_colorPointers: f32;\n                varying grlCounters: f32;\n                varying grlColorPointer: f32;\n\n                #ifdef GREASED_LINE_CAMERA_FACING\n                    attribute grl_previousAndSide : vec4f;\n                    attribute grl_nextAndCounters : vec4f;\n\n                    fn grlFix(i: vec4f, aspect: f32) -> vec2f {\n                        var res = i.xy / i.w;\n                        res.x *= aspect;\n                        return res;\n                    }\n                #else\n                    attribute grl_slopes: f32;\n                    attribute grl_counters: f32;\n                #endif\n\n\n                `,\n            CUSTOM_VERTEX_UPDATE_POSITION: `\n                #ifdef GREASED_LINE_CAMERA_FACING\n                    var grlPositionOffset: vec3f = input.grl_offsets;\n                    positionUpdated += grlPositionOffset;\n                #else\n                    positionUpdated = (positionUpdated + input.grl_offsets) + (input.grl_slopes * input.grl_widths);\n                #endif\n                `,\n            CUSTOM_VERTEX_MAIN_END: `\n                vertexOutputs.grlColorPointer = input.grl_colorPointers;\n\n                #ifdef GREASED_LINE_CAMERA_FACING\n\n                    let grlAspect: f32 = uniforms.grl_aspect_resolution_lineWidth.x;\n                    let grlBaseWidth: f32 = uniforms.grl_aspect_resolution_lineWidth.w;\n\n                    let grlPrevious: vec3f = input.grl_previousAndSide.xyz;\n                    let grlSide: f32 = input.grl_previousAndSide.w;\n\n                    let grlNext: vec3f = input.grl_nextAndCounters.xyz;\n                    vertexOutputs.grlCounters = input.grl_nextAndCounters.w;\n\n                    let grlMatrix: mat4x4f = uniforms.viewProjection * finalWorld;\n                    var grlFinalPosition: vec4f = grlMatrix * vec4f(positionUpdated, 1.0);\n                    let grlPrevPos: vec4f = grlMatrix * vec4f(grlPrevious + grlPositionOffset, 1.0);\n                    let grlNextPos: vec4f = grlMatrix * vec4f(grlNext + grlPositionOffset, 1.0);\n\n                    let grlCurrentP: vec2f = grlFix(grlFinalPosition, grlAspect);\n                    let grlPrevP: vec2f = grlFix(grlPrevPos, grlAspect);\n                    let grlNextP: vec2f = grlFix(grlNextPos, grlAspect);\n\n                    let grlWidth: f32 = grlBaseWidth * input.grl_widths;\n\n                    var grlDir: vec2f;\n                    if (all(grlNextP == grlCurrentP)) {\n                        grlDir = normalize(grlCurrentP - grlPrevP);\n                    } else if (all(grlPrevP == grlCurrentP)) {\n                        grlDir = normalize(grlNextP - grlCurrentP);\n                    } else {\n                        let grlDir1: vec2f = normalize(grlCurrentP - grlPrevP);\n                        let grlDir2: vec2f = normalize(grlNextP - grlCurrentP);\n                        grlDir = normalize(grlDir1 + grlDir2);\n                    }\n\n                    var grlNormal: vec4f = vec4f(-grlDir.y, grlDir.x, 0.0, 1.0);\n\n                    let grlHalfWidth: f32 = 0.5 * grlWidth;\n                    #if defined(GREASED_LINE_RIGHT_HANDED_COORDINATE_SYSTEM)\n                        grlNormal.x *= -grlHalfWidth;\n                        grlNormal.y *= -grlHalfWidth;\n                    #else\n                        grlNormal.x *= grlHalfWidth;\n                        grlNormal.y *= grlHalfWidth;\n                    #endif\n\n                    grlNormal *= uniforms.grl_projection;\n\n                    #if defined(GREASED_LINE_SIZE_ATTENUATION)\n                        grlNormal.x *= grlFinalPosition.w;\n                        grlNormal.y *= grlFinalPosition.w;\n\n                        let pr: f32 = vec4f(uniforms.grl_aspect_resolution_lineWidth.yz, 0.0, 1.0) * uniforms.grl_projection;\n                        grlNormal.x /= pr.x;\n                        grlNormal.y /= pr.y;\n                    #endif\n\n                    vertexOutputs.position = vec4f(grlFinalPosition.xy + grlNormal.xy * grlSide, grlFinalPosition.z, grlFinalPosition.w);\n                    vertexOutputs.vPositionW = vertexOutputs.position.xyz;\n                \n                #else\n                    vertexOutputs.grlCounters = input.grl_counters;\n                #endif\n                `,\n        };\n\n        cameraFacing && (obj[\"!vertexOutputs\\\\.position\\\\s=\\\\sscene\\\\.viewProjection\\\\s\\\\*\\\\sworldPos;\"] = \"//\"); // not needed for camera facing GRL\n        return obj;\n    }\n\n    if (shaderType === \"fragment\") {\n        return {\n            CUSTOM_FRAGMENT_DEFINITIONS: `\n                    varying grlCounters: f32;\n                    varying grlColorPointer: 32;\n\n                    var grl_colors: texture_2d<f32>;\n                    var grl_colorsSampler: sampler;\n                `,\n            CUSTOM_FRAGMENT_MAIN_END: `\n                    let grlColorMode: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.x;\n                    let grlVisibility: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.y;\n                    let grlColorsWidth: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.z;\n                    let grlUseColors: f32 = uniforms.grl_colorMode_visibility_colorsWidth_useColors.w;\n\n                    let grlUseDash: f32 = uniforms.grl_dashOptions.x;\n                    let grlDashArray: f32 = uniforms.grl_dashOptions.y;\n                    let grlDashOffset: f32 = uniforms.grl_dashOptions.z;\n                    let grlDashRatio: f32 = uniforms.grl_dashOptions.w;\n\n                    fragmentOutputs.color.a *= step(fragmentInputs.grlCounters, grlVisibility);\n                    if (fragmentOutputs.color.a == 0.0) {\n                        discard;\n                    }\n\n                    if (grlUseDash == 1.0) {\n                        let dashPosition = (fragmentInputs.grlCounters + grlDashOffset) % grlDashArray;\n                        fragmentOutputs.color.a *= ceil(dashPosition - (grlDashArray * grlDashRatio));\n\n                        if (fragmentOutputs.color.a == 0.0) {\n                            discard;\n                        }\n                    }\n\n                    #ifdef GREASED_LINE_HAS_COLOR\n                        if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_SET}.) {\n                            fragmentOutputs.color = vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                            fragmentOutputs.color += vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                            fragmentOutputs.color *= vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);\n                        }\n                    #else\n                        if (grlUseColors == 1.) {\n                            #ifdef GREASED_LINE_COLOR_DISTRIBUTION_TYPE_LINE\n                                let grlColor: vec4f = textureSample(grl_colors, grl_colorsSampler, vec2f(fragmentInputs.grlCounters, 0.));\n                            #else\n                                let lookup: vec2f = vec2(fract(fragmentInputs.grlColorPointer / uniforms.grl_textureSize.x), 1.0 - floor(fragmentInputs.grlColorPointer / uniforms.grl_textureSize.x) / max(uniforms.grl_textureSize.y - 1.0, 1.0));\n                                let grlColor: vec4f = textureSample(grl_colors, grl_colorsSampler, lookup);\n                            #endif\n                            if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_SET}.) {\n                                fragmentOutputs.color = grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                                fragmentOutputs.color += grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                                fragmentOutputs.color *= grlColor;\n                            }\n                        }\n                    #endif\n\n\n                `,\n        };\n    }\n\n    return null;\n}\n"]}

package/Materials/GreasedLine/greasedLineSimpleMaterial.d.ts

@@ -4,14 +4,16 @@ import { ShaderMaterial } from "../shaderMaterial";
 import type { Nullable } from "../../types";
 import { Color3 } from "../../Maths/math.color";
 import { Vector2 } from "../../Maths/math.vector";
-import "../../Shaders/greasedLine.fragment";
-import "../../Shaders/greasedLine.vertex";
 import type { GreasedLineMaterialOptions, IGreasedLineMaterial } from "./greasedLineMaterialInterfaces";
 import { GreasedLineMeshColorDistributionType, GreasedLineMeshColorMode } from "./greasedLineMaterialInterfaces";
 /**
  * GreasedLineSimpleMaterial
  */
 export declare class GreasedLineSimpleMaterial extends ShaderMaterial implements IGreasedLineMaterial {
+    /**
+     * Force to use GLSL in WebGPU
+     */
+    static ForceGLSL: boolean;
     private _visibility;
     private _width;
     private _useDash;

package/Materials/GreasedLine/greasedLineSimpleMaterial.js

@@ -2,8 +2,7 @@ import { RawTexture } from "../Textures/rawTexture.js";
 import { ShaderMaterial } from "../shaderMaterial.js";
 import { Color3 } from "../../Maths/math.color.js";
 import { Vector2 } from "../../Maths/math.vector.js";
-import "../../Shaders/greasedLine.fragment.js";
-import "../../Shaders/greasedLine.vertex.js";
+import { TextureSampler } from "../Textures/textureSampler.js";
 import { GreasedLineTools } from "../../Misc/greasedLineTools.js";
 import { GreasedLineMaterialDefaults } from "./greasedLineMaterialDefaults.js";
 /**
@@ -17,6 +16,8 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
      * @param options material options
      */
     constructor(name, scene, options) {
+        const engine = scene.getEngine();
+        const isWGSL = engine.isWebGPU && !(options.forceGLSL || GreasedLineSimpleMaterial.ForceGLSL);
         const defines = [
             `COLOR_DISTRIBUTION_TYPE_LINE ${1 /* GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_LINE */}.`,
             `COLOR_DISTRIBUTION_TYPE_SEGMENT ${0 /* GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_SEGMENT */}.`,
@@ -24,8 +25,8 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
             `COLOR_MODE_ADD ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.`,
             `COLOR_MODE_MULTIPLY ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.`,
         ];
-        const attributes = ["position", "grl_widths", "grl_offsets", "grl_colorPointers"];
         scene.useRightHandedSystem && defines.push("GREASED_LINE_RIGHT_HANDED_COORDINATE_SYSTEM");
+        const attributes = ["position", "grl_widths", "grl_offsets", "grl_colorPointers"];
         if (options.cameraFacing) {
             defines.push("GREASED_LINE_CAMERA_FACING");
             attributes.push("grl_previousAndSide", "grl_nextAndCounters");
@@ -34,32 +35,43 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
             attributes.push("grl_slopes");
             attributes.push("grl_counters");
         }
+        const uniforms = [
+            "grlColorsWidth",
+            "grlUseColors",
+            "grlWidth",
+            "grlColor",
+            "grl_colorModeAndColorDistributionType",
+            "grlResolution",
+            "grlAspect",
+            "grlAizeAttenuation",
+            "grlDashArray",
+            "grlDashOffset",
+            "grlDashRatio",
+            "grlUseDash",
+            "grlVisibility",
+            "grlColors",
+        ];
+        if (!isWGSL) {
+            uniforms.push("world", "viewProjection", "view", "projection");
+        }
         super(name, scene, {
             vertex: "greasedLine",
             fragment: "greasedLine",
         }, {
+            uniformBuffers: isWGSL ? ["Scene", "Mesh"] : undefined,
             attributes,
-            uniforms: [
-                "world",
-                "viewProjection",
-                "view",
-                "projection",
-                "grlColorsWidth",
-                "grlUseColors",
-                "grlWidth",
-                "grlColor",
-                "grl_colorModeAndColorDistributionType",
-                "grlResolution",
-                "grlAspect",
-                "grlAizeAttenuation",
-                "grlDashArray",
-                "grlDashOffset",
-                "grlDashRatio",
-                "grlUseDash",
-                "grlVisibility",
-            ],
-            samplers: ["grlColors"],
+            uniforms,
+            samplers: isWGSL ? [] : ["grlColors"],
             defines,
+            extraInitializationsAsync: async () => {
+                if (isWGSL) {
+                    await Promise.all([import("../../ShadersWGSL/greasedLine.vertex.js"), import("../../ShadersWGSL/greasedLine.fragment.js")]);
+                }
+                else {
+                    await Promise.all([import("../../Shaders/greasedLine.vertex.js"), import("../../Shaders/greasedLine.fragment.js")]);
+                }
+            },
+            shaderLanguage: isWGSL ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */,
         });
         this._color = Color3.White();
         this._colorsDistributionType = 0 /* GreasedLineMeshColorDistributionType.COLOR_DISTRIBUTION_TYPE_SEGMENT */;
@@ -67,7 +79,6 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
         options = options || {
             color: GreasedLineMaterialDefaults.DEFAULT_COLOR,
         };
-        const engine = scene.getEngine();
         this.visibility = options.visibility ?? 1;
         this.useDash = options.useDash ?? false;
         this.dashRatio = options.dashRatio ?? 0.5;
@@ -98,6 +109,12 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
                 this.colorsTexture = GreasedLineTools.CreateColorsTexture(`${this.name}-colors-texture`, this._colors, this.colorsSampling, scene);
             }
         }
+        if (isWGSL) {
+            const sampler = new TextureSampler();
+            sampler.setParameters(); // use the default values
+            sampler.samplingMode = this.colorsSampling;
+            this.setTextureSampler("grlColorsSampler", sampler);
+        }
         engine.onDisposeObservable.add(() => {
             GreasedLineTools.DisposeEmptyColorsTexture();
         });
@@ -389,7 +406,6 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
      * @param _rootUrl root url for textures
      */
     parse(source, scene, _rootUrl) {
-        // TODO: super.parse?
         const greasedLineMaterialOptions = source.greasedLineMaterialOptions;
         this._colorsTexture?.dispose();
         greasedLineMaterialOptions.color && (this.color = greasedLineMaterialOptions.color);
@@ -415,4 +431,8 @@ export class GreasedLineSimpleMaterial extends ShaderMaterial {
         this.setDefine("GREASED_LINE_CAMERA_FACING", this._cameraFacing);
     }
 }
+/**
+ * Force to use GLSL in WebGPU
+ */
+GreasedLineSimpleMaterial.ForceGLSL = false;
 //# sourceMappingURL=greasedLineSimpleMaterial.js.map