Cesium-Prequel/Source/Core/TerrainEncoding.js

import AttributeCompression from "./AttributeCompression.js";
import Cartesian2 from "./Cartesian2.js";
import Cartesian3 from "./Cartesian3.js";
import ComponentDatatype from "./ComponentDatatype.js";
import defaultValue from "./defaultValue.js";
import defined from "./defined.js";
import CesiumMath from "./Math.js";
import Matrix4 from "./Matrix4.js";
import TerrainQuantization from "./TerrainQuantization.js";

var cartesian3Scratch = new Cartesian3();
var cartesian3DimScratch = new Cartesian3();
var cartesian2Scratch = new Cartesian2();
var matrix4Scratch = new Matrix4();
var matrix4Scratch2 = new Matrix4();

var SHIFT_LEFT_12 = Math.pow(2.0, 12.0);

/**
 * Data used to quantize and pack the terrain mesh. The position can be unpacked for picking and all attributes
 * are unpacked in the vertex shader.
 *
 * @alias TerrainEncoding
 * @constructor
 *
 * @param {AxisAlignedBoundingBox} axisAlignedBoundingBox The bounds of the tile in the east-north-up coordinates at the tiles center.
 * @param {Number} minimumHeight The minimum height.
 * @param {Number} maximumHeight The maximum height.
 * @param {Matrix4} fromENU The east-north-up to fixed frame matrix at the center of the terrain mesh.
 * @param {Boolean} hasVertexNormals If the mesh has vertex normals.
 * @param {Boolean} [hasWebMercatorT=false] true if the terrain data includes a Web Mercator texture coordinate; otherwise, false.
 *
 * @private
 */
function TerrainEncoding(
  axisAlignedBoundingBox,
  minimumHeight,
  maximumHeight,
  fromENU,
  hasVertexNormals,
  hasWebMercatorT
) {
  var quantization = TerrainQuantization.NONE;
  var center;
  var toENU;
  var matrix;

  if (
    defined(axisAlignedBoundingBox) &&
    defined(minimumHeight) &&
    defined(maximumHeight) &&
    defined(fromENU)
  ) {
    var minimum = axisAlignedBoundingBox.minimum;
    var maximum = axisAlignedBoundingBox.maximum;

    var dimensions = Cartesian3.subtract(
      maximum,
      minimum,
      cartesian3DimScratch
    );
    var hDim = maximumHeight - minimumHeight;
    var maxDim = Math.max(Cartesian3.maximumComponent(dimensions), hDim);

    if (maxDim < SHIFT_LEFT_12 - 1.0) {
      quantization = TerrainQuantization.BITS12;
    } else {
      quantization = TerrainQuantization.NONE;
    }

    center = axisAlignedBoundingBox.center;
    toENU = Matrix4.inverseTransformation(fromENU, new Matrix4());

    var translation = Cartesian3.negate(minimum, cartesian3Scratch);
    Matrix4.multiply(
      Matrix4.fromTranslation(translation, matrix4Scratch),
      toENU,
      toENU
    );

    var scale = cartesian3Scratch;
    scale.x = 1.0 / dimensions.x;
    scale.y = 1.0 / dimensions.y;
    scale.z = 1.0 / dimensions.z;
    Matrix4.multiply(Matrix4.fromScale(scale, matrix4Scratch), toENU, toENU);

    matrix = Matrix4.clone(fromENU);
    Matrix4.setTranslation(matrix, Cartesian3.ZERO, matrix);

    fromENU = Matrix4.clone(fromENU, new Matrix4());

    var translationMatrix = Matrix4.fromTranslation(minimum, matrix4Scratch);
    var scaleMatrix = Matrix4.fromScale(dimensions, matrix4Scratch2);
    var st = Matrix4.multiply(translationMatrix, scaleMatrix, matrix4Scratch);

    Matrix4.multiply(fromENU, st, fromENU);
    Matrix4.multiply(matrix, st, matrix);
  }

  /**
   * How the vertices of the mesh were compressed.
   * @type {TerrainQuantization}
   */
  this.quantization = quantization;

  /**
   * The minimum height of the tile including the skirts.
   * @type {Number}
   */
  this.minimumHeight = minimumHeight;

  /**
   * The maximum height of the tile.
   * @type {Number}
   */
  this.maximumHeight = maximumHeight;

  /**
   * The center of the tile.
   * @type {Cartesian3}
   */
  this.center = center;

  /**
   * A matrix that takes a vertex from the tile, transforms it to east-north-up at the center and scales
   * it so each component is in the [0, 1] range.
   * @type {Matrix4}
   */
  this.toScaledENU = toENU;

  /**
   * A matrix that restores a vertex transformed with toScaledENU back to the earth fixed reference frame
   * @type {Matrix4}
   */
  this.fromScaledENU = fromENU;

  /**
   * The matrix used to decompress the terrain vertices in the shader for RTE rendering.
   * @type {Matrix4}
   */
  this.matrix = matrix;

  /**
   * The terrain mesh contains normals.
   * @type {Boolean}
   */
  this.hasVertexNormals = hasVertexNormals;

  /**
   * The terrain mesh contains a vertical texture coordinate following the Web Mercator projection.
   * @type {Boolean}
   */
  this.hasWebMercatorT = defaultValue(hasWebMercatorT, false);
}

