Import All Shaders

src/Layers/effectLayer.ts

@@ -24,6 +24,9 @@ import { Material } from "Materials/material";
 import { MaterialHelper } from "Materials/materialHelper";
 import { Constants } from "Engines/constants";
 
+import "./glowMapGeneration.fragment";
+import "./glowMapGeneration.vertex";
+
     /**
      * Effect layer options. This helps customizing the behaviour
      * of the effect layer.

src/Layers/glowLayer.ts

@@ -18,6 +18,9 @@ import { EffectLayer } from "./effectLayer";
 import { AbstractScene } from "abstractScene";
 import { Constants } from "Engines/constants";
 
+import "./glowMapMerge.fragment";
+import "./glowMapMerge.vertex";
+
 declare module "abstractScene" {
     export interface AbstractScene {
         /**

src/Layers/highlightLayer.ts

@@ -24,6 +24,10 @@ import { AbstractScene } from "abstractScene";
 import { Constants } from "Engines/constants";
 import { Logger } from "Misc/logger";
 
+import "Shaders/glowMapMerge.fragment";
+import "Shaders/glowMapMerge.vertex";
+import "Shaders/glowBlurPostProcess.fragment";
+
 declare module "abstractScene" {
     export interface AbstractScene {
         /**

src/Layers/layer.ts

@@ -14,6 +14,9 @@ import { LayerSceneComponent } from "./layerSceneComponent";
 import { Constants } from "Engines/constants";
 import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
 
+import "./layer.fragment";
+import "./layer.vertex";
+
     /**
      * This represents a full screen 2d layer.
      * This can be usefull to display a picture in the  background of your scene for instance.

src/LensFlares/lensFlareSystem.ts

@@ -16,6 +16,9 @@ import { LensFlare } from "./lensFlare";
 import { LensFlareSystemSceneComponent } from "./lensFlareSystemSceneComponent";
 import { Constants } from "Engines/constants";
 
+import "./lensFlare.fragment";
+import "./lensFlare.vertex";
+
     /**
      * This represents a Lens Flare System or the shiny effect created by the light reflection on the  camera lenses.
      * It is usually composed of several `lensFlare`.

src/Lights/Shadows/shadowGenerator.ts

@@ -24,6 +24,11 @@ import { SceneComponentConstants } from "sceneComponent";
 import { _TimeToken } from "Instrumentation/timeToken";
 import { _DepthCullingState, _StencilState, _AlphaState } from "States";
 import { Constants } from "Engines/constants";
+
+import "./shadowMap.fragment";
+import "./shadowMap.vertex";
+import "Shaders/depthBoxBlur.fragment";
+
     /**
      * Interface to implement to create a shadow generator compatible with BJS.
      */

src/Materials/Background/backgroundMaterial.ts

@@ -22,10 +22,10 @@ import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
 import { IShadowLight } from "Lights/shadowLight";
 import { _TimeToken } from "Instrumentation/timeToken";
 import { _DepthCullingState, _StencilState, _AlphaState } from "States";
+import { Constants } from "Engines/constants";
 
 import "Shaders/background.fragment";
 import "Shaders/background.vertex";
-import { Constants } from "Engines/constants";
 
     /**
      * Background material defines definition.

src/Materials/PBR/pbrBaseMaterial.ts

@@ -28,10 +28,10 @@ import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
 import { CubeTexture } from "Materials/Textures/cubeTexture";
 
 import { StandardMaterial } from "Materials/standardMaterial";
+import { Constants } from "Engines/constants";
 
 import "Shaders/pbr.fragment";
 import "Shaders/pbr.vertex";
-import { Constants } from "Engines/constants";
 
     /**
      * Manages the defines for the PBR Material.

src/Materials/Textures/Procedurals/noiseProceduralTexture.ts

@@ -6,6 +6,8 @@ import { _DepthCullingState, _StencilState, _AlphaState } from "States";
 import { Texture } from "Materials/Textures/texture";
 import { ProceduralTexture } from "./proceduralTexture";
 
+import "Shaders/noise.fragment";
+
     /**
      * Class used to generate noise procedural textures
      */

src/Materials/Textures/Procedurals/proceduralTexture.ts

