@babylonjs/core 7.41.1 → 7.43.0

package/Materials/GreasedLine/greasedLinePluginMaterialShadersGLSL.js

@@ -102,11 +102,17 @@ export function GetCustomCode(shaderType, cameraFacing) {
     if (shaderType === "fragment") {
         return {
             CUSTOM_FRAGMENT_DEFINITIONS: `
+                    #ifdef PBR
+                         #define grlFinalColor finalColor
+                    #else
+                         #define grlFinalColor color
+                    #endif
+
                     varying float grlCounters;
                     varying float grlColorPointer;
                     uniform sampler2D grl_colors;
                 `,
-            CUSTOM_FRAGMENT_MAIN_END: `
+            CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `
                     float grlColorMode = grl_colorMode_visibility_colorsWidth_useColors.x;
                     float grlVisibility = grl_colorMode_visibility_colorsWidth_useColors.y;
                     float grlColorsWidth = grl_colorMode_visibility_colorsWidth_useColors.z;
@@ -117,21 +123,21 @@ export function GetCustomCode(shaderType, cameraFacing) {
                     float grlDashOffset = grl_dashOptions.z;
                     float grlDashRatio = grl_dashOptions.w;
 
-                    gl_FragColor.a *= step(grlCounters, grlVisibility);
-                    if(gl_FragColor.a == 0.) discard;
+                    grlFinalColor.a *= step(grlCounters, grlVisibility);
+                    if(grlFinalColor.a == 0.) discard;
 
                     if(grlUseDash == 1.){
-                        gl_FragColor.a *= ceil(mod(grlCounters + grlDashOffset, grlDashArray) - (grlDashArray * grlDashRatio));
-                        if (gl_FragColor.a == 0.) discard;
+                        grlFinalColor.a *= ceil(mod(grlCounters + grlDashOffset, grlDashArray) - (grlDashArray * grlDashRatio));
+                        if (grlFinalColor.a == 0.) discard;
                     }
 
                     #ifdef GREASED_LINE_HAS_COLOR
                         if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
-                            gl_FragColor.rgb = grl_singleColor;
+                            grlFinalColor.rgb = grl_singleColor;
                         } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
-                            gl_FragColor.rgb += grl_singleColor;
+                            grlFinalColor.rgb += grl_singleColor;
                         } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
-                            gl_FragColor.rgb *= grl_singleColor;
+                            grlFinalColor.rgb *= grl_singleColor;
                         }
                     #else
                         if (grlUseColors == 1.) {
@@ -142,11 +148,11 @@ export function GetCustomCode(shaderType, cameraFacing) {
                                 vec4 grlColor = texture2D(grl_colors, lookup, 0.0);
                             #endif
                             if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
-                                gl_FragColor = grlColor;
+                                grlFinalColor = grlColor;
                             } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
-                                gl_FragColor += grlColor;
+                                grlFinalColor += grlColor;
                             } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
-                                gl_FragColor *= grlColor;
+                                grlFinalColor *= grlColor;
                             }
                         }
                     #endif

package/Materials/GreasedLine/greasedLinePluginMaterialShadersGLSL.js.map

@@ -1 +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"]}
+{"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;;;;;;;;;;iBAUxB;YACL,gCAAgC,EAAE;;;;;;;;;;;;;;;;;;;;8CAoBA,+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                    #ifdef PBR\n                         #define grlFinalColor finalColor\n                    #else\n                         #define grlFinalColor color\n                    #endif\n\n                    varying float grlCounters;\n                    varying float grlColorPointer;\n                    uniform sampler2D grl_colors;\n                `,\n            CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `\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                    grlFinalColor.a *= step(grlCounters, grlVisibility);\n                    if(grlFinalColor.a == 0.) discard;\n\n                    if(grlUseDash == 1.){\n                        grlFinalColor.a *= ceil(mod(grlCounters + grlDashOffset, grlDashArray) - (grlDashArray * grlDashRatio));\n                        if (grlFinalColor.a == 0.) discard;\n                    }\n\n                    #ifdef GREASED_LINE_HAS_COLOR\n                        if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_SET}.) {\n                            grlFinalColor.rgb = grl_singleColor;\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                            grlFinalColor.rgb += grl_singleColor;\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                            grlFinalColor.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                                grlFinalColor = grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                                grlFinalColor += grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                                grlFinalColor *= grlColor;\n                            }\n                        }\n                    #endif\n                `,\n        };\n    }\n\n    return null;\n}\n"]}