TerrainEncoding.prototype.encode = function (
  vertexBuffer,
  bufferIndex,
  position,
  uv,
  height,
  normalToPack,
  webMercatorT
) {
  var u = uv.x;
  var v = uv.y;

  if (this.quantization === TerrainQuantization.BITS12) {
    position = Matrix4.multiplyByPoint(
      this.toScaledENU,
      position,
      cartesian3Scratch
    );

    position.x = CesiumMath.clamp(position.x, 0.0, 1.0);
    position.y = CesiumMath.clamp(position.y, 0.0, 1.0);
    position.z = CesiumMath.clamp(position.z, 0.0, 1.0);

    var hDim = this.maximumHeight - this.minimumHeight;
    var h = CesiumMath.clamp((height - this.minimumHeight) / hDim, 0.0, 1.0);

    Cartesian2.fromElements(position.x, position.y, cartesian2Scratch);
    var compressed0 = AttributeCompression.compressTextureCoordinates(
      cartesian2Scratch
    );

    Cartesian2.fromElements(position.z, h, cartesian2Scratch);
    var compressed1 = AttributeCompression.compressTextureCoordinates(
      cartesian2Scratch
    );

    Cartesian2.fromElements(u, v, cartesian2Scratch);
    var compressed2 = AttributeCompression.compressTextureCoordinates(
      cartesian2Scratch
    );

    vertexBuffer[bufferIndex++] = compressed0;
    vertexBuffer[bufferIndex++] = compressed1;
    vertexBuffer[bufferIndex++] = compressed2;

    if (this.hasWebMercatorT) {
      Cartesian2.fromElements(webMercatorT, 0.0, cartesian2Scratch);
      var compressed3 = AttributeCompression.compressTextureCoordinates(
        cartesian2Scratch
      );
      vertexBuffer[bufferIndex++] = compressed3;
    }
  } else {
    Cartesian3.subtract(position, this.center, cartesian3Scratch);

    vertexBuffer[bufferIndex++] = cartesian3Scratch.x;
    vertexBuffer[bufferIndex++] = cartesian3Scratch.y;
    vertexBuffer[bufferIndex++] = cartesian3Scratch.z;
    vertexBuffer[bufferIndex++] = height;
    vertexBuffer[bufferIndex++] = u;
    vertexBuffer[bufferIndex++] = v;

    if (this.hasWebMercatorT) {
      vertexBuffer[bufferIndex++] = webMercatorT;
    }
  }

  if (this.hasVertexNormals) {
    vertexBuffer[bufferIndex++] = AttributeCompression.octPackFloat(
      normalToPack
    );
  }

  return bufferIndex;
};

TerrainEncoding.prototype.decodePosition = function (buffer, index, result) {
  if (!defined(result)) {
    result = new Cartesian3();
  }

  index *= this.getStride();

  if (this.quantization === TerrainQuantization.BITS12) {
    var xy = AttributeCompression.decompressTextureCoordinates(
      buffer[index],
      cartesian2Scratch
    );
    result.x = xy.x;
    result.y = xy.y;

    var zh = AttributeCompression.decompressTextureCoordinates(
      buffer[index + 1],
      cartesian2Scratch
    );
    result.z = zh.x;

    return Matrix4.multiplyByPoint(this.fromScaledENU, result, result);
  }

  result.x = buffer[index];
  result.y = buffer[index + 1];
  result.z = buffer[index + 2];
  return Cartesian3.add(result, this.center, result);
};

TerrainEncoding.prototype.decodeTextureCoordinates = function (
  buffer,
  index,
  result
) {
  if (!defined(result)) {
    result = new Cartesian2();
  }

  index *= this.getStride();

  if (this.quantization === TerrainQuantization.BITS12) {
    return AttributeCompression.decompressTextureCoordinates(
      buffer[index + 2],
      result
    );
  }

  return Cartesian2.fromElements(buffer[index + 4], buffer[index + 5], result);
};