@@ -15,6 +15,8 @@ import { Texture } from "Materials/Textures/texture";
 import { RenderTargetTexture } from "Materials/Textures/renderTargetTexture";
 import { ProceduralTextureSceneComponent } from "./proceduralTextureSceneComponent";
 
+import "Shaders/procedural.vertex";
+
     /**
      * Procedural texturing is a way to programmatically create a texture. There are 2 types of procedural textures: code-only, and code that references some classic 2D images, sometimes calmpler' images.
      * This is the base class of any Procedural texture and contains most of the shareable code.

src/Meshes/linesMesh.ts

@@ -9,6 +9,10 @@ import { InstancedMesh } from "Meshes/instancedMesh";
 import { Effect } from "Materials/effect";
 import { Material } from "Materials/material";
 import { ShaderMaterial } from "Materials/shaderMaterial";
+
+import "Shaders/color.fragment";
+import "Shaders/color.vertex";
+
     /**
      * Line mesh
      * @see https://doc.babylonjs.com/babylon101/parametric_shapes

src/Misc/environmentTextureTools.ts

@@ -11,6 +11,9 @@ import { Scene } from "scene";
 import { PostProcess } from "PostProcesses/postProcess";
 import { Logger } from "Misc/logger";
 
+import "Shaders/rgbdEncode.fragment";
+import "Shaders/rgbdDecode.fragment";
+
     /**
      * Raw texture data and descriptor sufficient for WebGL texture upload
      */

src/Particles/gpuParticleSystem.ts

@@ -20,6 +20,11 @@ import { Texture } from "Materials/Textures/texture";
 import { RawTexture } from "Materials/Textures/rawTexture";
 import { Constants } from "Engines/constants";
 
+import "./gpuUpdateParticles.fragment";
+import "./gpuUpdateParticles.vertex";
+import "./gpuRenderParticles.fragment";
+import "./gpuRenderParticles.vertex";
+
     /**
      * This represents a GPU particle system in Babylon
      * This is the fastest particle system in Babylon as it uses the GPU to update the individual particle data

src/Particles/particleSystem.ts

@@ -24,6 +24,9 @@ import { SubEmitter, SubEmitterType } from "./subEmitter";
 import { Constants } from "Engines/constants";
 import { SerializationHelper } from "Misc/decorators";
 
+import "Shaders/particles.fragment";
+import "Shaders/particles.vertex";
+
     /**
      * This represents a particle system in Babylon.
      * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.

src/Particles/particleSystemComponent.ts

@@ -8,6 +8,9 @@ import { ParticleSystem } from "./particleSystem";
 import { Scene } from "scene";
 import { SceneComponentConstants } from "sceneComponent";
 import { AssetContainer } from "assetContainer";
+
+import "Shaders/particles.vertex";
+
     // Adds the parsers to the scene parsers.
     AbstractScene.AddParser(SceneComponentConstants.NAME_PARTICLESYSTEM, (parsedData: any, scene: Scene, container: AssetContainer, rootUrl: string) => {
 

src/PostProcesses/RenderPipeline/Pipelines/lensRenderingPipeline.ts

@@ -9,6 +9,10 @@ import { PostProcessRenderPipeline } from "PostProcesses/RenderPipeline/postProc
 import { PostProcessRenderEffect } from "PostProcesses/RenderPipeline/postProcessRenderEffect";
 import { Scene } from "scene";
 
+import "Shaders/chromaticAberration";
+import "Shaders/lensHighlights";
+import "Shaders/depthOfField.fragment";
+
     /**
      * BABYLON.JS Chromatic Aberration GLSL Shader
      * Author: Olivier Guyot

src/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline.ts

@@ -13,6 +13,9 @@ import { Engine } from "Engines/engine";
 import { GeometryBufferRenderer } from "Rendering/geometryBufferRenderer";
 import { Scene } from "scene";
 
+import "Shaders/ssao2.fragment";
+import "Shaders/ssaoCombine.fragment";
+
     /**
      * Render pipeline to produce ssao effect
      */

src/PostProcesses/RenderPipeline/Pipelines/ssaoRenderingPipeline.ts

@@ -13,6 +13,9 @@ import { Constants } from "Engines/constants";
 import { serialize } from "Misc/decorators";
 import { Scene } from "scene";
 
