itowns 2.42.1-next.2 → 2.42.1-next.21

package/lib/Renderer/OrientedImageMaterial.js

@@ -1,24 +1,15 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var THREE = _interopRequireWildcard(require("three"));
-var _Capabilities = _interopRequireDefault(require("../Core/System/Capabilities"));
-var _ShaderUtils = _interopRequireDefault(require("./Shader/ShaderUtils"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+import * as THREE from 'three';
+import Capabilities from "../Core/System/Capabilities.js";
 /* babel-plugin-inline-import './Shader/ProjectiveTextureVS.glsl' */
-const textureVS = "#include <itowns/WebGL2_pars_vertex>\n#include <itowns/precision_qualifier>\n#include <itowns/project_pars_vertex>\n#include <itowns/projective_texturing_pars_vertex>\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\nvarying vec3 vNormal;\nattribute vec3 normal;\n\nvoid main() {\n    #include <begin_vertex>\n    #include <project_vertex>\n    vNormal = normal;\n    #include <itowns/projective_texturing_vertex>\n    #include <logdepthbuf_vertex>\n}\n";
+const textureVS = "#include <itowns/precision_qualifier>\n#include <itowns/projective_texturing_pars_vertex>\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\nvarying vec3 vNormal;\n\nvoid main() {\n    #include <begin_vertex>\n    #include <project_vertex>\n    vNormal = normal;\n    #include <itowns/projective_texturing_vertex>\n    #include <logdepthbuf_vertex>\n}\n";
 /* babel-plugin-inline-import './Shader/ProjectiveTextureFS.glsl' */
-const textureFS = "#include <itowns/WebGL2_pars_fragment>\n#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/projective_texturing_pars_fragment>\nvarying vec3 vNormal;\n\n#ifdef USE_BASE_MATERIAL\nstruct noPT {\n    vec3 lightDirection;\n    vec3 ambient;\n    float opacity;\n};\n\nuniform noPT noProjectiveMaterial;\n#endif\n\nvoid main(void)\n{\n    #include <logdepthbuf_fragment>\n    #ifdef USE_BASE_MATERIAL\n    float nDotVP = (max(0.1, dot(vNormal, normalize(noProjectiveMaterial.lightDirection))));\n    vec4 color = vec4(noProjectiveMaterial.ambient + nDotVP, 0.0);\n    #else\n    vec4 color = vec4(0.0);\n    #endif\n\n    #pragma unroll_loop\n    for (int i = 0; i < ORIENTED_IMAGES_COUNT; i++) {\n        color = projectiveTextureColor(projectiveTextureCoords[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTextureDistortion[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTexture[ ORIENTED_IMAGES_COUNT - 1 - i ], mask[ORIENTED_IMAGES_COUNT - 1 - i], color);\n    }\n\n    #ifdef USE_BASE_MATERIAL\n    color.a = color.a < 1.0 ? max(noProjectiveMaterial.opacity, color.a) : 1.0 ;\n    gl_FragColor = vec4(color.rgb, color.a * opacity);\n    #else\n    gl_FragColor = vec4(color.rgb / color.a, opacity);\n    #endif\n\n}\n";
+const textureFS = "#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/projective_texturing_pars_fragment>\nvarying vec3 vNormal;\n\n#ifdef USE_BASE_MATERIAL\nstruct noPT {\n    vec3 lightDirection;\n    vec3 ambient;\n    float opacity;\n};\n\nuniform noPT noProjectiveMaterial;\n#endif\n\nvoid main(void)\n{\n    #include <logdepthbuf_fragment>\n    #ifdef USE_BASE_MATERIAL\n    float nDotVP = (max(0.1, dot(vNormal, normalize(noProjectiveMaterial.lightDirection))));\n    vec4 color = vec4(noProjectiveMaterial.ambient + nDotVP, 0.0);\n    #else\n    vec4 color = vec4(0.0);\n    #endif\n\n    #pragma unroll_loop\n    for (int i = 0; i < ORIENTED_IMAGES_COUNT; i++) {\n        color = projectiveTextureColor(projectiveTextureCoords[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTextureDistortion[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTexture[ ORIENTED_IMAGES_COUNT - 1 - i ], mask[ORIENTED_IMAGES_COUNT - 1 - i], color);\n    }\n\n    #ifdef USE_BASE_MATERIAL\n    color.a = color.a < 1.0 ? max(noProjectiveMaterial.opacity, color.a) : 1.0 ;\n    gl_FragColor = vec4(color.rgb, color.a * opacity);\n    #else\n    gl_FragColor = vec4(color.rgb / color.a, opacity);\n    #endif\n\n}\n";
+import ShaderUtils from "./Shader/ShaderUtils.js";
 const ndcToTextureMatrix = new THREE.Matrix4(1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0, 0, 2);
 const noMask = new THREE.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, THREE.RGBAFormat, THREE.UnsignedByteType);
 noMask.needsUpdate = true;
 const noTexture = new THREE.Texture();
-const rawShaderMaterial = new THREE.RawShaderMaterial();
+const shaderMaterial = new THREE.ShaderMaterial();
 /**
  * @classdesc OrientedImageMaterial is a custom shader material used to do projective texture mapping.<br/>
  *
@@ -37,7 +28,7 @@ const rawShaderMaterial = new THREE.RawShaderMaterial();
  * <br/>
  * To get a more comprehensive support of camera Micmac models, you can consider using [three-photogrammetric-camera]{@link https://github.com/mbredif/three-photogrammetric-camera} instead.
  */
-class OrientedImageMaterial extends THREE.RawShaderMaterial {
+class OrientedImageMaterial extends THREE.ShaderMaterial {
   /**
    * @constructor
    * @param { OrientedImageCamera[]} cameras - Array of {@link OrientedImageCamera}. Each camera will project a texture.
@@ -62,21 +53,21 @@ class OrientedImageMaterial extends THREE.RawShaderMaterial {
     options.transparent = options.transparent ?? true;
     options.opacity = options.opacity ?? 1;
 
-    // Filter the rawShaderMaterial options
-    const rawShaderMaterialOptions = {};
+    // Filter out non-ShaderMaterial options
+    const shaderMaterialOptions = {};
     for (const key in options) {
       if (Object.prototype.hasOwnProperty.call(options, key)) {
-        const currentValue = rawShaderMaterial[key];
+        const currentValue = shaderMaterial[key];
         if (currentValue !== undefined) {
-          rawShaderMaterialOptions[key] = options[key];
+          shaderMaterialOptions[key] = options[key];
         }
       }
     }
-    super(rawShaderMaterialOptions);
+    super(shaderMaterialOptions);
     this.defines.ORIENTED_IMAGES_COUNT = options.OrientedImagesCount ?? cameras.length;
 
     // verify that number of textures doesn't exceed GPU capabilities
-    const maxTexturesUnits = _Capabilities.default.getMaxTextureUnitsCount();
+    const maxTexturesUnits = Capabilities.getMaxTextureUnitsCount();
     if (this.defines.ORIENTED_IMAGES_COUNT > maxTexturesUnits) {
       console.warn(`OrientedImageMaterial: Can't project ${cameras.length} textures, because it's more than GPU capabilities maximum texture units (${maxTexturesUnits})`);
 
@@ -116,18 +107,10 @@ class OrientedImageMaterial extends THREE.RawShaderMaterial {
       ambient: new THREE.Color(0.1, 0.1, 0.1),
       opacity: 0.75
     });
-    if (_Capabilities.default.isLogDepthBufferSupported()) {
-      this.defines.USE_LOGDEPTHBUF = 1;
-      this.defines.USE_LOGDEPTHBUF_EXT = 1;
-    }
     this.vertexShader = textureVS;
-    this.fragmentShader = _ShaderUtils.default.unrollLoops(textureFS, this.defines);
-  }
-  onBeforeCompile(shader, renderer) {
-    if (renderer.capabilities.isWebGL2) {
-      this.defines.WEBGL2 = true;
-      shader.glslVersion = '300 es';
-    }
+    // three loop unrolling of ShaderMaterial only supports integer bounds,
+    // see https://github.com/mrdoob/three.js/issues/28020
+    this.fragmentShader = ShaderUtils.unrollLoops(textureFS, this.defines);
   }
 
   /**
@@ -182,5 +165,4 @@ class OrientedImageMaterial extends THREE.RawShaderMaterial {
     }
   }
 }
-var _default = OrientedImageMaterial;
-exports.default = _default;
+export default OrientedImageMaterial;

package/lib/Renderer/PointsMaterial.js

@@ -1,37 +1,31 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.PNTS_SIZE_MODE = exports.PNTS_SHAPE = exports.PNTS_MODE = exports.ClassificationScheme = void 0;
-var THREE = _interopRequireWildcard(require("three"));
-var _Capabilities = _interopRequireDefault(require("../Core/System/Capabilities"));
-var _ShaderUtils = _interopRequireDefault(require("./Shader/ShaderUtils"));
-var _CommonMaterial = _interopRequireDefault(require("./CommonMaterial"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+import * as THREE from 'three';
 /* babel-plugin-inline-import './Shader/PointsVS.glsl' */
-const PointsVS = "#include <itowns/WebGL2_pars_vertex>\n#include <itowns/precision_qualifier>\n#include <itowns/project_pars_vertex>\n#if defined(USE_TEXTURES_PROJECTIVE)\n#include <itowns/projective_texturing_pars_vertex>\n#endif\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\nuniform float size;\nuniform float scale;\n\nuniform bool picking;\nuniform int mode;\nuniform float opacity;\nuniform vec4 overlayColor;\nuniform vec2 intensityRange;\nuniform bool applyOpacityClassication;\nattribute vec3 color;\nattribute vec4 unique_id;\nattribute float intensity;\nattribute float classification;\nuniform sampler2D classificationLUT;\nuniform int sizeMode;\nuniform float minAttenuatedSize;\nuniform float maxAttenuatedSize;\n\n#if defined(NORMAL_OCT16)\nattribute vec2 oct16Normal;\n#elif defined(NORMAL_SPHEREMAPPED)\nattribute vec2 sphereMappedNormal;\n#else\nattribute vec3 normal;\n#endif\n\nvarying vec4 vColor;\n\n// see https://web.archive.org/web/20150303053317/http://lgdv.cs.fau.de/get/1602\n// and implementation in PotreeConverter (BINPointReader.cpp) and potree (BinaryDecoderWorker.js)\n#if defined(NORMAL_OCT16)\nvec3 decodeOct16Normal(vec2 encodedNormal) {\n    vec2 nNorm = 2. * (encodedNormal / 255.) - 1.;\n    vec3 n;\n    n.z = 1. - abs(nNorm.x) - abs(nNorm.y);\n    if (n.z >= 0.) {\n        n.x = nNorm.x;\n        n.y = nNorm.y;\n    } else {\n        n.x = sign(nNorm.x) - sign(nNorm.x) * sign(nNorm.y) * nNorm.y;\n        n.y = sign(nNorm.y) - sign(nNorm.y) * sign(nNorm.x) * nNorm.x;\n    }\n    return normalize(n);\n}\n#elif defined(NORMAL_SPHEREMAPPED)\n// see http://aras-p.info/texts/CompactNormalStorage.html method #4\n// or see potree's implementation in BINPointReader.cpp\nvec3 decodeSphereMappedNormal(vec2 encodedNormal) {\n    vec2 fenc = 2. * encodedNormal / 255. - 1.;\n    float f = dot(fenc,fenc);\n    float g = 2. * sqrt(1. - f);\n    vec3 n;\n    n.xy = fenc * g;\n    n.z = 1. - 2. * f;\n    return n;\n}\n#endif\n\nvoid main() {\n\n#if defined(NORMAL_OCT16)\n    vec3  normal = decodeOct16Normal(oct16Normal);\n#elif defined(NORMAL_SPHEREMAPPED)\n    vec3 normal = decodeSphereMappedNormal(sphereMappedNormal);\n#elif defined(NORMAL)\n    // nothing to do\n#else\n    // default to color\n    vec3 normal = color;\n#endif\n\n    if (picking) {\n        vColor = unique_id;\n    } else {\n        vColor.a = opacity;\n        if (applyOpacityClassication || mode == PNTS_MODE_CLASSIFICATION) {\n            vec2 uv = vec2(classification, 0.5);\n            vColor = texture2D(classificationLUT, uv);\n            vColor.a *= opacity;\n        }\n\n        if (mode == PNTS_MODE_INTENSITY) {\n            // adapt the grayscale knowing the range\n            float i = (intensity - intensityRange.x) / (intensityRange.y - intensityRange.x);\n            vColor.rgb = vec3(i, i, i);\n        } else if (mode == PNTS_MODE_NORMAL) {\n            vColor.rgb = abs(normal);\n        } else if (mode == PNTS_MODE_COLOR) {\n            // default to color mode\n            vColor.rgb = mix(color, overlayColor.rgb, overlayColor.a);\n        }\n    }\n\n    #include <begin_vertex>\n    #include <project_vertex>\n\n    gl_PointSize = size;\n\n    if (sizeMode == PNTS_SIZE_MODE_ATTENUATED) {\n        bool isPerspective = isPerspectiveMatrix(projectionMatrix);\n\n        if (isPerspective) {\n            gl_PointSize *= scale / -mvPosition.z;\n            gl_PointSize = clamp(gl_PointSize, minAttenuatedSize, maxAttenuatedSize);\n        }\n    }\n\n#if defined(USE_TEXTURES_PROJECTIVE)\n    #include <itowns/projective_texturing_vertex>\n#endif\n    #include <logdepthbuf_vertex>\n}\n";
+const PointsVS = "#include <itowns/precision_qualifier>\n#if defined(USE_TEXTURES_PROJECTIVE)\n#include <itowns/projective_texturing_pars_vertex>\n#endif\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\n#define NB_CLASS 8.\n\nuniform float size;\nuniform float scale;\n\nuniform bool picking;\nuniform int mode;\nuniform float opacity;\nuniform vec4 overlayColor;\n\nuniform vec2 elevationRange;\nuniform vec2 intensityRange;\nuniform vec2 angleRange;\n\nuniform bool applyOpacityClassication;\n\nuniform sampler2D classificationTexture;\nuniform sampler2D discreteTexture;\nuniform sampler2D gradientTexture;\nuniform int sizeMode;\nuniform float minAttenuatedSize;\nuniform float maxAttenuatedSize;\n\nattribute vec3 color;\nattribute vec2 range;\nattribute vec4 unique_id;\nattribute float intensity;\nattribute float classification;\nattribute float pointSourceID;\n\nattribute float returnNumber;\nattribute float numberOfReturns;\nattribute float scanAngle;\n\n#if defined(NORMAL_OCT16)\nattribute vec2 oct16Normal;\n#elif defined(NORMAL_SPHEREMAPPED)\nattribute vec2 sphereMappedNormal;\n#endif\n\nvarying vec4 vColor;\n\n// see https://web.archive.org/web/20150303053317/http://lgdv.cs.fau.de/get/1602\n// and implementation in PotreeConverter (BINPointReader.cpp) and potree (BinaryDecoderWorker.js)\n#if defined(NORMAL_OCT16)\nvec3 decodeOct16Normal(vec2 encodedNormal) {\n    vec2 nNorm = 2. * (encodedNormal / 255.) - 1.;\n    vec3 n;\n    n.z = 1. - abs(nNorm.x) - abs(nNorm.y);\n    if (n.z >= 0.) {\n        n.x = nNorm.x;\n        n.y = nNorm.y;\n    } else {\n        n.x = sign(nNorm.x) - sign(nNorm.x) * sign(nNorm.y) * nNorm.y;\n        n.y = sign(nNorm.y) - sign(nNorm.y) * sign(nNorm.x) * nNorm.x;\n    }\n    return normalize(n);\n}\n#elif defined(NORMAL_SPHEREMAPPED)\n// see http://aras-p.info/texts/CompactNormalStorage.html method #4\n// or see potree's implementation in BINPointReader.cpp\nvec3 decodeSphereMappedNormal(vec2 encodedNormal) {\n    vec2 fenc = 2. * encodedNormal / 255. - 1.;\n    float f = dot(fenc,fenc);\n    float g = 2. * sqrt(1. - f);\n    vec3 n;\n    n.xy = fenc * g;\n    n.z = 1. - 2. * f;\n    return n;\n}\n#endif\n\nvoid main() {\n\n#if defined(NORMAL_OCT16)\n    vec3  normal = decodeOct16Normal(oct16Normal);\n#elif defined(NORMAL_SPHEREMAPPED)\n    vec3 normal = decodeSphereMappedNormal(sphereMappedNormal);\n#elif defined(NORMAL)\n    // nothing to do\n#else\n    // default to color\n    vec3 normal = color;\n#endif\n\n    if (picking) {\n        vColor = unique_id;\n    } else {\n        vColor.a = opacity;\n        if (applyOpacityClassication || mode == PNTS_MODE_CLASSIFICATION) {\n            vec2 uv = vec2(classification/255., 0.5);\n            vColor = texture2D(classificationTexture, uv);\n            vColor.a *= opacity;\n        }\n\n        if (mode == PNTS_MODE_NORMAL) {\n            vColor.rgb = abs(normal);\n        } else if (mode == PNTS_MODE_COLOR) {\n            // default to color mode\n            vColor.rgb = mix(color, overlayColor.rgb, overlayColor.a);\n        } else if (mode == PNTS_MODE_RETURN_NUMBER) {\n            vec2 uv = vec2(returnNumber/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_RETURN_TYPE) {\n            float returnType;\n            if (returnNumber > numberOfReturns) {\n                returnType = 4.;\n            } else if (returnNumber == 1.) {\n                if (numberOfReturns == 1.) {\n                    // single\n                    returnType = 0.;\n                } else {\n                    // first\n                    returnType = 1.;\n                }\n            } else {\n                if (returnNumber == numberOfReturns) {\n                    // last\n                    returnType = 3.;\n                } else {\n                    // intermediate\n                    returnType = 2.;\n                }\n            }\n            vec2 uv = vec2(returnType/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_RETURN_COUNT) {\n            vec2 uv = vec2(numberOfReturns/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_POINT_SOURCE_ID) {\n            vec2 uv = vec2(mod(pointSourceID, NB_CLASS)/255., 0.5);\n            vColor = texture2D(discreteTexture, uv);\n        } else if (mode == PNTS_MODE_SCAN_ANGLE) {\n            float i = (scanAngle - angleRange.x) / (angleRange.y - angleRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        } else if (mode == PNTS_MODE_INTENSITY) {\n            float i = (intensity - intensityRange.x) / (intensityRange.y - intensityRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        } else if (mode == PNTS_MODE_ELEVATION) {\n            float i = (position.z - elevationRange.x) / (elevationRange.y - elevationRange.x);\n            vec2 uv = vec2(i, (1. - i));\n            vColor = texture2D(gradientTexture, uv);\n        }\n    }\n\n    #include <begin_vertex>\n    #include <project_vertex>\n\n    gl_PointSize = size;\n\n    if (sizeMode == PNTS_SIZE_MODE_ATTENUATED) {\n        bool isPerspective = isPerspectiveMatrix(projectionMatrix);\n\n        if (isPerspective) {\n            gl_PointSize *= scale / -mvPosition.z;\n            gl_PointSize = clamp(gl_PointSize, minAttenuatedSize, maxAttenuatedSize);\n        }\n    }\n\n#if defined(USE_TEXTURES_PROJECTIVE)\n    #include <itowns/projective_texturing_vertex>\n#endif\n    #include <logdepthbuf_vertex>\n}\n";
 /* babel-plugin-inline-import './Shader/PointsFS.glsl' */
-const PointsFS = "#include <itowns/WebGL2_pars_fragment>\n#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#if defined(USE_TEXTURES_PROJECTIVE)\n#include <itowns/projective_texturing_pars_fragment>\n#endif\n\nvarying vec4 vColor;\nuniform bool picking;\nuniform int shape;\n\nvoid main() {\n    #include <logdepthbuf_fragment>\n    //square shape does not require any change.\n    if (shape == PNTS_SHAPE_CIRCLE) {\n        //circular rendering in glsl\n        if ((length(gl_PointCoord - 0.5) > 0.5) || (vColor.a == 0.0)) {\n            discard;\n        }\n    }\n\n#if defined(USE_TEXTURES_PROJECTIVE)\n    vec4 color = vColor;\n    if (!picking) {\n        #pragma unroll_loop\n        for (int i = 0; i < ORIENTED_IMAGES_COUNT; i++) {\n            color = projectiveTextureColor(projectiveTextureCoords[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTextureDistortion[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTexture[ ORIENTED_IMAGES_COUNT - 1 - i ], mask[ORIENTED_IMAGES_COUNT - 1 - i], color);\n        }\n        gl_FragColor = vec4(color.rgb, color.a * opacity);\n    } else {\n        gl_FragColor = color;\n    }\n#else\n    gl_FragColor = vColor;\n#endif\n}\n";
-const PNTS_MODE = {
+const PointsFS = "#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#if defined(USE_TEXTURES_PROJECTIVE)\n#include <itowns/projective_texturing_pars_fragment>\n#endif\n\nvarying vec4 vColor;\nuniform bool picking;\nuniform int shape;\n\nvoid main() {\n    #include <logdepthbuf_fragment>\n    //square shape does not require any change.\n    if (shape == PNTS_SHAPE_CIRCLE) {\n        //circular rendering in glsl\n        if ((length(gl_PointCoord - 0.5) > 0.5) || (vColor.a == 0.0)) {\n            discard;\n        }\n    }\n\n#if defined(USE_TEXTURES_PROJECTIVE)\n    vec4 color = vColor;\n    if (!picking) {\n        #pragma unroll_loop\n        for (int i = 0; i < ORIENTED_IMAGES_COUNT; i++) {\n            color = projectiveTextureColor(projectiveTextureCoords[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTextureDistortion[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTexture[ ORIENTED_IMAGES_COUNT - 1 - i ], mask[ORIENTED_IMAGES_COUNT - 1 - i], color);\n        }\n        gl_FragColor = vec4(color.rgb, color.a * opacity);\n    } else {\n        gl_FragColor = color;\n    }\n#else\n    gl_FragColor = vColor;\n#endif\n}\n";
+import ShaderUtils from "./Shader/ShaderUtils.js";
+import CommonMaterial from "./CommonMaterial.js";
+import Gradients from "../Utils/Gradients.js";
+export const PNTS_MODE = {
   COLOR: 0,
   INTENSITY: 1,
   CLASSIFICATION: 2,
-  NORMAL: 3
+  ELEVATION: 3,
+  RETURN_NUMBER: 4,
+  RETURN_TYPE: 5,
+  RETURN_COUNT: 6,
+  POINT_SOURCE_ID: 7,
+  SCAN_ANGLE: 8,
+  NORMAL: 9
 };
-exports.PNTS_MODE = PNTS_MODE;
-const PNTS_SHAPE = {
+export const PNTS_SHAPE = {
   CIRCLE: 0,
   SQUARE: 1
 };
-exports.PNTS_SHAPE = PNTS_SHAPE;
-const PNTS_SIZE_MODE = {
+export const PNTS_SIZE_MODE = {
   VALUE: 0,
   ATTENUATED: 1
 };
-exports.PNTS_SIZE_MODE = PNTS_SIZE_MODE;
 const white = new THREE.Color(1.0, 1.0, 1.0);
 
 /**
@@ -49,7 +43,7 @@ const white = new THREE.Color(1.0, 1.0, 1.0);
  */
 // eslint-disable-next-line
 class /* istanbul ignore next */Classification {}
-const ClassificationScheme = {
+export const ClassificationScheme = {
   DEFAULT: {
     0: {
       visible: true,
@@ -137,8 +131,129 @@ const ClassificationScheme = {
     }
   }
 };
-exports.ClassificationScheme = ClassificationScheme;
-class PointsMaterial extends THREE.RawShaderMaterial {
+const DiscreteScheme = {
+  DEFAULT: {
+    0: {
+      visible: true,
+      name: '0',
+      color: new THREE.Color('rgb(67, 99, 216)'),
+      opacity: 1.0
+    },
+    1: {
+      visible: true,
+      name: '1',
+      color: new THREE.Color('rgb(60, 180, 75);'),
+      opacity: 1.0
+    },
+    2: {
+      visible: true,
+      name: '2',
+      color: new THREE.Color('rgb(255, 255, 25)'),
+      opacity: 1.0
+    },
+    3: {
+      visible: true,
+      name: '3',
+      color: new THREE.Color('rgb(145, 30, 180)'),
+      opacity: 1.0
+    },
+    4: {
+      visible: true,
+      name: '4',
+      color: new THREE.Color('rgb(245, 130, 49)'),
+      opacity: 1.0
+    },
+    5: {
+      visible: true,
+      name: '5',
+      color: new THREE.Color('rgb(230, 25, 75)'),
+      opacity: 1.0
+    },
+    6: {
+      visible: true,
+      name: '6',
+      color: new THREE.Color('rgb(66, 212, 244)'),
+      opacity: 1.0
+    },
+    7: {
+      visible: true,
+      name: '7',
+      color: new THREE.Color('rgb(240, 50, 230)'),
+      opacity: 1.0
+    },
+    DEFAULT: {
+      visible: true,
+      name: 'default',
+      color: white,
+      opacity: 0.5
+    }
+  }
+};
+
+// Taken from Potree. Copyright (c) 2011-2020, Markus Schütz All rights reserved.
+// https://github.com/potree/potree/blob/develop/src/materials/PointCloudMaterial.js
+function generateGradientTexture(gradient) {
+  const size = 64;
+
+  // create canvas
+  const canvas = document.createElement('canvas');
+  canvas.width = size;
+  canvas.height = size;
+
+  // get context
+  const context = canvas.getContext('2d');
+
+  // draw gradient
+  context.rect(0, 0, size, size);
+  const ctxGradient = context.createLinearGradient(0, 0, size, size);
+  for (let i = 0; i < gradient.length; i++) {
+    const step = gradient[i];
+    ctxGradient.addColorStop(step[0], `#${step[1].getHexString()}`);
+  }
+  context.fillStyle = ctxGradient;
+  context.fill();
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.needsUpdate = true;
+  texture.minFilter = THREE.LinearFilter;
+  texture.wrap = THREE.RepeatWrapping;
+  texture.repeat = 2;
+  return texture;
+}
+function recomputeTexture(scheme, texture, nbClass) {
+  const data = texture.image.data;
+  const width = texture.image.width;
+  if (!nbClass) {
+    nbClass = Object.keys(scheme).length;
+  }
+  for (let i = 0; i < width; i++) {
+    let color;
+    let opacity;
+    let visible = true;
+    if (scheme[i]) {
+      color = scheme[i].color;
+      visible = scheme[i].visible;
+      opacity = scheme[i].opacity;
+    } else if (scheme[i % nbClass]) {
+      color = scheme[i % nbClass].color;
+      visible = scheme[i % nbClass].visible;
+      opacity = scheme[i % nbClass].opacity;
+    } else if (scheme.DEFAULT) {
+      color = scheme.DEFAULT.color;
+      visible = scheme.DEFAULT.visible;
+      opacity = scheme.DEFAULT.opacity;
+    } else {
+      color = white;
+      opacity = 1.0;
+    }
+    const j = 4 * i;
+    data[j + 0] = parseInt(255 * color.r, 10);
+    data[j + 1] = parseInt(255 * color.g, 10);
+    data[j + 2] = parseInt(255 * color.b, 10);
+    data[j + 3] = visible ? parseInt(255 * opacity, 10) : 0;
+  }
+  texture.needsUpdate = true;
+}
+class PointsMaterial extends THREE.ShaderMaterial {
   /**
    * @class      PointsMaterial
    * @param      {object}  [options={}]  The options
@@ -146,13 +261,23 @@ class PointsMaterial extends THREE.RawShaderMaterial {
    * @param      {number}  [options.mode=PNTS_MODE.COLOR]  display mode.
    * @param      {number}  [options.mode=PNTS_SHAPE.CIRCLE]  rendered points shape.
    * @param      {THREE.Vector4}  [options.overlayColor=new THREE.Vector4(0, 0, 0, 0)]  overlay color.
-   * @param      {THREE.Vector2}  [options.intensityRange=new THREE.Vector2(0, 1)]  intensity range.
+   * @param      {THREE.Vector2}  [options.intensityRange=new THREE.Vector2(1, 65536)]  intensity range.
+   * @param      {THREE.Vector2}  [options.elevationRange=new THREE.Vector2(0, 1000)]  elevation range.
+   * @param      {THREE.Vector2}  [options.angleRange=new THREE.Vector2(-90, 90)]  scan angle range.
    * @param      {boolean}  [options.applyOpacityClassication=false]  apply opacity classification on all display mode.
-   * @param      {Classification}  [options.classification] -  define points classification.
+   * @param      {Scheme}  [options.classification]  LUT for point classification colorization.
+   * @param      {Scheme}  [options.discreteScheme]  LUT for other discret point values colorization.
+   * @param      {string}  [options.gradient]  Descrition of the gradient to use for continuous point values.
+   *                          (Default value will be the 'SPECTRAL' gradient from Utils/Gradients)
    * @param      {number}  [options.sizeMode=PNTS_SIZE_MODE.VALUE]  point cloud size mode. Only 'VALUE' or 'ATTENUATED' are possible. VALUE use constant size, ATTENUATED compute size depending on distance from point to camera.
    * @param      {number}  [options.minAttenuatedSize=3]  minimum scale used by 'ATTENUATED' size mode
    * @param      {number}  [options.maxAttenuatedSize=10]  maximum scale used by 'ATTENUATED' size mode
-   * @property {Classification}  classification - points classification.
+   *
+   * @property {Scheme}  classificationScheme - Color scheme for point classification values.
+   * @property {Scheme}  discreteScheme - Color scheme for all other discrete values.
+   * @property {object}  gradients - Descriptions of all available gradients.
+   * @property {object}  gradient - Description of the gradient to use for display.
+   * @property {THREE.CanvasTexture}  gradientTexture - The texture generate from the choosen gradient.
    *
    * @example
    * // change color category classification
@@ -162,9 +287,12 @@ class PointsMaterial extends THREE.RawShaderMaterial {
    */
   constructor() {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const intensityRange = options.intensityRange || new THREE.Vector2(0, 1);
+    const intensityRange = options.intensityRange || new THREE.Vector2(1, 65536);
+    const elevationRange = options.elevationRange || new THREE.Vector2(0, 1000);
+    const angleRange = options.angleRange || new THREE.Vector2(-90, 90);
     const oiMaterial = options.orientedImageMaterial;
-    const classification = options.classification || ClassificationScheme.DEFAULT;
+    const classificationScheme = options.classification || ClassificationScheme.DEFAULT;
+    const discreteScheme = options.discreteScheme || DiscreteScheme.DEFAULT;
     const applyOpacityClassication = options.applyOpacityClassication == undefined ? false : options.applyOpacityClassication;
     const size = options.size || 0;
     const mode = options.mode || PNTS_MODE.COLOR;
@@ -172,9 +300,19 @@ class PointsMaterial extends THREE.RawShaderMaterial {
     const sizeMode = size === 0 ? PNTS_SIZE_MODE.ATTENUATED : options.sizeMode || PNTS_SIZE_MODE.VALUE;
     const minAttenuatedSize = options.minAttenuatedSize || 3;
     const maxAttenuatedSize = options.maxAttenuatedSize || 10;
-    delete options.orientedImageMaterial;
+    let gradients = Gradients;
+    if (options.gradient) {
+      gradients = {
+        ...options.gradient,
+        ...Gradients
+      };
+    }
     delete options.intensityRange;
-    delete options.classification;
+    delete options.elevationRange;
+    delete options.angleRange;
+    delete options.orientedImageMaterial;
+    delete options.classificationScheme;
+    delete options.discreteScheme;
     delete options.applyOpacityClassication;
     delete options.size;
     delete options.mode;
@@ -182,38 +320,56 @@ class PointsMaterial extends THREE.RawShaderMaterial {
     delete options.sizeMode;
     delete options.minAttenuatedSize;
     delete options.maxAttenuatedSize;
+    delete options.gradient;
     super(options);
+    this.gradients = gradients;
+    this.gradientTexture = new THREE.CanvasTexture();
     this.vertexShader = PointsVS;
     const scale = options.scale || 0.05 * 0.5 / Math.tan(1.0 / 2.0); // autosizing scale
 
-    _CommonMaterial.default.setDefineMapping(this, 'PNTS_MODE', PNTS_MODE);
-    _CommonMaterial.default.setDefineMapping(this, 'PNTS_SHAPE', PNTS_SHAPE);
-    _CommonMaterial.default.setDefineMapping(this, 'PNTS_SIZE_MODE', PNTS_SIZE_MODE);
-    _CommonMaterial.default.setUniformProperty(this, 'size', size);
-    _CommonMaterial.default.setUniformProperty(this, 'mode', mode);
-    _CommonMaterial.default.setUniformProperty(this, 'shape', shape);
-    _CommonMaterial.default.setUniformProperty(this, 'picking', false);
-    _CommonMaterial.default.setUniformProperty(this, 'opacity', this.opacity);
-    _CommonMaterial.default.setUniformProperty(this, 'overlayColor', options.overlayColor || new THREE.Vector4(0, 0, 0, 0));
-    _CommonMaterial.default.setUniformProperty(this, 'intensityRange', intensityRange);
-    _CommonMaterial.default.setUniformProperty(this, 'applyOpacityClassication', applyOpacityClassication);
-    _CommonMaterial.default.setUniformProperty(this, 'sizeMode', sizeMode);
-    _CommonMaterial.default.setUniformProperty(this, 'scale', scale);
-    _CommonMaterial.default.setUniformProperty(this, 'minAttenuatedSize', minAttenuatedSize);
-    _CommonMaterial.default.setUniformProperty(this, 'maxAttenuatedSize', maxAttenuatedSize);
+    CommonMaterial.setDefineMapping(this, 'PNTS_MODE', PNTS_MODE);
+    CommonMaterial.setDefineMapping(this, 'PNTS_SHAPE', PNTS_SHAPE);
+    CommonMaterial.setDefineMapping(this, 'PNTS_SIZE_MODE', PNTS_SIZE_MODE);
+    CommonMaterial.setUniformProperty(this, 'size', size);
+    CommonMaterial.setUniformProperty(this, 'mode', mode);
+    CommonMaterial.setUniformProperty(this, 'shape', shape);
+    CommonMaterial.setUniformProperty(this, 'picking', false);
+    CommonMaterial.setUniformProperty(this, 'opacity', this.opacity);
+    CommonMaterial.setUniformProperty(this, 'overlayColor', options.overlayColor || new THREE.Vector4(0, 0, 0, 0));
+    CommonMaterial.setUniformProperty(this, 'intensityRange', intensityRange);
+    CommonMaterial.setUniformProperty(this, 'elevationRange', elevationRange);
+    CommonMaterial.setUniformProperty(this, 'angleRange', angleRange);
+    CommonMaterial.setUniformProperty(this, 'applyOpacityClassication', applyOpacityClassication);
+    CommonMaterial.setUniformProperty(this, 'sizeMode', sizeMode);
+    CommonMaterial.setUniformProperty(this, 'scale', scale);
+    CommonMaterial.setUniformProperty(this, 'minAttenuatedSize', minAttenuatedSize);
+    CommonMaterial.setUniformProperty(this, 'maxAttenuatedSize', maxAttenuatedSize);
 
     // add classification texture to apply classification lut.
     const data = new Uint8Array(256 * 4);
     const texture = new THREE.DataTexture(data, 256, 1, THREE.RGBAFormat);
     texture.needsUpdate = true;
     texture.magFilter = THREE.NearestFilter;
-    _CommonMaterial.default.setUniformProperty(this, 'classificationLUT', texture);
+    CommonMaterial.setUniformProperty(this, 'classificationTexture', texture);
+
+    // add texture to applying the discrete lut.
+    const dataLUT = new Uint8Array(256 * 4);
+    const textureLUT = new THREE.DataTexture(dataLUT, 256, 1, THREE.RGBAFormat);
+    textureLUT.needsUpdate = true;
+    textureLUT.magFilter = THREE.NearestFilter;
+    CommonMaterial.setUniformProperty(this, 'discreteTexture', textureLUT);
 
-    // Classification scheme
-    this.classification = classification;
+    // Classification and other discrete values scheme
+    this.classificationScheme = classificationScheme;
+    this.discreteScheme = discreteScheme;
 
-    // Update classification
+    // Update classification and discrete Texture
     this.recomputeClassification();
+    this.recomputeDiscreteTexture();
+
+    // Gradient texture for continuous values
+    this.gradient = Object.values(gradients)[0];
+    CommonMaterial.setUniformProperty(this, 'gradientTexture', this.gradientTexture);
     if (oiMaterial) {
       this.uniforms.projectiveTextureAlphaBorder = oiMaterial.uniforms.projectiveTextureAlphaBorder;
       this.uniforms.projectiveTextureDistortion = oiMaterial.uniforms.projectiveTextureDistortion;
@@ -226,56 +382,26 @@ class PointsMaterial extends THREE.RawShaderMaterial {
       this.defines.DEBUG_ALPHA_BORDER = oiMaterial.defines.DEBUG_ALPHA_BORDER;
       this.defines.USE_TEXTURES_PROJECTIVE = true;
       this.defines.USE_BASE_MATERIAL = true;
-      this.fragmentShader = _ShaderUtils.default.unrollLoops(PointsFS, this.defines);
+      // three loop unrolling of ShaderMaterial only supports integer
+      // bounds, see https://github.com/mrdoob/three.js/issues/28020
+      this.fragmentShader = ShaderUtils.unrollLoops(PointsFS, this.defines);
     } else {
       this.fragmentShader = PointsFS;
     }
-    if (_Capabilities.default.isLogDepthBufferSupported()) {
-      this.defines.USE_LOGDEPTHBUF = 1;
-      this.defines.USE_LOGDEPTHBUF_EXT = 1;
-    }
   }
   recomputeClassification() {
-    const classification = this.classification;
-    const data = this.classificationLUT.image.data;
-    const width = this.classificationLUT.image.width;
-    for (let i = 0; i < width; i++) {
-      let color;
-      let opacity;
-      let visible = true;
-      if (classification[i]) {
-        color = classification[i].color;
-        visible = classification[i].visible;
-        opacity = classification[i].opacity;
-      } else if (classification[i % 32]) {
-        color = classification[i % 32].color;
-        visible = classification[i % 32].visible;
-        opacity = classification[i % 32].opacity;
-      } else if (classification.DEFAULT) {
-        color = classification.DEFAULT.color;
-        visible = classification.DEFAULT.visible;
-        opacity = classification.DEFAULT.opacity;
-      } else {
-        color = white;
-        opacity = 1.0;
-      }
-      const j = 4 * i;
-      data[j + 0] = parseInt(255 * color.r, 10);
-      data[j + 1] = parseInt(255 * color.g, 10);
-      data[j + 2] = parseInt(255 * color.b, 10);
-      data[j + 3] = visible ? parseInt(255 * opacity, 10) : 0;
-    }
-    this.classificationLUT.needsUpdate = true;
+    recomputeTexture(this.classificationScheme, this.classificationTexture, 32);
     this.dispatchEvent({
       type: 'material_property_changed',
-      target: this
+      target: this.uniforms
     });
   }
-  onBeforeCompile(shader, renderer) {
-    if (renderer.capabilities.isWebGL2) {
-      this.defines.WEBGL2 = true;
-      shader.glslVersion = '300 es';
-    }
+  recomputeDiscreteTexture() {
+    recomputeTexture(this.discreteScheme, this.discreteTexture);
+    this.dispatchEvent({
+      type: 'material_property_changed',
+      target: this.uniforms
+    });
   }
   copy(source) {
     super.copy(source);
@@ -309,9 +435,13 @@ class PointsMaterial extends THREE.RawShaderMaterial {
     this.scale = source.scale;
     this.overlayColor.copy(source.overlayColor);
     this.intensityRange.copy(source.intensityRange);
+    this.elevationRange.copy(source.elevationRange);
+    this.angleRange.copy(source.angleRange);
     Object.assign(this.defines, source.defines);
     return this;
   }
+  set gradient(value) {
+    this.gradientTexture = generateGradientTexture(value);
+  }
 }
-var _default = PointsMaterial;
-exports.default = _default;
+export default PointsMaterial;