Merge pull request #7083 from Pryme8/Worley_Block_Dev

Worley Noise Node

nodeEditor/src/blockTools.ts

@@ -1,465 +1,468 @@
-import { DiscardBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/discardBlock';
-import { BonesBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/bonesBlock';
-import { InstancesBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/instancesBlock';
-import { MorphTargetsBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/morphTargetsBlock';
-import { ImageProcessingBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/imageProcessingBlock';
-import { ColorMergerBlock } from 'babylonjs/Materials/Node/Blocks/colorMergerBlock';
-import { VectorMergerBlock } from 'babylonjs/Materials/Node/Blocks/vectorMergerBlock';
-import { ColorSplitterBlock } from 'babylonjs/Materials/Node/Blocks/colorSplitterBlock';
-import { VectorSplitterBlock } from 'babylonjs/Materials/Node/Blocks/vectorSplitterBlock';
-import { RemapBlock } from 'babylonjs/Materials/Node/Blocks/remapBlock';
-import { TextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/textureBlock';
-import { ReflectionTextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock';
-import { LightBlock } from 'babylonjs/Materials/Node/Blocks/Dual/lightBlock';
-import { FogBlock } from 'babylonjs/Materials/Node/Blocks/Dual/fogBlock';
-import { VertexOutputBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/vertexOutputBlock';
-import { FragmentOutputBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/fragmentOutputBlock';
-import { NormalizeBlock } from 'babylonjs/Materials/Node/Blocks/normalizeBlock';
-import { AddBlock } from 'babylonjs/Materials/Node/Blocks/addBlock';
-import { ScaleBlock } from 'babylonjs/Materials/Node/Blocks/scaleBlock';
-import { TrigonometryBlock, TrigonometryBlockOperations } from 'babylonjs/Materials/Node/Blocks/trigonometryBlock';
-import { ClampBlock } from 'babylonjs/Materials/Node/Blocks/clampBlock';
-import { CrossBlock } from 'babylonjs/Materials/Node/Blocks/crossBlock';
-import { DotBlock } from 'babylonjs/Materials/Node/Blocks/dotBlock';
-import { MultiplyBlock } from 'babylonjs/Materials/Node/Blocks/multiplyBlock';
-import { TransformBlock } from 'babylonjs/Materials/Node/Blocks/transformBlock';
-import { NodeMaterialBlockConnectionPointTypes } from 'babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes';
-import { FresnelBlock } from 'babylonjs/Materials/Node/Blocks/fresnelBlock';
-import { LerpBlock } from 'babylonjs/Materials/Node/Blocks/lerpBlock';
-import { NLerpBlock } from 'babylonjs/Materials/Node/Blocks/nLerpBlock';
-import { DivideBlock } from 'babylonjs/Materials/Node/Blocks/divideBlock';
-import { SubtractBlock } from 'babylonjs/Materials/Node/Blocks/subtractBlock';
-import { StepBlock } from 'babylonjs/Materials/Node/Blocks/stepBlock';
-import { SmoothStepBlock } from 'babylonjs/Materials/Node/Blocks/smoothStepBlock';
-import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
-import { NodeMaterialSystemValues } from 'babylonjs/Materials/Node/Enums/nodeMaterialSystemValues';
-import { AnimatedInputBlockTypes } from 'babylonjs/Materials/Node/Blocks/Input/animatedInputBlockTypes';
-import { OneMinusBlock } from 'babylonjs/Materials/Node/Blocks/oneMinusBlock';
-import { ViewDirectionBlock } from 'babylonjs/Materials/Node/Blocks/viewDirectionBlock';
-import { LightInformationBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/lightInformationBlock';
-import { MaxBlock } from 'babylonjs/Materials/Node/Blocks/maxBlock';
-import { MinBlock } from 'babylonjs/Materials/Node/Blocks/minBlock';
-import { PerturbNormalBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/perturbNormalBlock';
-import { LengthBlock } from 'babylonjs/Materials/Node/Blocks/lengthBlock';
-import { DistanceBlock } from 'babylonjs/Materials/Node/Blocks/distanceBlock';
-import { FrontFacingBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/frontFacingBlock';
-import { NegateBlock } from 'babylonjs/Materials/Node/Blocks/negateBlock';
-import { PowBlock } from 'babylonjs/Materials/Node/Blocks/powBlock';
-import { Scene } from 'babylonjs/scene';
-import { RandomNumberBlock } from 'babylonjs/Materials/Node/Blocks/randomNumberBlock';
-import { ReplaceColorBlock } from 'babylonjs/Materials/Node/Blocks/replaceColorBlock';
-import { PosterizeBlock } from 'babylonjs/Materials/Node/Blocks/posterizeBlock';
-import { ArcTan2Block } from 'babylonjs/Materials/Node/Blocks/arcTan2Block';
-import { ReciprocalBlock } from 'babylonjs/Materials/Node/Blocks/reciprocalBlock';
-import { GradientBlock } from 'babylonjs/Materials/Node/Blocks/gradientBlock';
-import { WaveBlock, WaveBlockKind } from 'babylonjs/Materials/Node/Blocks/waveBlock';
-import { NodeMaterial } from 'babylonjs/Materials/Node/nodeMaterial';
-import { SimplexPerlin3DBlock } from 'babylonjs/Materials/Node/Blocks/simplexPerlin3DBlock';
-
-export class BlockTools {
-    public static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial) {
-        switch (data) {
-            case "SimplexPerlin3DBlock":
-                return new SimplexPerlin3DBlock("SimplexPerlin3DBlock");
-            case "BonesBlock":
-                return new BonesBlock("Bones");
-            case "InstancesBlock":
-                return new InstancesBlock("Instances");
-            case "MorphTargetsBlock":
-                return new MorphTargetsBlock("MorphTargets");
-            case "DiscardBlock":
-                return new DiscardBlock("Discard");
-            case "ImageProcessingBlock":
-                return new ImageProcessingBlock("ImageProcessing");
-            case "ColorMergerBlock":
-                return new ColorMergerBlock("ColorMerger");
-            case "VectorMergerBlock":
-                return new VectorMergerBlock("VectorMerger");                
-            case "ColorSplitterBlock":
-                return new ColorSplitterBlock("ColorSplitter");
-            case "VectorSplitterBlock":
-                return new VectorSplitterBlock("VectorSplitter");
-            case "TextureBlock":
-                return new TextureBlock("Texture");
-            case "ReflectionTextureBlock":
-                return new ReflectionTextureBlock("Reflection texture");                
-            case "LightBlock":
-                return new LightBlock("Lights");
-            case "FogBlock":
-                return new FogBlock("Fog");
-            case "VertexOutputBlock":
-                return new VertexOutputBlock("VertexOutput");
-            case "FragmentOutputBlock":
-                return new FragmentOutputBlock("FragmentOutput");
-            case "AddBlock":
-                return new AddBlock("Add");
-            case "ClampBlock":
-                return new ClampBlock("Clamp");
-            case "ScaleBlock":
-                return new ScaleBlock("Scale");
-            case "CrossBlock":
-                return new CrossBlock("Cross");
-            case "DotBlock":
-                return new DotBlock("Dot");
-            case "PowBlock":
-                return new PowBlock("Pow");
-            case "MultiplyBlock":
-                return new MultiplyBlock("Multiply");
-            case "TransformBlock":
-                return new TransformBlock("Transform");
-            case "TrigonometryBlock":
-                return new TrigonometryBlock("Trigonometry");
-            case "RemapBlock":
-                return new RemapBlock("Remap");
-            case "NormalizeBlock":
-                return new NormalizeBlock("Normalize");
-            case "FresnelBlock":
-                return new FresnelBlock("Fresnel");
-            case "LerpBlock":
-                return new LerpBlock("Lerp");
-            case "NLerpBlock":
-                return new NLerpBlock("NLerp");
-            case "DivideBlock":
-                return new DivideBlock("Divide");
-            case "SubtractBlock":
-                return new SubtractBlock("Subtract"); 
-            case "StepBlock":
-                return new StepBlock("Step");        
-            case "SmoothStepBlock":
-                return new SmoothStepBlock("Smooth step");        
-            case "OneMinusBlock":
-                return new OneMinusBlock("One minus");          
-            case "ReciprocalBlock":
-                return new ReciprocalBlock("Reciprocal");    
-            case "ViewDirectionBlock":
-                return new ViewDirectionBlock("View direction");    
-            case "LightInformationBlock":
-                let lightInformationBlock = new LightInformationBlock("Light information");
-                lightInformationBlock.light = scene.lights.length ? scene.lights[0] : null;
-                return lightInformationBlock;
-            case "MaxBlock":
-                return new MaxBlock("Max");       
-            case "MinBlock":
-                return new MinBlock("Min");      
-            case "LengthBlock":
-                return new LengthBlock("Length");   
-            case "DistanceBlock":
-                return new DistanceBlock("Distance");     
-            case "NegateBlock":
-                return new NegateBlock("Negate");                                     
-            case "PerturbNormalBlock":                                          
-                return new PerturbNormalBlock("Perturb normal");                     
-            case "RandomNumberBlock":                                          
-                return new RandomNumberBlock("Random number");         
-            case "ReplaceColorBlock":                                          
-                return new ReplaceColorBlock("Replace color");      
-            case "PosterizeBlock":                                          
-                return new PosterizeBlock("Posterize");                              
-            case "ArcTan2Block":                                          
-                return new ArcTan2Block("ArcTan2");                            
-            case "GradientBlock":                                          
-                return new GradientBlock("Gradient");                             
-            case "FrontFacingBlock":                                          
-                return new FrontFacingBlock("Front facing");            
-            case "CosBlock": {
-                let cosBlock = new TrigonometryBlock("Cos");
-                cosBlock.operation = TrigonometryBlockOperations.Cos;
-                return cosBlock;
-            }
-            case "SinBlock": {
-                let sinBlock = new TrigonometryBlock("Sin");
-                sinBlock.operation = TrigonometryBlockOperations.Sin;
-                return sinBlock;
-            }
-            case "AbsBlock": {
-                let absBlock = new TrigonometryBlock("Abs");
-                absBlock.operation = TrigonometryBlockOperations.Abs;
-                return absBlock;
-            }            
-            case "SqrtBlock": {
-                let sqrtBlock = new TrigonometryBlock("Sqrt");
-                sqrtBlock.operation = TrigonometryBlockOperations.Sqrt;
-                return sqrtBlock;
-            }
-            case "ArcCosBlock": {
-                let acosBlock = new TrigonometryBlock("ArcCos");
-                acosBlock.operation = TrigonometryBlockOperations.ArcCos;
-                return acosBlock;
-            }
-            case "ArcSinBlock": {
-                let asinBlock = new TrigonometryBlock("ArcSin");
-                asinBlock.operation = TrigonometryBlockOperations.ArcSin;
-                return asinBlock;
-            }
-            case "TanBlock": {
-                let tanBlock = new TrigonometryBlock("Tan");
-                tanBlock.operation = TrigonometryBlockOperations.Tan;
-                return tanBlock;
-            }
-            case "ArcTanBlock": {
-                let atanBlock = new TrigonometryBlock("ArcTan");
-                atanBlock.operation = TrigonometryBlockOperations.ArcTan;
-                return atanBlock;
-            }
-            case "FractBlock": {
-                let fractBlock = new TrigonometryBlock("Fract");
-                fractBlock.operation = TrigonometryBlockOperations.Fract;
-                return fractBlock;
-            }
-            case "SignBlock": {
-                let signBlock = new TrigonometryBlock("Sign");
-                signBlock.operation = TrigonometryBlockOperations.Sign;
-                return signBlock;
-            }            
-            case "LogBlock": {
-                let logBlock = new TrigonometryBlock("Log");
-                logBlock.operation = TrigonometryBlockOperations.Log;
-                return logBlock;
-            }                                                            
-            case "ExpBlock": {
-                let expBlock = new TrigonometryBlock("Exp");
-                expBlock.operation = TrigonometryBlockOperations.Exp;
-                return expBlock;
-            }
-            case "Exp2Block": {
-                let exp2Block = new TrigonometryBlock("Exp2");
-                exp2Block.operation = TrigonometryBlockOperations.Exp2;
-                return exp2Block;
-            }
-            case "DegreesToRadiansBlock": {
-                let degreesToRadiansBlock = new TrigonometryBlock("Degrees to radians");
-                degreesToRadiansBlock.operation = TrigonometryBlockOperations.Radians;
-                return degreesToRadiansBlock;
-            }
-            case "RadiansToDegreesBlock": {
-                let radiansToDegreesBlock = new TrigonometryBlock("Radians to degrees");
-                radiansToDegreesBlock.operation = TrigonometryBlockOperations.Degrees;
-                return radiansToDegreesBlock;
-            }                        
-            case "RoundBlock": {
-                let roundBlock = new TrigonometryBlock("Round");
-                roundBlock.operation = TrigonometryBlockOperations.Round;
-                return roundBlock;
-            }
-            case "CeilingBlock": {
-                let ceilingBlock = new TrigonometryBlock("Ceiling");
-                ceilingBlock.operation = TrigonometryBlockOperations.Ceiling;
-                return ceilingBlock;
-            }     
-            case "FloorBlock": {
-                let floorBlock = new TrigonometryBlock("Floor");
-                floorBlock.operation = TrigonometryBlockOperations.Floor;
-                return floorBlock;
-            }       
-            case "SawToothWaveBlock": {
-                let sawToothWaveBlock = new WaveBlock("SawTooth wave");
-                sawToothWaveBlock.kind = WaveBlockKind.SawTooth;
-                return sawToothWaveBlock;
-            }     
-            case "SquareWaveBlock": {
-                let squareWaveBlock = new WaveBlock("Square wave");
-                squareWaveBlock.kind = WaveBlockKind.Square;
-                return squareWaveBlock;
-            }     
-            case "TriangleWaveBlock": {
-                let triangleWaveBlock = new WaveBlock("Triangle wave");
-                triangleWaveBlock.kind = WaveBlockKind.Triangle;
-                return triangleWaveBlock;
-            }
-            case "WorldMatrixBlock": {
-                let worldMatrixBlock = new InputBlock("World");
-                worldMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.World);
-                return worldMatrixBlock;
-            }             
-            case "WorldViewMatrixBlock": {
-                let worldViewMatrixBlock = new InputBlock("World x View");
-                worldViewMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.WorldView);
-                return worldViewMatrixBlock;
-            }             
-            case "WorldViewProjectionMatrixBlock": {
-                let worldViewProjectionMatrixBlock = new InputBlock("World x View x Projection");
-                worldViewProjectionMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.WorldViewProjection);
-                return worldViewProjectionMatrixBlock;
-            }                    
-            case "ViewMatrixBlock": {
-                let viewMatrixBlock = new InputBlock("View");
-                viewMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.View);
-                return viewMatrixBlock;
-            }                          
-            case "ViewProjectionMatrixBlock": {
-                let viewProjectionMatrixBlock = new InputBlock("View x Projection");
-                viewProjectionMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.ViewProjection);
-                return viewProjectionMatrixBlock;
-            }                              
-            case "ProjectionMatrixBlock": {
-                let projectionMatrixBlock = new InputBlock("Projection");
-                projectionMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.Projection);
-                return projectionMatrixBlock;
-            }                                 
-            case "CameraPositionBlock": {
-                let cameraPosition = new InputBlock("Camera position");
-                cameraPosition.setAsSystemValue(NodeMaterialSystemValues.CameraPosition);
-                return cameraPosition;
-            }                              
-            case "FogColorBlock": {
-                let FogColor = new InputBlock("Fog color");
-                FogColor.setAsSystemValue(NodeMaterialSystemValues.FogColor);
-                return FogColor;
-            }                                   
-            case "PositionBlock": {
-                let meshPosition = new InputBlock("position");
-                meshPosition.setAsAttribute("position");
-                return meshPosition;
-            }                                        
-            case "UVBlock": {
-                let meshUV = new InputBlock("uv");
-                meshUV.setAsAttribute("uv");
-                return meshUV;
-            }                                         
-            case "ColorBlock": {
-                let meshColor = new InputBlock("color");
-                meshColor.setAsAttribute("color");
-                return meshColor;
-            }                                              
-            case "NormalBlock": {
-                let meshNormal = new InputBlock("normal");
-                meshNormal.setAsAttribute("normal");
-                return meshNormal;
-            }                                                 
-            case "TangentBlock": {
-                let meshTangent = new InputBlock("tangent");
-                meshTangent.setAsAttribute("tangent");
-                return meshTangent;
-            }                                                  
-            case "MatrixIndicesBlock": {
-                let meshMatrixIndices = new InputBlock("matricesIndices");
-                meshMatrixIndices.setAsAttribute("matricesIndices");
-                return meshMatrixIndices;
-            }                                                    
-            case "MatrixWeightsBlock": {
-                let meshMatrixWeights = new InputBlock("matricesWeights");
-                meshMatrixWeights.setAsAttribute("matricesWeights");
-                return meshMatrixWeights;
-            }                                                     
-            case "TimeBlock": {
-                let timeBlock = new InputBlock("Time", undefined, NodeMaterialBlockConnectionPointTypes.Float);
-                timeBlock.animationType = AnimatedInputBlockTypes.Time;
-                return timeBlock;
-            }   
-            case "DeltaTimeBlock": {
-                let deltaTimeBlock = new InputBlock("Delta time");                
-                deltaTimeBlock.setAsSystemValue(NodeMaterialSystemValues.DeltaTime);
-                return deltaTimeBlock;
-            }      
-            case "WorldPositionBlock": {
-                let worldPositionBlock = nodeMaterial.getInputBlockByPredicate(b => b.isAttribute && b.name === "position");                
-                if (!worldPositionBlock) {
-                    worldPositionBlock = new InputBlock("position");
-                    worldPositionBlock.setAsAttribute("position");
-                }
-
-                let worldMatrixBlock = nodeMaterial.getInputBlockByPredicate(b => b.isSystemValue && b.systemValue === NodeMaterialSystemValues.World);  
-
-                if (!worldMatrixBlock) {
-                    worldMatrixBlock = new InputBlock("World");
-                    worldMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.World);
-                }
-
-                let transformBlock = new TransformBlock("World position");
-                worldPositionBlock.connectTo(transformBlock);
-                worldMatrixBlock.connectTo(transformBlock);
-
-                return transformBlock;
-            }        
-            case "WorldNormalBlock": {
-                let worldNormalBlock = nodeMaterial.getInputBlockByPredicate(b => b.isAttribute && b.name === "normal");                
-                if (!worldNormalBlock) {
-                    worldNormalBlock = new InputBlock("normal");
-                    worldNormalBlock.setAsAttribute("normal");
-                }
-
-                let worldMatrixBlock = nodeMaterial.getInputBlockByPredicate(b => b.isSystemValue && b.systemValue === NodeMaterialSystemValues.World);  
-
-                if (!worldMatrixBlock) {
-                    worldMatrixBlock = new InputBlock("World");
-                    worldMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.World);
-                }
-
-                let transformBlock = new TransformBlock("World normal");
-                worldNormalBlock.connectTo(transformBlock);
-                worldMatrixBlock.connectTo(transformBlock);
-
-                return transformBlock;
-            }                  
-        }
-
-        return null;
-    }
-
-    public static GetColorFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes) {
-        let color = "Red";
-        switch (type) {
-            case NodeMaterialBlockConnectionPointTypes.Float:
-				color = "#cb9e27";
-                break;
-            case NodeMaterialBlockConnectionPointTypes.Vector2:                
-				color = "#16bcb1";
-                break;
-            case NodeMaterialBlockConnectionPointTypes.Vector3:                
-            case NodeMaterialBlockConnectionPointTypes.Color3:                
-                color = "#b786cb";
-                break;
-            case NodeMaterialBlockConnectionPointTypes.Vector4:                
-            case NodeMaterialBlockConnectionPointTypes.Color4:                
-				color = "#be5126";
-                break;
-            case NodeMaterialBlockConnectionPointTypes.Matrix:                
-				color = "#591990";
-                break;
-        }
-
-        return color;
-    }
-
-    public static GetConnectionNodeTypeFromString(type: string) {
-        switch (type) {
-            case "Float":
-                return NodeMaterialBlockConnectionPointTypes.Float;
-            case "Vector2":
-                return NodeMaterialBlockConnectionPointTypes.Vector2;
-            case "Vector3":
-                return NodeMaterialBlockConnectionPointTypes.Vector3;
-            case "Vector4":
-                return NodeMaterialBlockConnectionPointTypes.Vector4;
-            case "Matrix":
-                return NodeMaterialBlockConnectionPointTypes.Matrix;
-            case "Color3":
-                return NodeMaterialBlockConnectionPointTypes.Color3;
-            case "Color4":
-                return NodeMaterialBlockConnectionPointTypes.Color4;
-        }
-
-        return NodeMaterialBlockConnectionPointTypes.AutoDetect;
-    }
-
-    public static GetStringFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes) {
-        switch (type){
-            case NodeMaterialBlockConnectionPointTypes.Float:
-                return "Float";
-            case NodeMaterialBlockConnectionPointTypes.Vector2:
-                return "Vector2";
-            case NodeMaterialBlockConnectionPointTypes.Vector3:
-                return "Vector3";
-            case NodeMaterialBlockConnectionPointTypes.Vector4:
-                return "Vector4";
-            case NodeMaterialBlockConnectionPointTypes.Color3:
-                return "Color3";
-            case NodeMaterialBlockConnectionPointTypes.Color4:
-                return "Color4";
-            case NodeMaterialBlockConnectionPointTypes.Matrix:
-                return "Matrix";
-        }
-
-        return "";
-    }
+import { DiscardBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/discardBlock';
+import { BonesBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/bonesBlock';
+import { InstancesBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/instancesBlock';
+import { MorphTargetsBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/morphTargetsBlock';
+import { ImageProcessingBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/imageProcessingBlock';
+import { ColorMergerBlock } from 'babylonjs/Materials/Node/Blocks/colorMergerBlock';
+import { VectorMergerBlock } from 'babylonjs/Materials/Node/Blocks/vectorMergerBlock';
+import { ColorSplitterBlock } from 'babylonjs/Materials/Node/Blocks/colorSplitterBlock';
+import { VectorSplitterBlock } from 'babylonjs/Materials/Node/Blocks/vectorSplitterBlock';
+import { RemapBlock } from 'babylonjs/Materials/Node/Blocks/remapBlock';
+import { TextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/textureBlock';
+import { ReflectionTextureBlock } from 'babylonjs/Materials/Node/Blocks/Dual/reflectionTextureBlock';
+import { LightBlock } from 'babylonjs/Materials/Node/Blocks/Dual/lightBlock';
+import { FogBlock } from 'babylonjs/Materials/Node/Blocks/Dual/fogBlock';
+import { VertexOutputBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/vertexOutputBlock';
+import { FragmentOutputBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/fragmentOutputBlock';
+import { NormalizeBlock } from 'babylonjs/Materials/Node/Blocks/normalizeBlock';
+import { AddBlock } from 'babylonjs/Materials/Node/Blocks/addBlock';
+import { ScaleBlock } from 'babylonjs/Materials/Node/Blocks/scaleBlock';
+import { TrigonometryBlock, TrigonometryBlockOperations } from 'babylonjs/Materials/Node/Blocks/trigonometryBlock';
+import { ClampBlock } from 'babylonjs/Materials/Node/Blocks/clampBlock';
+import { CrossBlock } from 'babylonjs/Materials/Node/Blocks/crossBlock';
+import { DotBlock } from 'babylonjs/Materials/Node/Blocks/dotBlock';
+import { MultiplyBlock } from 'babylonjs/Materials/Node/Blocks/multiplyBlock';
+import { TransformBlock } from 'babylonjs/Materials/Node/Blocks/transformBlock';
+import { NodeMaterialBlockConnectionPointTypes } from 'babylonjs/Materials/Node/Enums/nodeMaterialBlockConnectionPointTypes';
+import { FresnelBlock } from 'babylonjs/Materials/Node/Blocks/fresnelBlock';
+import { LerpBlock } from 'babylonjs/Materials/Node/Blocks/lerpBlock';
+import { NLerpBlock } from 'babylonjs/Materials/Node/Blocks/nLerpBlock';
+import { DivideBlock } from 'babylonjs/Materials/Node/Blocks/divideBlock';
+import { SubtractBlock } from 'babylonjs/Materials/Node/Blocks/subtractBlock';
+import { StepBlock } from 'babylonjs/Materials/Node/Blocks/stepBlock';
+import { SmoothStepBlock } from 'babylonjs/Materials/Node/Blocks/smoothStepBlock';
+import { InputBlock } from 'babylonjs/Materials/Node/Blocks/Input/inputBlock';
+import { NodeMaterialSystemValues } from 'babylonjs/Materials/Node/Enums/nodeMaterialSystemValues';
+import { AnimatedInputBlockTypes } from 'babylonjs/Materials/Node/Blocks/Input/animatedInputBlockTypes';
+import { OneMinusBlock } from 'babylonjs/Materials/Node/Blocks/oneMinusBlock';
+import { ViewDirectionBlock } from 'babylonjs/Materials/Node/Blocks/viewDirectionBlock';
+import { LightInformationBlock } from 'babylonjs/Materials/Node/Blocks/Vertex/lightInformationBlock';
+import { MaxBlock } from 'babylonjs/Materials/Node/Blocks/maxBlock';
+import { MinBlock } from 'babylonjs/Materials/Node/Blocks/minBlock';
+import { PerturbNormalBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/perturbNormalBlock';
+import { LengthBlock } from 'babylonjs/Materials/Node/Blocks/lengthBlock';
+import { DistanceBlock } from 'babylonjs/Materials/Node/Blocks/distanceBlock';
+import { FrontFacingBlock } from 'babylonjs/Materials/Node/Blocks/Fragment/frontFacingBlock';
+import { NegateBlock } from 'babylonjs/Materials/Node/Blocks/negateBlock';
+import { PowBlock } from 'babylonjs/Materials/Node/Blocks/powBlock';
+import { Scene } from 'babylonjs/scene';
+import { RandomNumberBlock } from 'babylonjs/Materials/Node/Blocks/randomNumberBlock';
+import { ReplaceColorBlock } from 'babylonjs/Materials/Node/Blocks/replaceColorBlock';
+import { PosterizeBlock } from 'babylonjs/Materials/Node/Blocks/posterizeBlock';
+import { ArcTan2Block } from 'babylonjs/Materials/Node/Blocks/arcTan2Block';
+import { ReciprocalBlock } from 'babylonjs/Materials/Node/Blocks/reciprocalBlock';
+import { GradientBlock } from 'babylonjs/Materials/Node/Blocks/gradientBlock';
+import { WaveBlock, WaveBlockKind } from 'babylonjs/Materials/Node/Blocks/waveBlock';
+import { NodeMaterial } from 'babylonjs/Materials/Node/nodeMaterial';
+import { WorleyNoise3DBlock } from 'babylonjs/Materials/Node/Blocks/worleyNoise3DBlock';
+import { SimplexPerlin3DBlock } from 'babylonjs/Materials/Node/Blocks/simplexPerlin3DBlock';
+
+export class BlockTools {
+    public static GetBlockFromString(data: string, scene: Scene, nodeMaterial: NodeMaterial) {
+        switch (data) {
+            case "WorleyNoise3DBlock":
+                return new WorleyNoise3DBlock("WorleyNoise3D");
+            case "SimplexPerlin3DBlock":
+                return new SimplexPerlin3DBlock("SimplexPerlin3D");
+            case "BonesBlock":
+                return new BonesBlock("Bones");
+            case "InstancesBlock":
+                return new InstancesBlock("Instances");
+            case "MorphTargetsBlock":
+                return new MorphTargetsBlock("MorphTargets");
+            case "DiscardBlock":
+                return new DiscardBlock("Discard");
+            case "ImageProcessingBlock":
+                return new ImageProcessingBlock("ImageProcessing");
+            case "ColorMergerBlock":
+                return new ColorMergerBlock("ColorMerger");
+            case "VectorMergerBlock":
+                return new VectorMergerBlock("VectorMerger");                
+            case "ColorSplitterBlock":
+                return new ColorSplitterBlock("ColorSplitter");
+            case "VectorSplitterBlock":
+                return new VectorSplitterBlock("VectorSplitter");
+            case "TextureBlock":
+                return new TextureBlock("Texture");
+            case "ReflectionTextureBlock":
+                return new ReflectionTextureBlock("Reflection texture");                
+            case "LightBlock":
+                return new LightBlock("Lights");
+            case "FogBlock":
+                return new FogBlock("Fog");
+            case "VertexOutputBlock":
+                return new VertexOutputBlock("VertexOutput");
+            case "FragmentOutputBlock":
+                return new FragmentOutputBlock("FragmentOutput");
+            case "AddBlock":
+                return new AddBlock("Add");
+            case "ClampBlock":
+                return new ClampBlock("Clamp");
+            case "ScaleBlock":
+                return new ScaleBlock("Scale");
+            case "CrossBlock":
+                return new CrossBlock("Cross");
+            case "DotBlock":
+                return new DotBlock("Dot");
+            case "PowBlock":
+                return new PowBlock("Pow");
+            case "MultiplyBlock":
+                return new MultiplyBlock("Multiply");
+            case "TransformBlock":
+                return new TransformBlock("Transform");
+            case "TrigonometryBlock":
+                return new TrigonometryBlock("Trigonometry");
+            case "RemapBlock":
+                return new RemapBlock("Remap");
+            case "NormalizeBlock":
+                return new NormalizeBlock("Normalize");
+            case "FresnelBlock":
+                return new FresnelBlock("Fresnel");
+            case "LerpBlock":
+                return new LerpBlock("Lerp");
+            case "NLerpBlock":
+                return new NLerpBlock("NLerp");
+            case "DivideBlock":
+                return new DivideBlock("Divide");
+            case "SubtractBlock":
+                return new SubtractBlock("Subtract"); 
+            case "StepBlock":
+                return new StepBlock("Step");        
+            case "SmoothStepBlock":
+                return new SmoothStepBlock("Smooth step");        
+            case "OneMinusBlock":
+                return new OneMinusBlock("One minus");          
+            case "ReciprocalBlock":
+                return new ReciprocalBlock("Reciprocal");    
+            case "ViewDirectionBlock":
+                return new ViewDirectionBlock("View direction");    
+            case "LightInformationBlock":
+                let lightInformationBlock = new LightInformationBlock("Light information");
+                lightInformationBlock.light = scene.lights.length ? scene.lights[0] : null;
+                return lightInformationBlock;
+            case "MaxBlock":
+                return new MaxBlock("Max");       
+            case "MinBlock":
+                return new MinBlock("Min");      
+            case "LengthBlock":
+                return new LengthBlock("Length");   
+            case "DistanceBlock":
+                return new DistanceBlock("Distance");     
+            case "NegateBlock":
+                return new NegateBlock("Negate");                                     
+            case "PerturbNormalBlock":                                          
+                return new PerturbNormalBlock("Perturb normal");                     
+            case "RandomNumberBlock":                                          
+                return new RandomNumberBlock("Random number");         
+            case "ReplaceColorBlock":                                          
+                return new ReplaceColorBlock("Replace color");      
+            case "PosterizeBlock":                                          
+                return new PosterizeBlock("Posterize");                              
+            case "ArcTan2Block":                                          
+                return new ArcTan2Block("ArcTan2");                            
+            case "GradientBlock":                                          
+                return new GradientBlock("Gradient");                             
+            case "FrontFacingBlock":                                          
+                return new FrontFacingBlock("Front facing");            
+            case "CosBlock": {
+                let cosBlock = new TrigonometryBlock("Cos");
+                cosBlock.operation = TrigonometryBlockOperations.Cos;
+                return cosBlock;
+            }
+            case "SinBlock": {
+                let sinBlock = new TrigonometryBlock("Sin");
+                sinBlock.operation = TrigonometryBlockOperations.Sin;
+                return sinBlock;
+            }
+            case "AbsBlock": {
+                let absBlock = new TrigonometryBlock("Abs");
+                absBlock.operation = TrigonometryBlockOperations.Abs;
+                return absBlock;
+            }            
+            case "SqrtBlock": {
+                let sqrtBlock = new TrigonometryBlock("Sqrt");
+                sqrtBlock.operation = TrigonometryBlockOperations.Sqrt;
+                return sqrtBlock;
+            }
+            case "ArcCosBlock": {
+                let acosBlock = new TrigonometryBlock("ArcCos");
+                acosBlock.operation = TrigonometryBlockOperations.ArcCos;
+                return acosBlock;
+            }
+            case "ArcSinBlock": {
+                let asinBlock = new TrigonometryBlock("ArcSin");
+                asinBlock.operation = TrigonometryBlockOperations.ArcSin;
+                return asinBlock;
+            }
+            case "TanBlock": {
+                let tanBlock = new TrigonometryBlock("Tan");
+                tanBlock.operation = TrigonometryBlockOperations.Tan;
+                return tanBlock;
+            }
+            case "ArcTanBlock": {
+                let atanBlock = new TrigonometryBlock("ArcTan");
+                atanBlock.operation = TrigonometryBlockOperations.ArcTan;
+                return atanBlock;
+            }
+            case "FractBlock": {
+                let fractBlock = new TrigonometryBlock("Fract");
+                fractBlock.operation = TrigonometryBlockOperations.Fract;
+                return fractBlock;
+            }
+            case "SignBlock": {
+                let signBlock = new TrigonometryBlock("Sign");
+                signBlock.operation = TrigonometryBlockOperations.Sign;
+                return signBlock;
+            }            
+            case "LogBlock": {
+                let logBlock = new TrigonometryBlock("Log");
+                logBlock.operation = TrigonometryBlockOperations.Log;
+                return logBlock;
+            }                                                            
+            case "ExpBlock": {
+                let expBlock = new TrigonometryBlock("Exp");
+                expBlock.operation = TrigonometryBlockOperations.Exp;
+                return expBlock;
+            }
+            case "Exp2Block": {
+                let exp2Block = new TrigonometryBlock("Exp2");
+                exp2Block.operation = TrigonometryBlockOperations.Exp2;
+                return exp2Block;
+            }
+            case "DegreesToRadiansBlock": {
+                let degreesToRadiansBlock = new TrigonometryBlock("Degrees to radians");
+                degreesToRadiansBlock.operation = TrigonometryBlockOperations.Radians;
+                return degreesToRadiansBlock;
+            }
+            case "RadiansToDegreesBlock": {
+                let radiansToDegreesBlock = new TrigonometryBlock("Radians to degrees");
+                radiansToDegreesBlock.operation = TrigonometryBlockOperations.Degrees;
+                return radiansToDegreesBlock;
+            }                        
+            case "RoundBlock": {
+                let roundBlock = new TrigonometryBlock("Round");
+                roundBlock.operation = TrigonometryBlockOperations.Round;
+                return roundBlock;
+            }
+            case "CeilingBlock": {
+                let ceilingBlock = new TrigonometryBlock("Ceiling");
+                ceilingBlock.operation = TrigonometryBlockOperations.Ceiling;
+                return ceilingBlock;
+            }     
+            case "FloorBlock": {
+                let floorBlock = new TrigonometryBlock("Floor");
+                floorBlock.operation = TrigonometryBlockOperations.Floor;
+                return floorBlock;
+            }       
+            case "SawToothWaveBlock": {
+                let sawToothWaveBlock = new WaveBlock("SawTooth wave");
+                sawToothWaveBlock.kind = WaveBlockKind.SawTooth;
+                return sawToothWaveBlock;
+            }     
+            case "SquareWaveBlock": {
+                let squareWaveBlock = new WaveBlock("Square wave");
+                squareWaveBlock.kind = WaveBlockKind.Square;
+                return squareWaveBlock;
+            }     
+            case "TriangleWaveBlock": {
+                let triangleWaveBlock = new WaveBlock("Triangle wave");
+                triangleWaveBlock.kind = WaveBlockKind.Triangle;
+                return triangleWaveBlock;
+            }
+            case "WorldMatrixBlock": {
+                let worldMatrixBlock = new InputBlock("World");
+                worldMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.World);
+                return worldMatrixBlock;
+            }             
+            case "WorldViewMatrixBlock": {
+                let worldViewMatrixBlock = new InputBlock("World x View");
+                worldViewMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.WorldView);
+                return worldViewMatrixBlock;
+            }             
+            case "WorldViewProjectionMatrixBlock": {
+                let worldViewProjectionMatrixBlock = new InputBlock("World x View x Projection");
+                worldViewProjectionMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.WorldViewProjection);
+                return worldViewProjectionMatrixBlock;
+            }                    
+            case "ViewMatrixBlock": {
+                let viewMatrixBlock = new InputBlock("View");
+                viewMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.View);
+                return viewMatrixBlock;
+            }                          
+            case "ViewProjectionMatrixBlock": {
+                let viewProjectionMatrixBlock = new InputBlock("View x Projection");
+                viewProjectionMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.ViewProjection);
+                return viewProjectionMatrixBlock;
+            }                              
+            case "ProjectionMatrixBlock": {
+                let projectionMatrixBlock = new InputBlock("Projection");
+                projectionMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.Projection);
+                return projectionMatrixBlock;
+            }                                 
+            case "CameraPositionBlock": {
+                let cameraPosition = new InputBlock("Camera position");
+                cameraPosition.setAsSystemValue(NodeMaterialSystemValues.CameraPosition);
+                return cameraPosition;
+            }                              
+            case "FogColorBlock": {
+                let FogColor = new InputBlock("Fog color");
+                FogColor.setAsSystemValue(NodeMaterialSystemValues.FogColor);
+                return FogColor;
+            }                                   
+            case "PositionBlock": {
+                let meshPosition = new InputBlock("position");
+                meshPosition.setAsAttribute("position");
+                return meshPosition;
+            }                                        
+            case "UVBlock": {
+                let meshUV = new InputBlock("uv");
+                meshUV.setAsAttribute("uv");
+                return meshUV;
+            }                                         
+            case "ColorBlock": {
+                let meshColor = new InputBlock("color");
+                meshColor.setAsAttribute("color");
+                return meshColor;
+            }                                              
+            case "NormalBlock": {
+                let meshNormal = new InputBlock("normal");
+                meshNormal.setAsAttribute("normal");
+                return meshNormal;
+            }                                                 
+            case "TangentBlock": {
+                let meshTangent = new InputBlock("tangent");
+                meshTangent.setAsAttribute("tangent");
+                return meshTangent;
+            }                                                  
+            case "MatrixIndicesBlock": {
+                let meshMatrixIndices = new InputBlock("matricesIndices");
+                meshMatrixIndices.setAsAttribute("matricesIndices");
+                return meshMatrixIndices;
+            }                                                    
+            case "MatrixWeightsBlock": {
+                let meshMatrixWeights = new InputBlock("matricesWeights");
+                meshMatrixWeights.setAsAttribute("matricesWeights");
+                return meshMatrixWeights;
+            }                                                     
+            case "TimeBlock": {
+                let timeBlock = new InputBlock("Time", undefined, NodeMaterialBlockConnectionPointTypes.Float);
+                timeBlock.animationType = AnimatedInputBlockTypes.Time;
+                return timeBlock;
+            }   
+            case "DeltaTimeBlock": {
+                let deltaTimeBlock = new InputBlock("Delta time");                
+                deltaTimeBlock.setAsSystemValue(NodeMaterialSystemValues.DeltaTime);
+                return deltaTimeBlock;
+            }      
+            case "WorldPositionBlock": {
+                let worldPositionBlock = nodeMaterial.getInputBlockByPredicate(b => b.isAttribute && b.name === "position");                
+                if (!worldPositionBlock) {
+                    worldPositionBlock = new InputBlock("position");
+                    worldPositionBlock.setAsAttribute("position");
+                }
+
+                let worldMatrixBlock = nodeMaterial.getInputBlockByPredicate(b => b.isSystemValue && b.systemValue === NodeMaterialSystemValues.World);  
+
+                if (!worldMatrixBlock) {
+                    worldMatrixBlock = new InputBlock("World");
+                    worldMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.World);
+                }
+
+                let transformBlock = new TransformBlock("World position");
+                worldPositionBlock.connectTo(transformBlock);
+                worldMatrixBlock.connectTo(transformBlock);
+
+                return transformBlock;
+            }        
+            case "WorldNormalBlock": {
+                let worldNormalBlock = nodeMaterial.getInputBlockByPredicate(b => b.isAttribute && b.name === "normal");                
+                if (!worldNormalBlock) {
+                    worldNormalBlock = new InputBlock("normal");
+                    worldNormalBlock.setAsAttribute("normal");
+                }
+
+                let worldMatrixBlock = nodeMaterial.getInputBlockByPredicate(b => b.isSystemValue && b.systemValue === NodeMaterialSystemValues.World);  
+
+                if (!worldMatrixBlock) {
+                    worldMatrixBlock = new InputBlock("World");
+                    worldMatrixBlock.setAsSystemValue(NodeMaterialSystemValues.World);
+                }
+
+                let transformBlock = new TransformBlock("World normal");
+                worldNormalBlock.connectTo(transformBlock);
+                worldMatrixBlock.connectTo(transformBlock);
+
+                return transformBlock;
+            }                  
+        }
+
+        return null;
+    }
+
+    public static GetColorFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes) {
+        let color = "Red";
+        switch (type) {
+            case NodeMaterialBlockConnectionPointTypes.Float:
+				color = "#cb9e27";
+                break;
+            case NodeMaterialBlockConnectionPointTypes.Vector2:                
+				color = "#16bcb1";
+                break;
+            case NodeMaterialBlockConnectionPointTypes.Vector3:                
+            case NodeMaterialBlockConnectionPointTypes.Color3:                
+                color = "#b786cb";
+                break;
+            case NodeMaterialBlockConnectionPointTypes.Vector4:                
+            case NodeMaterialBlockConnectionPointTypes.Color4:                
+				color = "#be5126";
+                break;
+            case NodeMaterialBlockConnectionPointTypes.Matrix:                
+				color = "#591990";
+                break;
+        }
+
+        return color;
+    }
+
+    public static GetConnectionNodeTypeFromString(type: string) {
+        switch (type) {
+            case "Float":
+                return NodeMaterialBlockConnectionPointTypes.Float;
+            case "Vector2":
+                return NodeMaterialBlockConnectionPointTypes.Vector2;
+            case "Vector3":
+                return NodeMaterialBlockConnectionPointTypes.Vector3;
+            case "Vector4":
+                return NodeMaterialBlockConnectionPointTypes.Vector4;
+            case "Matrix":
+                return NodeMaterialBlockConnectionPointTypes.Matrix;
+            case "Color3":
+                return NodeMaterialBlockConnectionPointTypes.Color3;
+            case "Color4":
+                return NodeMaterialBlockConnectionPointTypes.Color4;
+        }
+
+        return NodeMaterialBlockConnectionPointTypes.AutoDetect;
+    }
+
+    public static GetStringFromConnectionNodeType(type: NodeMaterialBlockConnectionPointTypes) {
+        switch (type){
+            case NodeMaterialBlockConnectionPointTypes.Float:
+                return "Float";
+            case NodeMaterialBlockConnectionPointTypes.Vector2:
+                return "Vector2";
+            case NodeMaterialBlockConnectionPointTypes.Vector3:
+                return "Vector3";
+            case NodeMaterialBlockConnectionPointTypes.Vector4:
+                return "Vector4";
+            case NodeMaterialBlockConnectionPointTypes.Color3:
+                return "Color3";
+            case NodeMaterialBlockConnectionPointTypes.Color4:
+                return "Color4";
+            case NodeMaterialBlockConnectionPointTypes.Matrix:
+                return "Matrix";
+        }
+
+        return "";
+    }
 }

nodeEditor/src/components/diagram/generic/genericNodeModel.tsx

@@ -71,7 +71,13 @@ export class GenericNodeModel extends DefaultNodeModel {
                     <CheckBoxLineComponent label="Invert X axis" target={this.block} propertyName="invertX" onValueChanged={() => globalState.onRebuildRequiredObservable.notifyObservers()} />
                     <CheckBoxLineComponent label="Invert Y axis" target={this.block} propertyName="invertY" onValueChanged={() => globalState.onRebuildRequiredObservable.notifyObservers()}/>                    
                 </LineContainerComponent>
-            }               
+            }
+            {
+                this.block!.getClassName() === "WorleyNoise3DBlock" &&
+                <LineContainerComponent title="PROPERTIES">
+                    <CheckBoxLineComponent label="Use Manhattan Distance" target={this.block} propertyName="manhattanDistance" onValueChanged={() => globalState.onRebuildRequiredObservable.notifyObservers()} />              
+                </LineContainerComponent>
+            }
             </div>
         );
     }