+import "Shaders/ssao.fragment";
+import "Shaders/ssaoCombine.fragment";
+
     /**
      * Render pipeline to produce ssao effect
      */

src/PostProcesses/RenderPipeline/Pipelines/standardRenderingPipeline.ts

@@ -19,6 +19,8 @@ import { GeometryBufferRenderer } from "Rendering/geometryBufferRenderer";
 import { Scene } from "scene";
 import { Animation } from "Animations/animation";
 import { Constants } from "Engines/constants";
+
+import "Shaders/standard.fragment";
     /**
      * Standard rendering pipeline
      * Default pipeline should be used going forward but the standard pipeline will be kept for backwards compatibility.

src/PostProcesses/anaglyphPostProcess.ts

@@ -4,6 +4,8 @@ import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Camera } from "Cameras/camera";
 import { Effect } from "Materials/effect";
 
+import "Shaders/anaglyph.fragment";
+
     /**
      * Postprocess used to generate anaglyphic rendering
      */

src/PostProcesses/blackAndWhitePostProcess.ts

@@ -3,6 +3,8 @@ import { Camera } from "Cameras/camera";
 import { Effect } from "Materials/effect";
 import { Engine } from "Engines/engine";
 
+import "Shaders/blackAndWhite.fragment";
+
     /**
      * Post process used to render in black and white
      */

src/PostProcesses/bloomMergePostProcess.ts

@@ -5,6 +5,8 @@ import { Effect } from "Materials/effect";
 import { Camera } from "Cameras/camera";
 import { Constants } from "Engines/constants";
 
+import "Shaders/bloomMerge.fragment";
+
     /**
      * The BloomMergePostProcess merges blurred images with the original based on the values of the circle of confusion.
      */

src/PostProcesses/blurPostProcess.ts

@@ -7,6 +7,9 @@ import { Texture } from "Materials/Textures/texture";
 import { Engine } from "Engines/engine";
 import { Constants } from "Engines/constants";
 
+import "Shaders/kernelBlur.fragment";
+import "Shaders/kernelBlur.vertex";
+
     /**
      * The Blur Post Process which blurs an image based on a kernel and direction.
      * Can be used twice in x and y directions to perform a guassian blur in two passes.

src/PostProcesses/chromaticAberrationPostProcess.ts

@@ -6,6 +6,8 @@ import { Camera } from "Cameras/camera";
 import { Engine } from "Engines/engine";
 import { Constants } from "Engines/constants";
 
+import "Shaders/chromaticAberration.fragment";
+
     /**
      * The ChromaticAberrationPostProcess separates the rgb channels in an image to produce chromatic distortion around the edges of the screen
      */

src/PostProcesses/circleOfConfusionPostProcess.ts

@@ -7,6 +7,8 @@ import { Camera } from "Cameras/camera";
 import { Logger } from "Misc/logger";
 import { Constants } from "Engines/constants";
 
+import "Shaders/circleOfConfusion.fragment";
+
     /**
      * The CircleOfConfusionPostProcess computes the circle of confusion value for each pixel given required lens parameters. See https://en.wikipedia.org/wiki/Circle_of_confusion
      */

src/PostProcesses/colorCorrectionPostProcess.ts

@@ -4,6 +4,8 @@ import { Texture } from "Materials/Textures/texture";
 import { Engine } from "Engines/engine";
 import { Camera } from "Cameras/camera";
 
+import "Shaders/colorCorrection.fragment";
+
     /**
      *
      * This post-process allows the modification of rendered colors by using

src/PostProcesses/convolutionPostProcess.ts

@@ -5,6 +5,8 @@ import { Engine } from "Engines/engine";
 import { Effect } from "Materials/effect";
 import { Constants } from "Engines/constants";
 
+import "Shaders/convolution.fragment";
+
     /**
      * The ConvolutionPostProcess applies a 3x3 kernel to every pixel of the
      * input texture to perform effects such as edge detection or sharpening

src/PostProcesses/depthOfFieldMergePostProcess.ts

@@ -4,6 +4,9 @@ import { Effect } from "Materials/effect";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
 import { Constants } from "Engines/constants";
+
+import "Shaders/depthOfFieldMerge.fragment";
+
     /**
      * Options to be set when merging outputs from the default pipeline.
      */