TerrainEncoding.prototype.decodeHeight = function (buffer, index) {
  index *= this.getStride();

  if (this.quantization === TerrainQuantization.BITS12) {
    var zh = AttributeCompression.decompressTextureCoordinates(
      buffer[index + 1],
      cartesian2Scratch
    );
    return (
      zh.y * (this.maximumHeight - this.minimumHeight) + this.minimumHeight
    );
  }

  return buffer[index + 3];
};

TerrainEncoding.prototype.decodeWebMercatorT = function (buffer, index) {
  index *= this.getStride();

  if (this.quantization === TerrainQuantization.BITS12) {
    return AttributeCompression.decompressTextureCoordinates(
      buffer[index + 3],
      cartesian2Scratch
    ).x;
  }

  return buffer[index + 6];
};

TerrainEncoding.prototype.getOctEncodedNormal = function (
  buffer,
  index,
  result
) {
  var stride = this.getStride();
  index = (index + 1) * stride - 1;

  var temp = buffer[index] / 256.0;
  var x = Math.floor(temp);
  var y = (temp - x) * 256.0;

  return Cartesian2.fromElements(x, y, result);
};

TerrainEncoding.prototype.getStride = function () {
  var vertexStride;

  switch (this.quantization) {
    case TerrainQuantization.BITS12:
      vertexStride = 3;
      break;
    default:
      vertexStride = 6;
  }

  if (this.hasWebMercatorT) {
    ++vertexStride;
  }

  if (this.hasVertexNormals) {
    ++vertexStride;
  }

  return vertexStride;
};

var attributesNone = {
  position3DAndHeight: 0,
  textureCoordAndEncodedNormals: 1,
};
var attributes = {
  compressed0: 0,
  compressed1: 1,
};

TerrainEncoding.prototype.getAttributes = function (buffer) {
  var datatype = ComponentDatatype.FLOAT;
  var sizeInBytes = ComponentDatatype.getSizeInBytes(datatype);
  var stride;

  if (this.quantization === TerrainQuantization.NONE) {
    var position3DAndHeightLength = 4;
    var numTexCoordComponents = 2;

    if (this.hasWebMercatorT) {
      ++numTexCoordComponents;
    }

    if (this.hasVertexNormals) {
      ++numTexCoordComponents;
    }

    stride = (position3DAndHeightLength + numTexCoordComponents) * sizeInBytes;

    return [
      {
        index: attributesNone.position3DAndHeight,
        vertexBuffer: buffer,
        componentDatatype: datatype,
        componentsPerAttribute: position3DAndHeightLength,
        offsetInBytes: 0,
        strideInBytes: stride,
      },
      {
        index: attributesNone.textureCoordAndEncodedNormals,
        vertexBuffer: buffer,
        componentDatatype: datatype,
        componentsPerAttribute: numTexCoordComponents,
        offsetInBytes: position3DAndHeightLength * sizeInBytes,
        strideInBytes: stride,
      },
    ];
  }

  var numCompressed0 = 3;
  var numCompressed1 = 0;

  if (this.hasWebMercatorT || this.hasVertexNormals) {
    ++numCompressed0;
  }

  if (this.hasWebMercatorT && this.hasVertexNormals) {
    ++numCompressed1;

    stride = (numCompressed0 + numCompressed1) * sizeInBytes;

    return [
      {
        index: attributes.compressed0,
        vertexBuffer: buffer,
        componentDatatype: datatype,
        componentsPerAttribute: numCompressed0,
        offsetInBytes: 0,
        strideInBytes: stride,
      },
      {
        index: attributes.compressed1,
        vertexBuffer: buffer,
        componentDatatype: datatype,
        componentsPerAttribute: numCompressed1,
        offsetInBytes: numCompressed0 * sizeInBytes,
        strideInBytes: stride,
      },
    ];
  }
  return [
    {
      index: attributes.compressed0,
      vertexBuffer: buffer,
      componentDatatype: datatype,
      componentsPerAttribute: numCompressed0,
    },
  ];
};

TerrainEncoding.prototype.getAttributeLocations = function () {
  if (this.quantization === TerrainQuantization.NONE) {
    return attributesNone;
  }
  return attributes;
};

TerrainEncoding.clone = function (encoding, result) {
  if (!defined(result)) {
    result = new TerrainEncoding();
  }

  result.quantization = encoding.quantization;
  result.minimumHeight = encoding.minimumHeight;
  result.maximumHeight = encoding.maximumHeight;
  result.center = Cartesian3.clone(encoding.center);
  result.toScaledENU = Matrix4.clone(encoding.toScaledENU);
  result.fromScaledENU = Matrix4.clone(encoding.fromScaledENU);
  result.matrix = Matrix4.clone(encoding.matrix);
  result.hasVertexNormals = encoding.hasVertexNormals;
  result.hasWebMercatorT = encoding.hasWebMercatorT;
  return result;
};
export default TerrainEncoding;