nodeEditor/src/components/nodeList/nodeListComponent.tsx

@@ -33,7 +33,7 @@ export class NodeListComponent extends React.Component<INodeListComponentProps,
             Interpolation: ["LerpBlock", "SmoothStepBlock", "NLerpBlock"],
             Matrices: ["Matrix", "WorldMatrixBlock", "WorldViewMatrixBlock", "WorldViewProjectionMatrixBlock", "ViewMatrixBlock", "ViewProjectionMatrixBlock", "ProjectionMatrixBlock"],
             Mesh: ["InstancesBlock", "PositionBlock", "UVBlock", "ColorBlock", "NormalBlock", "TangentBlock", "MatrixIndicesBlock", "MatrixWeightsBlock", "WorldPositionBlock", "WorldNormalBlock", "FrontFacingBlock"], 
-            Noises: ["SimplexPerlin3DBlock"],
+            Noises: ["SimplexPerlin3DBlock", "WorleyNoise3DBlock"],
             Output_Blocks: ["VertexOutputBlock", "FragmentOutputBlock", "DiscardBlock"],
             Range: ["ClampBlock", "RemapBlock", "NormalizeBlock"],
             Round: ["StepBlock", "RoundBlock", "CeilingBlock", "FloorBlock"],

src/Materials/Node/Blocks/index.ts