src/PostProcesses/displayPassPostProcess.ts

@@ -3,6 +3,8 @@ import { Camera } from "Cameras/camera";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
 
+import "Shaders/displayPass.fragment";
+
     /**
      * DisplayPassPostProcess which produces an output the same as it's input
      */

src/PostProcesses/extractHighlightsPostProcess.ts

@@ -6,6 +6,8 @@ import { Engine } from "Engines/engine";
 import { ToGammaSpace } from "Maths/math";
 import { Constants } from "Engines/constants";
 
+import "Shaders/extractHighlights.fragment";
+
     /**
      * The extract highlights post process sets all pixels to black except pixels above the specified luminance threshold. Used as the first step for a bloom effect.
      */

src/PostProcesses/filterPostProcess.ts

@@ -5,6 +5,8 @@ import { Effect } from "Materials/effect";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
 
+import "Shaders/filter.fragment";
+
     /**
      * Applies a kernel filter to the image
      */

src/PostProcesses/fxaaPostProcess.ts

@@ -6,6 +6,9 @@ import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
 import { Constants } from "Engines/constants";
 
+import "Shaders/fxaa.fragment";
+import "Shaders/fxaa.vertex";
+
     /**
      * Fxaa post process
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#fxaa

src/PostProcesses/grainPostProcess.ts

@@ -5,6 +5,8 @@ import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
 import { Constants } from "Engines/constants";
 
+import "Shaders/grain.fragment";
+
     /**
      * The GrainPostProcess adds noise to the image at mid luminance levels
      */

src/PostProcesses/highlightsPostProcess.ts

@@ -4,6 +4,8 @@ import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
 import { Constants } from "Engines/constants";
 
+import "Shaders/highlights.fragment";
+
     /**
      * Extracts highlights from the image
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses

src/PostProcesses/imageProcessingPostProcess.ts

@@ -12,6 +12,9 @@ import { Engine } from "Engines/engine";
 import { Scene } from "scene";
 import { Constants } from "Engines/constants";
 
+import "Shaders/imageProcessing.fragment";
+import "Shaders/postprocess.vertex";
+
     /**
      * ImageProcessingPostProcess
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#imageprocessing

src/PostProcesses/motionBlurPostProcess.ts

@@ -8,6 +8,8 @@ import { Constants } from "Engines/constants";
 import { GeometryBufferRenderer } from "Rendering/geometryBufferRenderer";
 import { Scene } from "scene";
 
+import "Shaders/motionBlur.fragment";
+
 declare type Engine = import("Engines/engine").Engine;
 
     /**

src/PostProcesses/passPostProcess.ts

@@ -3,6 +3,9 @@ import { Constants } from "Engines/constants";
 import { Camera } from "Cameras/camera";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 
+import "Shaders/pass.fragment";
+import "Shaders/passCube.fragment";
+
 declare type Engine = import("Engines/engine").Engine;
 
     /**

src/PostProcesses/postProcess.ts

@@ -9,6 +9,8 @@ import { Scene } from "scene";
 import { Animation } from "Animations/animation";
 import { Constants } from "Engines/constants";
 
+import "Shaders/postprocess.vertex";
+
 declare type InternalTexture  = import("Materials/Textures/internalTexture").InternalTexture;
 declare type WebVRFreeCamera = import("Cameras/VR/webVRCamera").WebVRFreeCamera;
 declare type Engine = import("Engines/engine").Engine;

src/PostProcesses/refractionPostProcess.ts

@@ -4,6 +4,9 @@ import { Effect } from "Materials/effect";
 import { Texture } from "Materials/Textures/texture";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Engine } from "Engines/engine";
+
+import "Shaders/refraction.fragment";
+
     /**
      * Post process which applies a refractin texture
      * @see https://doc.babylonjs.com/how_to/how_to_use_postprocesses#refraction

src/PostProcesses/sharpenPostProcess.ts

@@ -4,6 +4,8 @@ import { Effect } from "Materials/effect";
 import { PostProcess, PostProcessOptions } from "./postProcess";
 import { Constants } from "Engines/constants";
 
+import "Shaders/sharpen.fragment";
+
 declare type Engine = import("Engines/engine").Engine;
     /**
      * The SharpenPostProcess applies a sharpen kernel to every pixel

src/PostProcesses/stereoscopicInterlacePostProcess.ts

@@ -4,6 +4,9 @@ import { Camera } from "Cameras/camera";
 import { Effect } from "Materials/effect";
 import { PostProcess } from "./postProcess";
 import { Engine } from "Engines/engine";
+
+import "Shaders/stereoscopicInterlace.fragment";
+
     /**
      * StereoscopicInterlacePostProcess used to render stereo views from a rigged camera
      */

