babylonjs.proceduralTextures.d.ts 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237
  1. /*BabylonJS Procedural Textures*/
  2. // Dependencies for this module:
  3. // ../../../../Tools/Gulp/babylonjs
  4. declare module BABYLON {
  5. export class BrickProceduralTexture extends BABYLON.ProceduralTexture {
  6. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  7. updateShaderUniforms(): void;
  8. numberOfBricksHeight: number;
  9. numberOfBricksWidth: number;
  10. jointColor: BABYLON.Color3;
  11. brickColor: BABYLON.Color3;
  12. /**
  13. * Serializes this brick procedural texture
  14. * @returns a serialized brick procedural texture object
  15. */
  16. serialize(): any;
  17. /**
  18. * Creates a Brick Procedural BABYLON.Texture from parsed brick procedural texture data
  19. * @param parsedTexture defines parsed texture data
  20. * @param scene defines the current scene
  21. * @param rootUrl defines the root URL containing brick procedural texture information
  22. * @returns a parsed Brick Procedural BABYLON.Texture
  23. */
  24. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): BrickProceduralTexture;
  25. }
  26. }
  27. declare module BABYLON {
  28. export class CloudProceduralTexture extends BABYLON.ProceduralTexture {
  29. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  30. updateShaderUniforms(): void;
  31. skyColor: BABYLON.Color4;
  32. cloudColor: BABYLON.Color4;
  33. /**
  34. * Serializes this cloud procedural texture
  35. * @returns a serialized cloud procedural texture object
  36. */
  37. serialize(): any;
  38. /**
  39. * Creates a Cloud Procedural BABYLON.Texture from parsed cloud procedural texture data
  40. * @param parsedTexture defines parsed texture data
  41. * @param scene defines the current scene
  42. * @param rootUrl defines the root URL containing cloud procedural texture information
  43. * @returns a parsed Cloud Procedural BABYLON.Texture
  44. */
  45. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): CloudProceduralTexture;
  46. }
  47. }
  48. declare module BABYLON {
  49. export class FireProceduralTexture extends BABYLON.ProceduralTexture {
  50. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  51. updateShaderUniforms(): void;
  52. render(useCameraPostProcess?: boolean): void;
  53. static readonly PurpleFireColors: BABYLON.Color3[];
  54. static readonly GreenFireColors: BABYLON.Color3[];
  55. static readonly RedFireColors: BABYLON.Color3[];
  56. static readonly BlueFireColors: BABYLON.Color3[];
  57. autoGenerateTime: boolean;
  58. fireColors: BABYLON.Color3[];
  59. time: number;
  60. speed: BABYLON.Vector2;
  61. alphaThreshold: number;
  62. /**
  63. * Serializes this fire procedural texture
  64. * @returns a serialized fire procedural texture object
  65. */
  66. serialize(): any;
  67. /**
  68. * Creates a Fire Procedural BABYLON.Texture from parsed fire procedural texture data
  69. * @param parsedTexture defines parsed texture data
  70. * @param scene defines the current scene
  71. * @param rootUrl defines the root URL containing fire procedural texture information
  72. * @returns a parsed Fire Procedural BABYLON.Texture
  73. */
  74. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): FireProceduralTexture;
  75. }
  76. }
  77. declare module BABYLON {
  78. export class GrassProceduralTexture extends BABYLON.ProceduralTexture {
  79. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  80. updateShaderUniforms(): void;
  81. grassColors: BABYLON.Color3[];
  82. groundColor: BABYLON.Color3;
  83. /**
  84. * Serializes this grass procedural texture
  85. * @returns a serialized grass procedural texture object
  86. */
  87. serialize(): any;
  88. /**
  89. * Creates a Grass Procedural BABYLON.Texture from parsed grass procedural texture data
  90. * @param parsedTexture defines parsed texture data
  91. * @param scene defines the current scene
  92. * @param rootUrl defines the root URL containing grass procedural texture information
  93. * @returns a parsed Grass Procedural BABYLON.Texture
  94. */
  95. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): GrassProceduralTexture;
  96. }
  97. }
  98. declare module BABYLON {
  99. export class MarbleProceduralTexture extends BABYLON.ProceduralTexture {
  100. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  101. updateShaderUniforms(): void;
  102. numberOfTilesHeight: number;
  103. amplitude: number;
  104. numberOfTilesWidth: number;
  105. jointColor: BABYLON.Color3;
  106. /**
  107. * Serializes this marble procedural texture
  108. * @returns a serialized marble procedural texture object
  109. */
  110. serialize(): any;
  111. /**
  112. * Creates a Marble Procedural BABYLON.Texture from parsed marble procedural texture data
  113. * @param parsedTexture defines parsed texture data
  114. * @param scene defines the current scene
  115. * @param rootUrl defines the root URL containing marble procedural texture information
  116. * @returns a parsed Marble Procedural BABYLON.Texture
  117. */
  118. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): MarbleProceduralTexture;
  119. }
  120. }
  121. declare module BABYLON {
  122. export class NormalMapProceduralTexture extends BABYLON.ProceduralTexture {
  123. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  124. updateShaderUniforms(): void;
  125. render(useCameraPostProcess?: boolean): void;
  126. resize(size: any, generateMipMaps: any): void;
  127. baseTexture: BABYLON.Texture;
  128. /**
  129. * Serializes this normal map procedural texture
  130. * @returns a serialized normal map procedural texture object
  131. */
  132. serialize(): any;
  133. /**
  134. * Creates a Normal Map Procedural BABYLON.Texture from parsed normal map procedural texture data
  135. * @param parsedTexture defines parsed texture data
  136. * @param scene defines the current scene
  137. * @param rootUrl defines the root URL containing normal map procedural texture information
  138. * @returns a parsed Normal Map Procedural BABYLON.Texture
  139. */
  140. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): NormalMapProceduralTexture;
  141. }
  142. }
  143. declare module BABYLON {
  144. export class PerlinNoiseProceduralTexture extends BABYLON.ProceduralTexture {
  145. time: number;
  146. timeScale: number;
  147. translationSpeed: number;
  148. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  149. updateShaderUniforms(): void;
  150. render(useCameraPostProcess?: boolean): void;
  151. resize(size: any, generateMipMaps: any): void;
  152. /**
  153. * Serializes this perlin noise procedural texture
  154. * @returns a serialized perlin noise procedural texture object
  155. */
  156. serialize(): any;
  157. /**
  158. * Creates a Perlin Noise Procedural BABYLON.Texture from parsed perlin noise procedural texture data
  159. * @param parsedTexture defines parsed texture data
  160. * @param scene defines the current scene
  161. * @param rootUrl defines the root URL containing perlin noise procedural texture information
  162. * @returns a parsed Perlin Noise Procedural BABYLON.Texture
  163. */
  164. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): PerlinNoiseProceduralTexture;
  165. }
  166. }
  167. declare module BABYLON {
  168. export class RoadProceduralTexture extends BABYLON.ProceduralTexture {
  169. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  170. updateShaderUniforms(): void;
  171. roadColor: BABYLON.Color3;
  172. /**
  173. * Serializes this road procedural texture
  174. * @returns a serialized road procedural texture object
  175. */
  176. serialize(): any;
  177. /**
  178. * Creates a Road Procedural BABYLON.Texture from parsed road procedural texture data
  179. * @param parsedTexture defines parsed texture data
  180. * @param scene defines the current scene
  181. * @param rootUrl defines the root URL containing road procedural texture information
  182. * @returns a parsed Road Procedural BABYLON.Texture
  183. */
  184. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): RoadProceduralTexture;
  185. }
  186. }
  187. declare module BABYLON {
  188. export class StarfieldProceduralTexture extends BABYLON.ProceduralTexture {
  189. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  190. updateShaderUniforms(): void;
  191. time: number;
  192. alpha: number;
  193. beta: number;
  194. formuparam: number;
  195. stepsize: number;
  196. zoom: number;
  197. tile: number;
  198. brightness: number;
  199. darkmatter: number;
  200. distfading: number;
  201. saturation: number;
  202. /**
  203. * Serializes this starfield procedural texture
  204. * @returns a serialized starfield procedural texture object
  205. */
  206. serialize(): any;
  207. /**
  208. * Creates a Starfield Procedural BABYLON.Texture from parsed startfield procedural texture data
  209. * @param parsedTexture defines parsed texture data
  210. * @param scene defines the current scene
  211. * @param rootUrl defines the root URL containing startfield procedural texture information
  212. * @returns a parsed Starfield Procedural BABYLON.Texture
  213. */
  214. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): StarfieldProceduralTexture;
  215. }
  216. }
  217. declare module BABYLON {
  218. export class WoodProceduralTexture extends BABYLON.ProceduralTexture {
  219. constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
  220. updateShaderUniforms(): void;
  221. ampScale: number;
  222. woodColor: BABYLON.Color3;
  223. /**
  224. * Serializes this wood procedural texture
  225. * @returns a serialized wood procedural texture object
  226. */
  227. serialize(): any;
  228. /**
  229. * Creates a Wood Procedural BABYLON.Texture from parsed wood procedural texture data
  230. * @param parsedTexture defines parsed texture data
  231. * @param scene defines the current scene
  232. * @param rootUrl defines the root URL containing wood procedural texture information
  233. * @returns a parsed Wood Procedural BABYLON.Texture
  234. */
  235. static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): WoodProceduralTexture;
  236. }
  237. }