package/Materials/GreasedLine/greasedLinePluginMaterialShadersWGSL.js

@@ -92,7 +92,7 @@ export function GetCustomCode(shaderType, cameraFacing) {
                         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;
+                        let pr = vec4f(uniforms.grl_aspect_resolution_lineWidth.yz, 0.0, 1.0) * uniforms.grl_projection;
                         grlNormal.x /= pr.x;
                         grlNormal.y /= pr.y;
                     #endif
@@ -111,13 +111,19 @@ export function GetCustomCode(shaderType, cameraFacing) {
     if (shaderType === "fragment") {
         return {
             CUSTOM_FRAGMENT_DEFINITIONS: `
+                    #ifdef PBR
+                         #define grlFinalColor finalColor
+                    #else
+                         #define grlFinalColor color
+                    #endif
+
                     varying grlCounters: f32;
                     varying grlColorPointer: 32;
 
                     var grl_colors: texture_2d<f32>;
                     var grl_colorsSampler: sampler;
                 `,
-            CUSTOM_FRAGMENT_MAIN_END: `
+            CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `
                     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;
@@ -128,27 +134,27 @@ export function GetCustomCode(shaderType, cameraFacing) {
                     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) {
+                    grlFinalColor.a *= step(fragmentInputs.grlCounters, grlVisibility);
+                    if (grlFinalColor.a == 0.0) {
                         discard;
                     }
 
                     if (grlUseDash == 1.0) {
                         let dashPosition = (fragmentInputs.grlCounters + grlDashOffset) % grlDashArray;
-                        fragmentOutputs.color.a *= ceil(dashPosition - (grlDashArray * grlDashRatio));
+                        grlFinalColor.a *= ceil(dashPosition - (grlDashArray * grlDashRatio));
 
-                        if (fragmentOutputs.color.a == 0.0) {
+                        if (grlFinalColor.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);
+                            grlFinalColor = vec4f(uniforms.grl_singleColor, grlFinalColor.a);
                         } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
-                            fragmentOutputs.color += vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);
+                            grlFinalColor += vec4f(uniforms.grl_singleColor, grlFinalColor.a);
                         } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
-                            fragmentOutputs.color *= vec4f(uniforms.grl_singleColor, fragmentOutputs.color.a);
+                            grlFinalColor *= vec4f(uniforms.grl_singleColor, grlFinalColor.a);
                         }
                     #else
                         if (grlUseColors == 1.) {
@@ -159,11 +165,11 @@ export function GetCustomCode(shaderType, cameraFacing) {
                                 let grlColor: vec4f = textureSample(grl_colors, grl_colorsSampler, lookup);
                             #endif
                             if (grlColorMode == ${0 /* GreasedLineMeshColorMode.COLOR_MODE_SET */}.) {
-                                fragmentOutputs.color = grlColor;
+                                grlFinalColor = grlColor;
                             } else if (grlColorMode == ${1 /* GreasedLineMeshColorMode.COLOR_MODE_ADD */}.) {
-                                fragmentOutputs.color += grlColor;
+                                grlFinalColor += grlColor;
                             } else if (grlColorMode == ${2 /* GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY */}.) {
-                                fragmentOutputs.color *= grlColor;
+                                grlFinalColor *= grlColor;
                             }
                         }
                     #endif

package/Materials/GreasedLine/greasedLinePluginMaterialShadersWGSL.js.map

@@ -1 +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"]}
+{"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;;;;;;;;;;;;iBAYxB;YACL,gCAAgC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;8CA0BA,+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 = 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                    #ifdef PBR\n                         #define grlFinalColor finalColor\n                    #else\n                         #define grlFinalColor color\n                    #endif\n\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_BEFORE_FRAGCOLOR: `\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                    grlFinalColor.a *= step(fragmentInputs.grlCounters, grlVisibility);\n                    if (grlFinalColor.a == 0.0) {\n                        discard;\n                    }\n\n                    if (grlUseDash == 1.0) {\n                        let dashPosition = (fragmentInputs.grlCounters + grlDashOffset) % grlDashArray;\n                        grlFinalColor.a *= ceil(dashPosition - (grlDashArray * grlDashRatio));\n\n                        if (grlFinalColor.a == 0.0) {\n                            discard;\n                        }\n                    }\n\n                    #ifdef GREASED_LINE_HAS_COLOR\n                        if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_SET}.) {\n                            grlFinalColor = vec4f(uniforms.grl_singleColor, grlFinalColor.a);\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                            grlFinalColor += vec4f(uniforms.grl_singleColor, grlFinalColor.a);\n                        } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                            grlFinalColor *= vec4f(uniforms.grl_singleColor, grlFinalColor.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                                grlFinalColor = grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_ADD}.) {\n                                grlFinalColor += grlColor;\n                            } else if (grlColorMode == ${GreasedLineMeshColorMode.COLOR_MODE_MULTIPLY}.) {\n                                grlFinalColor *= grlColor;\n                            }\n                        }\n                    #endif\n\n\n                `,\n        };\n    }\n\n    return null;\n}\n"]}

package/Materials/Node/Blocks/Input/inputBlock.js

@@ -25,6 +25,18 @@ const attributeInFragmentOnly = {
 const attributeAsUniform = {
     particle_texturemask: true,
 };
+const attributeDefine = {
+    normal: "NORMAL",
+    tangent: "TANGENT",
+    uv: "UV1",
+    uv2: "UV2",
+    uv3: "UV3",
+    uv4: "UV4",
+    uv5: "UV5",
+    uv6: "UV6",
+    uv7: "UV7",
+    uv8: "UV8",
+};
 /**
  * Block used to expose an input value
  */
@@ -530,13 +542,33 @@ export class InputBlock extends NodeMaterialBlock {
                 }
                 if (state.shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
                     if (!alreadyDeclared) {
-                        state._attributeDeclaration += `attribute ${this.declarationVariableName}: ${state._getShaderType(this.type)};\n`;
+                        const defineName = attributeDefine[this.name];
+                        if (defineName) {
+                            state._attributeDeclaration += `#ifdef ${defineName}\n`;
+                            state._attributeDeclaration += `attribute ${this.declarationVariableName}: ${state._getShaderType(this.type)};\n`;
+                            state._attributeDeclaration += `#else\n`;
+                            state._attributeDeclaration += `let ${this.declarationVariableName}: ${state._getShaderType(this.type)} = ${state._getShaderType(this.type)}(0.);\n`;
+                            state._attributeDeclaration += `#endif\n`;
+                        }
+                        else {
+                            state._attributeDeclaration += `attribute ${this.declarationVariableName}: ${state._getShaderType(this.type)};\n`;
+                        }
                     }
                     this._prefix = `vertexInputs.`;
                 }
                 else {
                     if (!alreadyDeclared) {
-                        state._attributeDeclaration += `attribute ${state._getShaderType(this.type)} ${this.declarationVariableName};\n`;
+                        const defineName = attributeDefine[this.name];
+                        if (defineName) {
+                            state._attributeDeclaration += `#ifdef ${defineName}\n`;
+                            state._attributeDeclaration += `attribute ${state._getShaderType(this.type)} ${this.declarationVariableName};\n`;
+                            state._attributeDeclaration += `#else\n`;
+                            state._attributeDeclaration += `${state._getShaderType(this.type)} ${this.declarationVariableName} = ${state._getShaderType(this.type)}(0.);\n`;
+                            state._attributeDeclaration += `#endif\n`;
+                        }
+                        else {
+                            state._attributeDeclaration += `attribute ${state._getShaderType(this.type)} ${this.declarationVariableName};\n`;
+                        }
                     }
                 }
                 if (define && !alreadyDeclared) {