Nightly

proceduralTexturesLibrary/src/normalMap/normalMapProceduralTexture.ts

@@ -16,7 +16,7 @@ export class NormalMapProceduralTexture extends ProceduralTexture {
 
     public updateShaderUniforms() {
         this.setTexture("baseSampler", this._baseTexture);
-        this.setFloat("size", this.getRenderSize());
+        this.setFloat("size", this.getRenderSize() as number);
     }
 
     public render(useCameraPostProcess?: boolean) {

proceduralTexturesLibrary/src/perlinNoise/perlinNoiseProceduralTexture.ts

@@ -24,7 +24,7 @@ export class PerlinNoiseProceduralTexture extends ProceduralTexture {
     }
 
     public updateShaderUniforms() {
-        this.setFloat("size", this.getRenderSize());
+        this.setFloat("size", this.getRenderSize() as number);
 
         let scene = this.getScene();
 

src/Engines/Extensions/engine.renderTarget.ts

@@ -5,7 +5,13 @@ import { Constants } from '../constants';
 import { ThinEngine } from '../thinEngine';
 import { DepthTextureCreationOptions } from '../depthTextureCreationOptions';
 
+/**
+ * Type used to define a render target texture size (either with a number or with a rect width and height)
+ */
+export type RenderTargetTextureSize = number | { width: number, height: number, layers?: number };
+
 declare module "../../Engines/thinEngine" {
+
     export interface ThinEngine {
         /**
          * Creates a new render target texture
@@ -13,7 +19,7 @@ declare module "../../Engines/thinEngine" {
          * @param options defines the options used to create the texture
          * @returns a new render target texture stored in an InternalTexture
          */
-        createRenderTargetTexture(size: number | { width: number, height: number, layers?: number }, options: boolean | RenderTargetCreationOptions): InternalTexture;
+        createRenderTargetTexture(size: RenderTargetTextureSize, options: boolean | RenderTargetCreationOptions): InternalTexture;
 
         /**
          * Creates a depth stencil texture.
@@ -22,14 +28,14 @@ declare module "../../Engines/thinEngine" {
          * @param options The options defining the texture.
          * @returns The texture
          */
-        createDepthStencilTexture(size: number | { width: number, height: number, layers?: number }, options: DepthTextureCreationOptions): InternalTexture;
+        createDepthStencilTexture(size: RenderTargetTextureSize, options: DepthTextureCreationOptions): InternalTexture;
 
         /** @hidden */
-        _createDepthStencilTexture(size: number | { width: number, height: number, layers?: number }, options: DepthTextureCreationOptions): InternalTexture;
+        _createDepthStencilTexture(size: RenderTargetTextureSize, options: DepthTextureCreationOptions): InternalTexture;
     }
 }
 
-ThinEngine.prototype.createRenderTargetTexture = function(this: ThinEngine, size: number | { width: number, height: number, layers?: number }, options: boolean | RenderTargetCreationOptions): InternalTexture {
+ThinEngine.prototype.createRenderTargetTexture = function(this: ThinEngine, size: RenderTargetTextureSize, options: boolean | RenderTargetCreationOptions): InternalTexture {
     const fullOptions = new RenderTargetCreationOptions();
     if (options !== undefined && typeof options === "object") {
         fullOptions.generateMipMaps = options.generateMipMaps;
@@ -126,7 +132,7 @@ ThinEngine.prototype.createRenderTargetTexture = function(this: ThinEngine, size
     return texture;
 };
 
-ThinEngine.prototype.createDepthStencilTexture = function(size: number | { width: number, height: number, layers?: number }, options: DepthTextureCreationOptions): InternalTexture {
+ThinEngine.prototype.createDepthStencilTexture = function(size: RenderTargetTextureSize, options: DepthTextureCreationOptions): InternalTexture {
     if (options.isCube) {
         let width = (<{ width: number, height: number }>size).width || <number>size;
         return this._createDepthStencilCubeTexture(width, options);
@@ -136,7 +142,7 @@ ThinEngine.prototype.createDepthStencilTexture = function(size: number | { width
     }
 };
 
-ThinEngine.prototype._createDepthStencilTexture = function(size: number | { width: number, height: number, layers?: number }, options: DepthTextureCreationOptions): InternalTexture {
+ThinEngine.prototype._createDepthStencilTexture = function(size: RenderTargetTextureSize, options: DepthTextureCreationOptions): InternalTexture {
     const gl = this._gl;
     const layers = (<{ width: number, height: number, layers?: number }>size).layers || 0;
     const target = layers !== 0 ? gl.TEXTURE_2D_ARRAY : gl.TEXTURE_2D;

src/Materials/Textures/Procedurals/proceduralTexture.ts

@@ -20,6 +20,7 @@ import "../../../Shaders/procedural.vertex";
 import { DataBuffer } from '../../../Meshes/dataBuffer';
 import { _TypeStore } from '../../../Misc/typeStore';
 import { NodeMaterial } from '../../Node/nodeMaterial';
+import { RenderTargetTextureSize } from '../../../Engines/Extensions/engine.renderTarget';
 
 /**
  * Procedural texturing is a way to programmatically create a texture. There are 2 types of procedural textures: code-only, and code that references some classic 2D images, sometimes calmpler' images.
@@ -73,7 +74,7 @@ export class ProceduralTexture extends Texture {
     protected _fallbackTexture: Nullable<Texture>;
 
     @serialize()
-    private _size: number | { width: number, height: number, layers?: number };
+    private _size: RenderTargetTextureSize;
     private _currentRefreshId = -1;
     private _frameId = -1;
     private _refreshRate = 1;
@@ -113,7 +114,7 @@ export class ProceduralTexture extends Texture {
      * @param generateMipMaps Define if the texture should creates mip maps or not
      * @param isCube Define if the texture is a cube texture or not (this will render each faces of the cube)
      */
-    constructor(name: string, size: number | { width: number, height: number, layers?: number }, fragment: any, scene: Nullable<Scene>, fallbackTexture: Nullable<Texture> = null, generateMipMaps = true, isCube = false) {
+    constructor(name: string, size: RenderTargetTextureSize, fragment: any, scene: Nullable<Scene>, fallbackTexture: Nullable<Texture> = null, generateMipMaps = true, isCube = false) {
         super(null, scene, !generateMipMaps);
 
         scene = this.getScene()!;
@@ -342,7 +343,7 @@ export class ProceduralTexture extends Texture {
      * Get the size the texture is rendering at.
      * @returns the size (on cube texture it is always squared)
      */
-    public getRenderSize(): number | { width: number, height: number, layers?: number } {
+    public getRenderSize(): RenderTargetTextureSize {
         return this._size;
     }