mid commenting

dist/preview release/typedocValidationBaseline.json

@@ -4774,20 +4774,6 @@
         }
       }
     },
-    "BlurPostProcess": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Property": {
-        "direction": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      }
-    },
     "Bone": {
       "Class": {
         "Comments": {
@@ -8912,178 +8898,6 @@
         }
       }
     },
-    "DefaultRenderingPipeline": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Property": {
-        "BlurXPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "BlurYPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "CopyBackPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "FinalMergePostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "FxaaPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "HighLightsPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "ImageProcessingPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "PassPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "animations": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "bloomEnabled": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "bloomScale": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "bloomWeight": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "blurX": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "blurY": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "copyBack": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "finalMerge": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "fxaa": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "fxaaEnabled": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "highlights": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "imageProcessing": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "imageProcessingEnabled": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "pass": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "serialize": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "Parse": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "source": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "rootUrl": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
     "DepthRenderer": {
       "Class": {
         "Comments": {
@@ -25995,433 +25809,6 @@
         }
       }
     },
-    "PostProcess": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Constructor": {
-        "new PostProcess": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "name": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "fragmentUrl": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "parameters": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "samplers": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "options": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "camera": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "samplingMode": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "engine": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "reusable": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "defines": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "textureType": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "vertexUrl": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "indexParameters": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "blockCompilation": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Property": {
-        "_currentRenderTextureInd": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_textures": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "adaptScaleToCurrentViewport": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "alphaConstants": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "alphaMode": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "alwaysForcePOT": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "animations": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "aspectRatio": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "autoClear": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "clearColor": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "enablePixelPerfectMode": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "height": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "isSupported": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "name": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onActivate": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onAfterRender": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onApply": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onBeforeRender": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onSizeChanged": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "outputTexture": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "renderTargetSamplingMode": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "samples": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "scaleMode": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "texelSize": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "width": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "activate": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "camera": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "sourceTexture": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "forceDepthStencil": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "apply": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "dispose": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "camera": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getCamera": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getEffect": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "getEngine": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "isReusable": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "shareOutputWith": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "postProcess": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "updateEffect": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "defines": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "uniforms": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "samplers": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "indexParameters": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "onCompiled": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "onError": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
-    "PostProcessManager": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Constructor": {
-        "new PostProcessManager": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "scene": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Method": {
-        "_finalizeFrame": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "doNotPresent": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "targetTexture": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "faceIndex": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "postProcesses": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "forceFullscreenViewport": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_prepareFrame": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "sourceTexture": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "postProcesses": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_rebuild": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "directRender": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "postProcesses": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "targetTexture": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "forceFullscreenViewport": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "dispose": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      }
-    },
     "PostProcessRenderPipeline": {
       "Class": {
         "Comments": {

src/PostProcess/RenderPipeline/Pipelines/babylon.defaultRenderingPipeline.ts

@@ -1,31 +1,85 @@
 module BABYLON {
+    /**
+	 * The default rendering pipeline can be added to a scene to apply common post processing effects such as anti-aliasing or depth of field.
+     * See https://doc.babylonjs.com/how_to/using_default_rendering_pipeline
+     */
     export class DefaultRenderingPipeline extends PostProcessRenderPipeline implements IDisposable, IAnimatable {
         private _scene: Scene;
 
+        /**
+		 * ID of the pass post process used for bloom,
+		 */
         readonly PassPostProcessId: string = "PassPostProcessEffect";
+        /**
+		 * ID of the highlight post process used for bloom,
+		 */
         readonly HighLightsPostProcessId: string = "HighLightsPostProcessEffect";
+        /**
+		 * ID of the blurX post process used for bloom,
+		 */
         readonly BlurXPostProcessId: string = "BlurXPostProcessEffect";
+        /**
+		 * ID of the blurY post process used for bloom,
+		 */
         readonly BlurYPostProcessId: string = "BlurYPostProcessEffect";
+        /**
+		 * ID of the copy back post process used for bloom,
+		 */
         readonly CopyBackPostProcessId: string = "CopyBackPostProcessEffect";
+        /**
+		 * ID of the image processing post process;
+		 */
         readonly ImageProcessingPostProcessId: string = "ImageProcessingPostProcessEffect";
+        /**
+		 * ID of the Fast Approximate Anti-Aliasing post process;
+		 */
         readonly FxaaPostProcessId: string = "FxaaPostProcessEffect";
+        /**
+		 * ID of the final merge post process;
+		 */
         readonly FinalMergePostProcessId: string = "FinalMergePostProcessEffect";
 
         // Post-processes
+        /**
+		 * First pass of bloom to capture the original image texture for later use.
+		 */
         public pass: PassPostProcess;
+        /**
+		 * Second pass of bloom used to brighten bright portions of the image.
+		 */
         public highlights: HighlightsPostProcess;
+        /**
+		 * BlurX post process used in coordination with blurY to guassian blur the highlighted image.
+		 */
         public blurX: BlurPostProcess;
+        /**
+		 * BlurY post process used in coordination with blurX to guassian blur the highlighted image.
+		 */
         public blurY: BlurPostProcess;
+        /**
+		 * Final pass run for bloom to copy the resulting bloom texture back to screen.
+		 */
         public copyBack: PassPostProcess;
         /**
          * Depth of field effect, applies a blur based on how far away objects are from the focus distance.
          */
         public depthOfField: DepthOfFieldEffect;
+        /**
+         * The Fast Approximate Anti-Aliasing post process which attemps to remove aliasing from an image.
+         */
         public fxaa: FxaaPostProcess;
+        /**
+         * Image post processing pass used to perform operations such as tone mapping or color grading.
+         */
         public imageProcessing: ImageProcessingPostProcess;
+        /**
+         * Final post process to merge results of all previous passes
+         */
         public finalMerge: PassPostProcess;
 
-        // IAnimatable
+        /**
+         * Animations which can be used to tweak settings over a period of time
+         */
         public animations: Animation[] = [];
 
         // Values       
@@ -53,6 +107,9 @@
         @serialize()
         private _hdr: boolean;
 
+        /**
+         * The strength of the bloom.
+         */
         public set bloomWeight(value: number) {
             if (this._bloomWeight === value) {
                 return;
@@ -69,6 +126,9 @@
             return this._bloomWeight;
         }
 
+        /**
+         * The scale of the bloom, lower value will provide better performance.
+         */
         public set bloomScale(value: number) {
             if (this._bloomScale === value) {
                 return;
@@ -83,6 +143,9 @@
             return this._bloomScale;
         }
 
+        /**
+         * Enable or disable the bloom from the pipeline
+         */
         public set bloomEnabled(enabled: boolean) {
             if (this._bloomEnabled === enabled) {
                 return;
@@ -114,6 +177,9 @@
             this._buildPipeline();
         }
 
+        /**
+         * If the anti aliasing is enabled.
+         */
         public set fxaaEnabled(enabled: boolean) {
             if (this._fxaaEnabled === enabled) {
                 return;
@@ -128,6 +194,9 @@
             return this._fxaaEnabled;
         }
 
+        /**
+         * If image processing is enabled.
+         */
         public set imageProcessingEnabled(enabled: boolean) {
             if (this._imageProcessingEnabled === enabled) {
                 return;

src/PostProcess/babylon.blurPostProcess.ts

@@ -1,4 +1,8 @@
 module BABYLON {
+	/**
+	 * 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.
+     */
     export class BlurPostProcess extends PostProcess {
 		protected _kernel: number;
 		protected _idealKernel: number;
@@ -43,7 +47,19 @@
 			return this._packedFloat;
 		}
 
-        constructor(name: string, public direction: Vector2, kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode: number = Texture.BILINEAR_SAMPLINGMODE, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT) {
+		/**
+         * Creates a new instance of @see BlurPostProcess
+         * @param name The name of the effect.
+         * @param direction The direction in which to blur the image.
+		 * @param kernel The size of the kernel to be used when computing the blur. eg. Size of 3 will blur the center pixel by 2 pixels surrounding it.
+         * @param options The required width/height ratio to downsize to before computing the render pass. (Use 1.0 for full size)
+         * @param camera The camera to apply the render pass to.
+         * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
+         * @param engine The engine which the post process will be applied. (default: current engine)
+         * @param reusable If the post process can be reused on the same frame. (default: false)
+         * @param textureType Type of textures used when performing the post process. (default: 0)
+         */
+        constructor(name: string, /*The direction in which to blur the image.*/public direction: Vector2, kernel: number, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode: number = Texture.BILINEAR_SAMPLINGMODE, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT) {
             super(name, "kernelBlur", ["delta", "direction", "cameraMinMaxZ"], ["depthSampler"], options, camera, samplingMode, engine, reusable, null, textureType, "kernelBlur", {varyingCount: 0, depCount: 0}, true);
 			
 			this.onApplyObservable.add((effect: Effect) => {

src/PostProcess/babylon.postProcess.ts

@@ -1,25 +1,67 @@
 module BABYLON {
     export type PostProcessOptions = { width: number, height: number };
 
+    /**
+	 * PostProcess can be used to apply a shader to a texture after it has been rendered
+     * See https://doc.babylonjs.com/how_to/how_to_use_postprocesses
+     */
     export class PostProcess {
+        /**
+        * Width of the texture to apply the post process on
+        */
         public width = -1;
+        /**
+        * Height of the texture to apply the post process on
+        */
         public height = -1;
+        /**
+        * Sampling mode used by the shader
+        * See https://doc.babylonjs.com/classes/3.1/texture
+        */
         public renderTargetSamplingMode: number;
+        /**
+        * Clear color to use when screen clearing
+        */
         public clearColor: Color4;
+        /**
+        * If the buffer needs to be cleared before applying the post process. (default: true)
+        * Should be set to false if shader will overwrite all previous pixels.
+        */
         public autoClear = true;
+        /**
+        * Type of alpha mode to use when performing the post process (default: Engine.ALPHA_DISABLE)
+        */
         public alphaMode = Engine.ALPHA_DISABLE;
+        /**
+        * Sets the setAlphaBlendConstants of the babylon engine
+        */
         public alphaConstants: Color4;
+        /**
+        * Animations to be used for the post processing 
+        */
         public animations = new Array<Animation>();
 
         /*
             Enable Pixel Perfect mode where texture is not scaled to be power of 2.
-            Can only be used on a single postprocess or on the last one of a chain.
+            Can only be used on a single postprocess or on the last one of a chain. (default: false)
         */
         public enablePixelPerfectMode = false;
 
+        /**
+        * Scale mode for the post process (default: Engine.SCALEMODE_FLOOR)
+        */
         public scaleMode = Engine.SCALEMODE_FLOOR;
+        /**
+        * Force textures to be a power of two (default: false)
+        */
         public alwaysForcePOT = false;
+        /**
+        * Number of sample textures (default: 1)
+        */
         public samples = 1;
+        /**
+        * Modify the scale of the post process to be the same as the viewport (default: false)
+        */
         public adaptScaleToCurrentViewport = false;
 
         private _camera: Camera;
@@ -50,6 +92,9 @@
         public onActivateObservable = new Observable<Camera>();
 
         private _onActivateObserver: Nullable<Observer<Camera>>;
+        /**
+        * A function that is added to the onActivateObservable
+        */
         public set onActivate(callback: Nullable<(camera: Camera) => void>) {
             if (this._onActivateObserver) {
                 this.onActivateObservable.remove(this._onActivateObserver);
@@ -66,6 +111,9 @@
         public onSizeChangedObservable = new Observable<PostProcess>();
 
         private _onSizeChangedObserver: Nullable<Observer<PostProcess>>;
+        /**
+        * A function that is added to the onSizeChangedObservable
+        */
         public set onSizeChanged(callback: (postProcess: PostProcess) => void) {
             if (this._onSizeChangedObserver) {
                 this.onSizeChangedObservable.remove(this._onSizeChangedObserver);
@@ -80,6 +128,9 @@
         public onApplyObservable = new Observable<Effect>();
 
         private _onApplyObserver: Nullable<Observer<Effect>>;
+        /**
+        * A function that is added to the onApplyObservable
+        */
         public set onApply(callback: (effect: Effect) => void) {
             if (this._onApplyObserver) {
                 this.onApplyObservable.remove(this._onApplyObserver);
@@ -94,6 +145,9 @@
         public onBeforeRenderObservable = new Observable<Effect>();
 
         private _onBeforeRenderObserver: Nullable<Observer<Effect>>;
+        /**
+        * A function that is added to the onBeforeRenderObservable
+        */
         public set onBeforeRender(callback: (effect: Effect) => void) {
             if (this._onBeforeRenderObserver) {
                 this.onBeforeRenderObservable.remove(this._onBeforeRenderObserver);
@@ -108,6 +162,9 @@
         public onAfterRenderObservable = new Observable<Effect>();
 
         private _onAfterRenderObserver: Nullable<Observer<Effect>>;
+        /**
+        * A function that is added to the onAfterRenderObservable
+        */
         public set onAfterRender(callback: (efect: Effect) => void) {
             if (this._onAfterRenderObserver) {
                 this.onAfterRenderObservable.remove(this._onAfterRenderObserver);
@@ -115,6 +172,9 @@
             this._onAfterRenderObserver = this.onAfterRenderObservable.add(callback);
         }
 
+        /**
+        * The resulting output of the post process.
+        */
         public get outputTexture(): InternalTexture {
             return this._textures.data[this._currentRenderTextureInd];
         }
@@ -123,10 +183,17 @@
             this._forcedOutputTexture = value;
         }
 
+        /**
+        * Gets the camera which post process is applied to
+        */
         public getCamera(): Camera {
             return this._camera;
         }
 
+        /**
+        * Gets the texel size of the postprocess
+        * See https://en.wikipedia.org/wiki/Texel_(graphics)
+        */
         public get texelSize(): Vector2 {
             if (this._shareOutputWithPostProcess) {
                 return this._shareOutputWithPostProcess.texelSize;