@@ -1,41 +1,42 @@
-export * from "./Vertex/index";
-export * from "./Fragment/index";
-export * from "./Dual/index";
-export * from "./Input/index";
-export * from "./multiplyBlock";
-export * from "./addBlock";
-export * from "./scaleBlock";
-export * from "./clampBlock";
-export * from "./crossBlock";
-export * from "./dotBlock";
-export * from "./transformBlock";
-export * from "./remapBlock";
-export * from "./normalizeBlock";
-export * from "./trigonometryBlock";
-export * from "./colorMergerBlock";
-export * from "./vectorMergerBlock";
-export * from "./colorSplitterBlock";
-export * from "./vectorSplitterBlock";
-export * from "./lerpBlock";
-export * from "./divideBlock";
-export * from "./subtractBlock";
-export * from "./stepBlock";
-export * from "./oneMinusBlock";
-export * from "./viewDirectionBlock";
-export * from "./fresnelBlock";
-export * from "./maxBlock";
-export * from "./minBlock";
-export * from "./distanceBlock";
-export * from "./lengthBlock";
-export * from "./negateBlock";
-export * from "./powBlock";
-export * from "./randomNumberBlock";
-export * from "./arcTan2Block";
-export * from "./smoothStepBlock";
-export * from "./reciprocalBlock";
-export * from "./replaceColorBlock";
-export * from "./posterizeBlock";
-export * from "./waveBlock";
-export * from "./gradientBlock";
-export * from "./nLerpBlock";
-export * from "./simplexPerlin3DBlock";
+export * from "./Vertex/index";
+export * from "./Fragment/index";
+export * from "./Dual/index";
+export * from "./Input/index";
+export * from "./multiplyBlock";
+export * from "./addBlock";
+export * from "./scaleBlock";
+export * from "./clampBlock";
+export * from "./crossBlock";
+export * from "./dotBlock";
+export * from "./transformBlock";
+export * from "./remapBlock";
+export * from "./normalizeBlock";
+export * from "./trigonometryBlock";
+export * from "./colorMergerBlock";
+export * from "./vectorMergerBlock";
+export * from "./colorSplitterBlock";
+export * from "./vectorSplitterBlock";
+export * from "./lerpBlock";
+export * from "./divideBlock";
+export * from "./subtractBlock";
+export * from "./stepBlock";
+export * from "./oneMinusBlock";
+export * from "./viewDirectionBlock";
+export * from "./fresnelBlock";
+export * from "./maxBlock";
+export * from "./minBlock";
+export * from "./distanceBlock";
+export * from "./lengthBlock";
+export * from "./negateBlock";
+export * from "./powBlock";
+export * from "./randomNumberBlock";
+export * from "./arcTan2Block";
+export * from "./smoothStepBlock";
+export * from "./reciprocalBlock";
+export * from "./replaceColorBlock";
+export * from "./posterizeBlock";
+export * from "./waveBlock";
+export * from "./gradientBlock";
+export * from "./nLerpBlock";
+export * from "./worleyNoise3DBlock";
+export * from "./simplexPerlin3DBlock";

