react-babylonjs
Version:
React for Babylon.js
437 lines (436 loc) • 17.4 kB
TypeScript
import { Camera } from '@babylonjs/core/Cameras/camera.js';
import { Color3 } from '@babylonjs/core/Maths/math.color.js';
import { Vector3 } from '@babylonjs/core/Maths/math.vector.js';
import { Mesh } from '@babylonjs/core/Meshes/mesh.js';
import { SolidParticleSystem } from '@babylonjs/core/Particles/solidParticleSystem.js';
import { Scene } from '@babylonjs/core/scene.js';
export declare class DynamicTerrain {
name: string;
private _terrainSub;
private _mapData;
private _terrainIdx;
private _mapSubX;
private _mapSubZ;
private _mapUVs;
private _mapColors;
private _mapNormals;
private _SPmapData;
private _SPcolorData;
private _SPuvData;
private _sps;
private _spsTypeStartIndexes;
private _nbAvailablePerType;
private _spsNbPerType;
private _particleDataStride;
private _particleColorStride;
private _particleUVStride;
private _scene;
private _subToleranceX;
private _subToleranceZ;
private _LODLimits;
private _initialLOD;
private _LODValue;
private _cameraLODCorrection;
private _LODPositiveX;
private _LODNegativeX;
private _LODPositiveZ;
private _LODNegativeZ;
private _terrainCamera;
private _inverted;
shiftFromCamera: {
x: number;
z: number;
};
private _indices;
private _positions;
private _normals;
private _colors;
private _uvs;
private _deltaSubX;
private _deltaSubZ;
private _refreshEveryFrame;
private _useCustomVertexFunction;
private _computeNormals;
private _datamap;
private _uvmap;
private _colormap;
private _mapSPData;
private _colorSPData;
private _uvSPData;
private _mapQuads;
private static _vertex;
private _averageSubSizeX;
private _averageSubSizeZ;
private _terrainSizeX;
private _terrainSizeZ;
private _terrainHalfSizeX;
private _terrainHalfSizeZ;
private _centerWorld;
private _centerLocal;
private _mapSizeX;
private _mapSizeZ;
private _terrain;
private _isAlwaysVisible;
private _precomputeNormalsFromMap;
private static _v1;
private static _v2;
private static _v3;
private static _v4;
private static _vAvB;
private static _vAvC;
private static _norm;
private static _bbMin;
private static _bbMax;
/**
* constructor
* @param name
* @param options
* @param scene
* @param {*} mapData the array of the map 3D data : x, y, z successive float values
* @param {*} mapSubX the data map number of x subdivisions : integer
* @param {*} mapSubZ the data map number of z subdivisions : integer
* @param {*} terrainSub the wanted terrain number of subdivisions : integer, multiple of 2.
* @param {*} mapUVs the array of the map UV data (optional) : u,v successive values, each between 0 and 1.
* @param {*} mapColors the array of the map Color data (optional) : x, y, z successive float values.
* @param {*} mapNormals the array of the map normal data (optional) : r,g,b successive values, each between 0 and 1.
* @param {*} invertSide boolean, to invert the terrain mesh upside down. Default false.
* @param {*} camera the camera to link the terrain to. Optional, by default the scene active camera
* @param {*} SPmapData an array of arrays or Float32Arrays (one per particle type) of object data (position, rotation, scaling) on the map. Optional.
* @param {*} sps the Solid Particle System used to manage the particles. Required when used with SPmapData.
* @param {*} SPcolorData an array of arrays or Float32Arrays (one per particle type) of object colors on the map. One series of r, g, b, a floats per object. Optional, requires a SPmapData and a sps to be passed.
* @param {*} SPuvData an array of arrays or Float32Arrays (one per particle type) of object uvs on the map. One series of x, y, z, w floats per object. Optional, requires a SPmapData and a sps to be passed.
*/
constructor(name: string, scene: Scene, options?: {
terrainSub?: number;
mapData?: number[] | Float32Array;
mapSubX?: number;
mapSubZ?: number;
mapUVs?: number[] | Float32Array;
mapColors?: number[] | Float32Array;
mapNormals?: number[] | Float32Array;
invertSide?: boolean;
camera?: Camera;
SPmapData?: number[][] | Float32Array[];
sps?: SolidParticleSystem;
SPcolorData?: number[][] | Float32Array[];
SPuvData?: number[][] | Float32Array[];
intializedCallback?: any;
});
/**
* Updates the terrain position and shape according to the camera position.
* `force` : boolean, forces the terrain update even if no camera position change.
* Returns the terrain.
*/
update(force: boolean): DynamicTerrain;
private _updateTerrain;
private _mod;
/**
* Updates the mesh terrain size according to the LOD limits and the camera position.
* Returns the terrain.
*/
updateTerrainSize(): DynamicTerrain;
/**
* Returns the altitude (float) at the coordinates (x, z) of the map.
* @param x
* @param z
* @param {normal: Vector3} (optional)
* If the optional object {normal: Vector3} is passed, then its property "normal" is updated with the normal vector value at the coordinates (x, z).
*/
getHeightFromMap(x: number, z: number, options?: {
normal: Vector3;
}): number;
/**
* Static : Returns the altitude (float) at the coordinates (x, z) of the passed map.
* @param x
* @param z
* @param mapSubX the number of points along the map width
* @param mapSubX the number of points along the map height
* @param {normal: Vector3} (optional)
* @param inverted (optional boolean) is the terrain inverted
* If the optional object {normal: Vector3} is passed, then its property "normal" is updated with the normal vector value at the coordinates (x, z).
*/
static GetHeightFromMap(x: number, z: number, mapData: number[] | Float32Array, mapSubX: number, mapSubZ: number, options?: {
normal: Vector3;
}, inverted?: boolean): number;
private static _GetHeightFromMap;
/**
* Static : Computes all the normals from the terrain data map and stores them in the passed Float32Array reference.
* This passed array must have the same size than the mapData array.
*/
static ComputeNormalsFromMapToRef(mapData: number[] | Float32Array, mapSubX: number, mapSubZ: number, normals: number[] | Float32Array, inverted: boolean): void;
/**
* Computes all the map normals from the current terrain data map and sets them to the terrain.
* Returns the terrain.
*/
computeNormalsFromMap(): DynamicTerrain;
/**
* Returns true if the World coordinates (x, z) are in the current terrain.
* @param x
* @param z
*/
contains(x: number, z: number): boolean;
/**
* Static : Returns a new data map from the passed heightmap image file.
The parameters `width` and `height` (positive floats, default 300) set the map width and height sizes.
* `subX` is the wanted number of points along the map width (default 100).
* `subZ` is the wanted number of points along the map height (default 100).
* The parameter `minHeight` (float, default 0) is the minimum altitude of the map.
* The parameter `maxHeight` (float, default 1) is the maximum altitude of the map.
* The parameter `colorFilter` (optional Color3, default (0.3, 0.59, 0.11) ) is the filter to apply to the image pixel colors to compute the height.
* `onReady` is an optional callback function, called once the map is computed. It's passed the computed map.
* `scene` is the Scene object whose database will store the downloaded image.
*/
static CreateMapFromHeightMap(heightmapURL: string, options: {
width: number;
height: number;
subX: number;
subZ: number;
minHeight: number;
maxHeight: number;
offsetX: number;
offsetZ: number;
onReady?: (map: number[] | Float32Array, subX: number, subZ: number) => void;
colorFilter?: Color3;
}, scene: Scene): Float32Array;
/**
* Static : Updates the passed array or Float32Array with a data map computed from the passed heightmap image file.
* The parameters `width` and `height` (positive floats, default 300) set the map width and height sizes.
* `subX` is the wanted number of points along the map width (default 100).
* `subZ` is the wanted number of points along the map height (default 100).
* The parameter `minHeight` (float, default 0) is the minimum altitude of the map.
* The parameter `maxHeight` (float, default 1) is the maximum altitude of the map.
* The parameter `colorFilter` (optional Color3, default (0.3, 0.59, 0.11) ) is the filter to apply to the image pixel colors to compute the height.
* `onReady` is an optional callback function, called once the map is computed. It's passed the computed map.
* `scene` is the Scene object whose database will store the downloaded image.
* The passed Float32Array must be the right size : 3 x subX x subZ.
*/
static CreateMapFromHeightMapToRef(heightmapURL: string, options: {
width: number;
height: number;
subX: number;
subZ: number;
minHeight: number;
maxHeight: number;
offsetX: number;
offsetZ: number;
onReady?: (map: number[] | Float32Array, subX: number, subZ: number) => void;
colorFilter?: Color3;
}, data: number[] | Float32Array, scene: Scene): void;
/**
* Static : Updates the passed arrays with UVs values to fit the whole map with subX points along its width and subZ points along its height.
* The passed array must be the right size : subX x subZ x 2.
*/
static CreateUVMapToRef(subX: number, subZ: number, mapUVs: number[] | Float32Array): void;
/**
* Static : Returns a new UV array with values to fit the whole map with subX points along its width and subZ points along its height.
*/
static CreateUVMap(subX: number, subZ: number): Float32Array;
/**
* Computes and sets the terrain UV map with values to fit the whole map.
* Returns the terrain.
*/
createUVMap(): DynamicTerrain;
/**
* boolean : if the terrain must be recomputed every frame.
*/
get refreshEveryFrame(): boolean;
set refreshEveryFrame(val: boolean);
/**
* Mesh : the logical terrain underlying mesh
*/
get mesh(): Mesh;
/**
* The camera the terrain is linked to
*/
get camera(): Camera;
set camera(val: Camera);
/**
* Number of cells flought over by the cam on the X axis before the terrain is updated.
* Integer greater or equal to 1.
*/
get subToleranceX(): number;
set subToleranceX(val: number);
/**
* Number of cells flought over by the cam on the Z axis before the terrain is updated.
* Integer greater or equal to 1. Default 1.
*/
get subToleranceZ(): number;
set subToleranceZ(val: number);
/**
* Initial LOD factor value.
* Integer greater or equal to 1. Default 1.
*/
get initialLOD(): number;
set initialLOD(val: number);
/**
* Current LOD factor value : the lower factor in the terrain.
* The LOD value is the sum of the initialLOD and the current cameraLODCorrection.
* Integer greater or equal to 1. Default 1.
*/
get LODValue(): number;
/**
* Camera LOD correction : the factor to add to the initial LOD according to the camera position, movement, etc.
* Positive integer (default 0)
*/
get cameraLODCorrection(): number;
set cameraLODCorrection(val: number);
/**
* Boolean : Does the LOD apply only to the terrain right edge ?
* Default : true
*/
get LODPositiveX(): boolean;
set LODPositiveX(val: boolean);
/**
* Boolean : Does the LOD apply only to the terrain left edge ?
* Default : true
*/
get LODNegativeX(): boolean;
set LODNegativeX(val: boolean);
/**
* Boolean : Does the LOD apply only to the terrain upper edge ?
* Default : true
*/
get LODPositiveZ(): boolean;
set LODPositiveZ(val: boolean);
/**
* Boolean : Does the LOD apply only to the terrain lower edge ?
* Default : true
*/
get LODNegativeZ(): boolean;
set LODNegativeZ(val: boolean);
/**
* Average map and terrain subdivision size on X axis.
* Returns a float.
*/
get averageSubSizeX(): number;
/**
* Average map and terrain subdivision size on Z axis.
* Returns a float.
*/
get averageSubSizeZ(): number;
/**
* Current terrain size on the X axis.
* Returns a float.
*/
get terrainSizeX(): number;
/**
* Current terrain half size on the X axis.
* Returns a float.
*/
get terrainHalfSizeX(): number;
/**
* Current terrain size on the Z axis.
* Returns a float.
*/
get terrainSizeZ(): number;
/**
* Current terrain half size on the Z axis.
* Returns a float.
*/
get terrainHalfSizeZ(): number;
/**
* Current position of terrain center in its local space.
* Returns a Vector3.
*/
get centerLocal(): Vector3;
/**
* Current position of terrain center in the World space.
* Returns a Vector3.
*/
get centerWorld(): Vector3;
/**
* The array of the limit values to change the LOD factor.
* Returns an array of integers or an empty array.
* This array is always sorted in the descending order once set.
*/
get LODLimits(): number[];
set LODLimits(ar: number[]);
/**
* The data of the map.
* A flat array (Float32Array recommeded) of successive 3D float coordinates (x, y, z).
* This property can be set only if a mapData array was passed at construction time.
*/
get mapData(): Float32Array | number[];
set mapData(val: Float32Array | number[]);
/**
* The number of points on the map width.
* Positive Integer.
*/
get mapSubX(): number;
set mapSubX(val: number);
/**
* The number of points on the map height .
* Positive Integer.
*/
get mapSubZ(): number;
set mapSubZ(val: number);
/**
* The map of colors.
* A flat array of successive floats between 0 and 1 as r,g,b values.
* This property can be set only if a mapColors array was passed at construction time.
*/
get mapColors(): Float32Array | number[];
set mapColors(val: Float32Array | number[]);
/**
* The map of UVs.
* A flat array of successive floats between 0 and 1 as (u, v) values.
* This property can be set only if a mapUVs array was passed at construction time.
*/
get mapUVs(): Float32Array | number[];
set mapUVs(val: Float32Array | number[]);
/**
* The map of normals.
* A flat array of successive floats as normal vector coordinates (x, y, z) on each map point.
*/
get mapNormals(): Float32Array | number[];
set mapNormals(val: Float32Array | number[]);
/**
* Boolean : must the normals be recomputed on each terrain update (default : false).
* By default, all the map normals are pre-computed on terrain creation.
*/
get computeNormals(): boolean;
set computeNormals(val: boolean);
/**
* Boolean : will the custom function updateVertex() be called on each terrain update ?
* Default false
*/
get useCustomVertexFunction(): boolean;
set useCustomVertexFunction(val: boolean);
/**
* Boolean : is the terrain always directly selected for rendering ?
*/
get isAlwaysVisible(): boolean;
set isAlwaysVisible(val: boolean);
/**
* Boolean : when assigning a new data map to the existing, shall the normals be automatically precomputed once ?
* Default false.
*/
get precomputeNormalsFromMap(): boolean;
set precomputeNormalsFromMap(val: boolean);
/**
* Custom function called for each terrain vertex and passed the :
* - current vertex {position: Vector3, uvs: Vector2, color: Color4, lodX: integer, lodZ: integer, worldPosition: Vector3, mapIndex: integer}
* - i : the vertex index on the terrain x axis
* - j : the vertex index on the terrain x axis
* This function is called only if the property useCustomVertexFunction is set to true.
*/
updateVertex(vertex: Vector3, i: number, j: number): void;
/**
* Custom function called each frame and passed the terrain camera reference.
* This should return a positive integer or zero.
* Returns zero by default.
*/
updateCameraLOD(terrainCamera: Camera): number;
/**
* Custom function called before each terrain update.
* The value of reference is passed.
* Does nothing by default.
*/
beforeUpdate(refreshEveryFrame: boolean): void;
/**
* Custom function called after each terrain update.
* The value of refreshEveryFrame is passed.
* Does nothing by default.
*/
afterUpdate(refreshEveryFrame: boolean): void;
}