src/PostProcesses/tonemapPostProcess.ts

@@ -3,6 +3,8 @@ import { Effect } from "Materials/effect";
 import { PostProcess } from "./postProcess";
 import { Constants } from "Engines/constants";
 
+import "Shaders/tonemap.fragment";
+
 declare type Engine = import("Engines/engine").Engine;
 
     /** Defines operator used for tonemapping */

src/PostProcesses/volumetricLightScatteringPostProcess.ts

@@ -16,6 +16,10 @@ import { PostProcess } from "./postProcess";
 import { Constants } from "Engines/constants";
 import { Scene } from "scene";
 
+import "Shaders/depth.vertex";
+import "Shaders/volumetricLightScattering.fragment";
+import "Shaders/volumetricLightScatteringPass.fragment";
+
 declare type Engine = import("Engines/engine").Engine;
 
     /**

src/PostProcesses/vrDistortionCorrectionPostProcess.ts

@@ -4,6 +4,9 @@ import { VRCameraMetrics } from "Cameras/VR/vrCameraMetrics";
 import { Effect } from "Materials/effect";
 import { Texture } from "Materials/Textures/texture";
 import { PostProcess } from "./postProcess";
+
+import "Shaders/vrDistortionCorrection.fragment";
+
     /**
      * VRDistortionCorrectionPostProcess used for mobile VR
      */

src/Rendering/boundingBoxRenderer.ts

@@ -12,6 +12,9 @@ import { Effect } from "Materials/effect";
 import { Material } from "Materials/material";
 import { ShaderMaterial } from "Materials/shaderMaterial";
 
+import "Shaders/color.fragment";
+import "Shaders/color.vertex";
+
 declare module "scene" {
     export interface Scene {
         /** @hidden (Backing field) */

src/Rendering/depthRenderer.ts

@@ -13,6 +13,9 @@ import { Constants } from "Engines/constants";
 import { SceneComponentConstants } from "sceneComponent";
 import { DepthRendererSceneComponent } from "./depthRendererSceneComponent";
 
+import "./depth.fragment";
+import "./depth.vertex";
+
     /**
      * This represents a depth renderer in Babylon.
      * A depth renderer will render to it's depth map every frame which can be displayed or used in post processing

src/Rendering/edgesRenderer.ts

@@ -12,6 +12,9 @@ import { Camera } from "Cameras/camera";
 import { Constants } from "Engines/constants";
 import { Node } from "node";
 
+import "Shaders/line.fragment";
+import "Shaders/line.vertex";
+
 declare module "Meshes/AbstractMesh" {
     export interface AbstractMesh {
         /**

src/Rendering/geometryBufferRenderer.ts

@@ -12,6 +12,9 @@ import { GeometryBufferRendererSceneComponent } from "./geometryBufferRendererSc
 import { Scene } from "scene";
 import { SceneComponentConstants } from "sceneComponent";
 
+import "./geometry.fragment";
+import "./geometry.vertex";
+
     /**
      * This renderer is helpfull to fill one of the render target with a geometry buffer.
      */

src/Rendering/outlineRenderer.ts

@@ -9,6 +9,9 @@ import { ISceneComponent, SceneComponentConstants } from "sceneComponent";
 import { Effect } from "Materials/effect";
 import { Material } from "Materials/material";
 
+import "./outline.fragment";
+import "./outline.vertex";
+
 declare module "scene" {
     export interface Scene {
         /** @hidden */

src/Sprites/spriteManager.ts

@@ -15,6 +15,9 @@ import { Material } from "Materials/material";
 import { SceneComponentConstants } from "sceneComponent";
 import { Constants } from "Engines/constants";
 
+import "./sprites.fragment";
+import "./sprites.vertex";
+
     /**
      * Defines the minimum interface to fullfil in order to be a sprite manager.
      */