src/Materials/Node/Blocks/worleyNoise3DBlock.ts

@@ -0,0 +1,260 @@
+import { NodeMaterialBlock } from '../nodeMaterialBlock';
+import { NodeMaterialBlockConnectionPointTypes } from '../Enums/nodeMaterialBlockConnectionPointTypes';
+import { NodeMaterialBuildState } from '../nodeMaterialBuildState';
+import { NodeMaterialConnectionPoint } from '../nodeMaterialBlockConnectionPoint';
+import { NodeMaterialBlockTargets } from '../Enums/nodeMaterialBlockTargets';
+import { _TypeStore } from '../../../Misc/typeStore';
+import { Scene } from '../../../scene';
+
+/**
+ * block used to Generate a Worley Noise 3D Noise Pattern
+ */
+
+//  Source: https://github.com/Erkaman/glsl-worley
+//  Converted to BJS by Pryme8
+//
+//  Worley Noise 3D
+//  Return vec2 value range of -1.0->1.0, F1-F2 respectivly
+
+export class WorleyNoise3DBlock extends NodeMaterialBlock {
+    /** Gets or sets a boolean indicating that normal should be inverted on X axis */
+    public manhattanDistance = false;
+
+    /**
+     * Creates a new WorleyNoise3DBlock
+     * @param name defines the block name
+     */
+    public constructor(name: string) {
+        super(name, NodeMaterialBlockTargets.Neutral);
+        this.registerInput("position", NodeMaterialBlockConnectionPointTypes.Vector3);
+        this.registerInput("jitter", NodeMaterialBlockConnectionPointTypes.Float);
+
+        this.registerOutput("output", NodeMaterialBlockConnectionPointTypes.Vector2);
+    }
+
+    /**
+     * Gets the current class name
+     * @returns the class name
+     */
+    public getClassName() {
+        return "WorleyNoise3DBlock";
+    }
+
+    /**
+     * Gets the position input component
+     */
+    public get position(): NodeMaterialConnectionPoint {
+        return this._inputs[0];
+    }
+
+    /**
+     * Gets the jitter input component
+     */
+    public get jitter(): NodeMaterialConnectionPoint {
+        return this._inputs[1];
+    }
+
+    /**
+     * Gets the output component
+     */
+    public get output(): NodeMaterialConnectionPoint {
+        return this._outputs[0];
+    }
+
+    protected _buildBlock(state: NodeMaterialBuildState) {
+        super._buildBlock(state);
+
+        if (!this.position.isConnected) {
+            return;
+        }
+
+        if (!this._outputs[0].hasEndpoints) {
+            return;
+        }
+
+        let functionString = `vec3 permute(vec3 x){\r\n`;
+        functionString += `    return mod((34.0 * x + 1.0) * x, 289.0);\r\n`;
+        functionString += `}\r\n\r\n`;
+
+        functionString += `vec3 dist(vec3 x, vec3 y, vec3 z,  bool manhattanDistance){\r\n`;
+        functionString += `    return manhattanDistance ?  abs(x) + abs(y) + abs(z) :  (x * x + y * y + z * z);\r\n`;
+        functionString += `}\r\n\r\n`;
+
+        functionString += `vec2 worley(vec3 P, float jitter, bool manhattanDistance){\r\n`;
+        functionString += `    float K = 0.142857142857; // 1/7\r\n`;
+        functionString += `    float Ko = 0.428571428571; // 1/2-K/2\r\n`;
+        functionString += `    float  K2 = 0.020408163265306; // 1/(7*7)\r\n`;
+        functionString += `    float Kz = 0.166666666667; // 1/6\r\n`;
+        functionString += `    float Kzo = 0.416666666667; // 1/2-1/6*2\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 Pi = mod(floor(P), 289.0);\r\n`;
+        functionString += `    vec3 Pf = fract(P) - 0.5;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 Pfx = Pf.x + vec3(1.0, 0.0, -1.0);\r\n`;
+        functionString += `    vec3 Pfy = Pf.y + vec3(1.0, 0.0, -1.0);\r\n`;
+        functionString += `    vec3 Pfz = Pf.z + vec3(1.0, 0.0, -1.0);\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 p = permute(Pi.x + vec3(-1.0, 0.0, 1.0));\r\n`;
+        functionString += `    vec3 p1 = permute(p + Pi.y - 1.0);\r\n`;
+        functionString += `    vec3 p2 = permute(p + Pi.y);\r\n`;
+        functionString += `    vec3 p3 = permute(p + Pi.y + 1.0);\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 p11 = permute(p1 + Pi.z - 1.0);\r\n`;
+        functionString += `    vec3 p12 = permute(p1 + Pi.z);\r\n`;
+        functionString += `    vec3 p13 = permute(p1 + Pi.z + 1.0);\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 p21 = permute(p2 + Pi.z - 1.0);\r\n`;
+        functionString += `    vec3 p22 = permute(p2 + Pi.z);\r\n`;
+        functionString += `    vec3 p23 = permute(p2 + Pi.z + 1.0);\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 p31 = permute(p3 + Pi.z - 1.0);\r\n`;
+        functionString += `    vec3 p32 = permute(p3 + Pi.z);\r\n`;
+        functionString += `    vec3 p33 = permute(p3 + Pi.z + 1.0);\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox11 = fract(p11*K) - Ko;\r\n`;
+        functionString += `    vec3 oy11 = mod(floor(p11*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz11 = floor(p11*K2)*Kz - Kzo; // p11 < 289 guaranteed\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox12 = fract(p12*K) - Ko;\r\n`;
+        functionString += `    vec3 oy12 = mod(floor(p12*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz12 = floor(p12*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox13 = fract(p13*K) - Ko;\r\n`;
+        functionString += `    vec3 oy13 = mod(floor(p13*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz13 = floor(p13*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox21 = fract(p21*K) - Ko;\r\n`;
+        functionString += `    vec3 oy21 = mod(floor(p21*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz21 = floor(p21*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox22 = fract(p22*K) - Ko;\r\n`;
+        functionString += `    vec3 oy22 = mod(floor(p22*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz22 = floor(p22*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox23 = fract(p23*K) - Ko;\r\n`;
+        functionString += `    vec3 oy23 = mod(floor(p23*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz23 = floor(p23*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox31 = fract(p31*K) - Ko;\r\n`;
+        functionString += `    vec3 oy31 = mod(floor(p31*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz31 = floor(p31*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox32 = fract(p32*K) - Ko;\r\n`;
+        functionString += `    vec3 oy32 = mod(floor(p32*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz32 = floor(p32*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 ox33 = fract(p33*K) - Ko;\r\n`;
+        functionString += `    vec3 oy33 = mod(floor(p33*K), 7.0)*K - Ko;\r\n`;
+        functionString += `    vec3 oz33 = floor(p33*K2)*Kz - Kzo;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx11 = Pfx + jitter*ox11;\r\n`;
+        functionString += `    vec3 dy11 = Pfy.x + jitter*oy11;\r\n`;
+        functionString += `    vec3 dz11 = Pfz.x + jitter*oz11;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx12 = Pfx + jitter*ox12;\r\n`;
+        functionString += `    vec3 dy12 = Pfy.x + jitter*oy12;\r\n`;
+        functionString += `    vec3 dz12 = Pfz.y + jitter*oz12;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx13 = Pfx + jitter*ox13;\r\n`;
+        functionString += `    vec3 dy13 = Pfy.x + jitter*oy13;\r\n`;
+        functionString += `    vec3 dz13 = Pfz.z + jitter*oz13;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx21 = Pfx + jitter*ox21;\r\n`;
+        functionString += `    vec3 dy21 = Pfy.y + jitter*oy21;\r\n`;
+        functionString += `    vec3 dz21 = Pfz.x + jitter*oz21;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx22 = Pfx + jitter*ox22;\r\n`;
+        functionString += `    vec3 dy22 = Pfy.y + jitter*oy22;\r\n`;
+        functionString += `    vec3 dz22 = Pfz.y + jitter*oz22;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx23 = Pfx + jitter*ox23;\r\n`;
+        functionString += `    vec3 dy23 = Pfy.y + jitter*oy23;\r\n`;
+        functionString += `    vec3 dz23 = Pfz.z + jitter*oz23;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx31 = Pfx + jitter*ox31;\r\n`;
+        functionString += `    vec3 dy31 = Pfy.z + jitter*oy31;\r\n`;
+        functionString += `    vec3 dz31 = Pfz.x + jitter*oz31;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx32 = Pfx + jitter*ox32;\r\n`;
+        functionString += `    vec3 dy32 = Pfy.z + jitter*oy32;\r\n`;
+        functionString += `    vec3 dz32 = Pfz.y + jitter*oz32;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 dx33 = Pfx + jitter*ox33;\r\n`;
+        functionString += `    vec3 dy33 = Pfy.z + jitter*oy33;\r\n`;
+        functionString += `    vec3 dz33 = Pfz.z + jitter*oz33;\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 d11 = dist(dx11, dy11, dz11, manhattanDistance);\r\n`;
+        functionString += `    vec3 d12 =dist(dx12, dy12, dz12, manhattanDistance);\r\n`;
+        functionString += `    vec3 d13 = dist(dx13, dy13, dz13, manhattanDistance);\r\n`;
+        functionString += `    vec3 d21 = dist(dx21, dy21, dz21, manhattanDistance);\r\n`;
+        functionString += `    vec3 d22 = dist(dx22, dy22, dz22, manhattanDistance);\r\n`;
+        functionString += `    vec3 d23 = dist(dx23, dy23, dz23, manhattanDistance);\r\n`;
+        functionString += `    vec3 d31 = dist(dx31, dy31, dz31, manhattanDistance);\r\n`;
+        functionString += `    vec3 d32 = dist(dx32, dy32, dz32, manhattanDistance);\r\n`;
+        functionString += `    vec3 d33 = dist(dx33, dy33, dz33, manhattanDistance);\r\n`;
+        functionString += `\r\n`;
+        functionString += `    vec3 d1a = min(d11, d12);\r\n`;
+        functionString += `    d12 = max(d11, d12);\r\n`;
+        functionString += `    d11 = min(d1a, d13); // Smallest now not in d12 or d13\r\n`;
+        functionString += `    d13 = max(d1a, d13);\r\n`;
+        functionString += `    d12 = min(d12, d13); // 2nd smallest now not in d13\r\n`;
+        functionString += `    vec3 d2a = min(d21, d22);\r\n`;
+        functionString += `    d22 = max(d21, d22);\r\n`;
+        functionString += `    d21 = min(d2a, d23); // Smallest now not in d22 or d23\r\n`;
+        functionString += `    d23 = max(d2a, d23);\r\n`;
+        functionString += `    d22 = min(d22, d23); // 2nd smallest now not in d23\r\n`;
+        functionString += `    vec3 d3a = min(d31, d32);\r\n`;
+        functionString += `    d32 = max(d31, d32);\r\n`;
+        functionString += `    d31 = min(d3a, d33); // Smallest now not in d32 or d33\r\n`;
+        functionString += `    d33 = max(d3a, d33);\r\n`;
+        functionString += `    d32 = min(d32, d33); // 2nd smallest now not in d33\r\n`;
+        functionString += `    vec3 da = min(d11, d21);\r\n`;
+        functionString += `    d21 = max(d11, d21);\r\n`;
+        functionString += `    d11 = min(da, d31); // Smallest now in d11\r\n`;
+        functionString += `    d31 = max(da, d31); // 2nd smallest now not in d31\r\n`;
+        functionString += `    d11.xy = (d11.x < d11.y) ? d11.xy : d11.yx;\r\n`;
+        functionString += `    d11.xz = (d11.x < d11.z) ? d11.xz : d11.zx; // d11.x now smallest\r\n`;
+        functionString += `    d12 = min(d12, d21); // 2nd smallest now not in d21\r\n`;
+        functionString += `    d12 = min(d12, d22); // nor in d22\r\n`;
+        functionString += `    d12 = min(d12, d31); // nor in d31\r\n`;
+        functionString += `    d12 = min(d12, d32); // nor in d32\r\n`;
+        functionString += `    d11.yz = min(d11.yz,d12.xy); // nor in d12.yz\r\n`;
+        functionString += `    d11.y = min(d11.y,d12.z); // Only two more to go\r\n`;
+        functionString += `    d11.y = min(d11.y,d11.z); // Done! (Phew!)\r\n`;
+        functionString += `    return sqrt(d11.xy); // F1, F2\r\n`;
+        functionString += `}\r\n\r\n`;
+
+        state._emitFunction('worley3D', functionString, 'worley3D');
+        state.compilationString += this._declareOutput(this._outputs[0], state) + ` = worley(${this.position.associatedVariableName}, ${this.jitter.associatedVariableName}, ${this.manhattanDistance});\r\n`;
+
+        return this;
+    }
+    /**
+     * Exposes the properties to the UI?
+     */
+    protected _dumpPropertiesCode() {
+        var codeString = `${this._codeVariableName}.manhattanDistance = ${this.manhattanDistance};\r\n`;
+
+        return codeString;
+    }
+    /**
+     * Exposes the properties to the Seralize?
+     */
+    public serialize(): any {
+        let serializationObject = super.serialize();
+
+        serializationObject.manhattanDistance = this.manhattanDistance;
+
+        return serializationObject;
+    }
+    /**
+     * Exposes the properties to the deseralize?
+     */
+    public _deserialize(serializationObject: any, scene: Scene, rootUrl: string) {
+        super._deserialize(serializationObject, scene, rootUrl);
+
+        this.manhattanDistance = serializationObject.manhattanDistance;
+    }
+}
+
+_TypeStore.RegisteredTypes["BABYLON.WorleyNoise3DBlock"] = WorleyNoise3DBlock;