@cesium/engine 0.1.0

package/Source/Scene/BingMapsStyle.js

@@ -0,0 +1,93 @@
+/**
+ * The types of imagery provided by Bing Maps.
+ *
+ * @enum {Number}
+ *
+ * @see BingMapsImageryProvider
+ */
+const BingMapsStyle = {
+  /**
+   * Aerial imagery.
+   *
+   * @type {String}
+   * @constant
+   */
+  AERIAL: "Aerial",
+
+  /**
+   * Aerial imagery with a road overlay.
+   *
+   * @type {String}
+   * @constant
+   * @deprecated See https://github.com/CesiumGS/cesium/issues/7128.
+   * Use `BingMapsStyle.AERIAL_WITH_LABELS_ON_DEMAND` instead
+   */
+  AERIAL_WITH_LABELS: "AerialWithLabels",
+
+  /**
+   * Aerial imagery with a road overlay.
+   *
+   * @type {String}
+   * @constant
+   */
+  AERIAL_WITH_LABELS_ON_DEMAND: "AerialWithLabelsOnDemand",
+
+  /**
+   * Roads without additional imagery.
+   *
+   * @type {String}
+   * @constant
+   * @deprecated See https://github.com/CesiumGS/cesium/issues/7128.
+   * Use `BingMapsStyle.ROAD_ON_DEMAND` instead
+   */
+  ROAD: "Road",
+
+  /**
+   * Roads without additional imagery.
+   *
+   * @type {String}
+   * @constant
+   */
+  ROAD_ON_DEMAND: "RoadOnDemand",
+
+  /**
+   * A dark version of the road maps.
+   *
+   * @type {String}
+   * @constant
+   */
+  CANVAS_DARK: "CanvasDark",
+
+  /**
+   * A lighter version of the road maps.
+   *
+   * @type {String}
+   * @constant
+   */
+  CANVAS_LIGHT: "CanvasLight",
+
+  /**
+   * A grayscale version of the road maps.
+   *
+   * @type {String}
+   * @constant
+   */
+  CANVAS_GRAY: "CanvasGray",
+
+  /**
+   * Ordnance Survey imagery. This imagery is visible only for the London, UK area.
+   *
+   * @type {String}
+   * @constant
+   */
+  ORDNANCE_SURVEY: "OrdnanceSurvey",
+
+  /**
+   * Collins Bart imagery.
+   *
+   * @type {String}
+   * @constant
+   */
+  COLLINS_BART: "CollinsBart",
+};
+export default Object.freeze(BingMapsStyle);

package/Source/Scene/BlendEquation.js

@@ -0,0 +1,53 @@
+import WebGLConstants from "../Core/WebGLConstants.js";
+
+/**
+ * Determines how two pixels' values are combined.
+ *
+ * @enum {Number}
+ */
+const BlendEquation = {
+  /**
+   * Pixel values are added componentwise.  This is used in additive blending for translucency.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ADD: WebGLConstants.FUNC_ADD,
+
+  /**
+   * Pixel values are subtracted componentwise (source - destination).  This is used in alpha blending for translucency.
+   *
+   * @type {Number}
+   * @constant
+   */
+  SUBTRACT: WebGLConstants.FUNC_SUBTRACT,
+
+  /**
+   * Pixel values are subtracted componentwise (destination - source).
+   *
+   * @type {Number}
+   * @constant
+   */
+  REVERSE_SUBTRACT: WebGLConstants.FUNC_REVERSE_SUBTRACT,
+
+  /**
+   * Pixel values are given to the minimum function (min(source, destination)).
+   *
+   * This equation operates on each pixel color component.
+   *
+   * @type {Number}
+   * @constant
+   */
+  MIN: WebGLConstants.MIN,
+
+  /**
+   * Pixel values are given to the maximum function (max(source, destination)).
+   *
+   * This equation operates on each pixel color component.
+   *
+   * @type {Number}
+   * @constant
+   */
+  MAX: WebGLConstants.MAX,
+};
+export default Object.freeze(BlendEquation);

package/Source/Scene/BlendFunction.js

@@ -0,0 +1,129 @@
+import WebGLConstants from "../Core/WebGLConstants.js";
+
+/**
+ * Determines how blending factors are computed.
+ *
+ * @enum {Number}
+ */
+const BlendFunction = {
+  /**
+   * The blend factor is zero.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ZERO: WebGLConstants.ZERO,
+
+  /**
+   * The blend factor is one.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE: WebGLConstants.ONE,
+
+  /**
+   * The blend factor is the source color.
+   *
+   * @type {Number}
+   * @constant
+   */
+  SOURCE_COLOR: WebGLConstants.SRC_COLOR,
+
+  /**
+   * The blend factor is one minus the source color.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE_MINUS_SOURCE_COLOR: WebGLConstants.ONE_MINUS_SRC_COLOR,
+
+  /**
+   * The blend factor is the destination color.
+   *
+   * @type {Number}
+   * @constant
+   */
+  DESTINATION_COLOR: WebGLConstants.DST_COLOR,
+
+  /**
+   * The blend factor is one minus the destination color.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE_MINUS_DESTINATION_COLOR: WebGLConstants.ONE_MINUS_DST_COLOR,
+
+  /**
+   * The blend factor is the source alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  SOURCE_ALPHA: WebGLConstants.SRC_ALPHA,
+
+  /**
+   * The blend factor is one minus the source alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE_MINUS_SOURCE_ALPHA: WebGLConstants.ONE_MINUS_SRC_ALPHA,
+
+  /**
+   * The blend factor is the destination alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  DESTINATION_ALPHA: WebGLConstants.DST_ALPHA,
+
+  /**
+   * The blend factor is one minus the destination alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE_MINUS_DESTINATION_ALPHA: WebGLConstants.ONE_MINUS_DST_ALPHA,
+
+  /**
+   * The blend factor is the constant color.
+   *
+   * @type {Number}
+   * @constant
+   */
+  CONSTANT_COLOR: WebGLConstants.CONSTANT_COLOR,
+
+  /**
+   * The blend factor is one minus the constant color.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE_MINUS_CONSTANT_COLOR: WebGLConstants.ONE_MINUS_CONSTANT_COLOR,
+
+  /**
+   * The blend factor is the constant alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  CONSTANT_ALPHA: WebGLConstants.CONSTANT_ALPHA,
+
+  /**
+   * The blend factor is one minus the constant alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  ONE_MINUS_CONSTANT_ALPHA: WebGLConstants.ONE_MINUS_CONSTANT_ALPHA,
+
+  /**
+   * The blend factor is the saturated source alpha.
+   *
+   * @type {Number}
+   * @constant
+   */
+  SOURCE_ALPHA_SATURATE: WebGLConstants.SRC_ALPHA_SATURATE,
+};
+export default Object.freeze(BlendFunction);

package/Source/Scene/BlendOption.js

@@ -0,0 +1,28 @@
+/**
+ * Determines how opaque and translucent parts of billboards, points, and labels are blended with the scene.
+ *
+ * @enum {Number}
+ */
+const BlendOption = {
+  /**
+   * The billboards, points, or labels in the collection are completely opaque.
+   * @type {Number}
+   * @constant
+   */
+  OPAQUE: 0,
+
+  /**
+   * The billboards, points, or labels in the collection are completely translucent.
+   * @type {Number}
+   * @constant
+   */
+  TRANSLUCENT: 1,
+
+  /**
+   * The billboards, points, or labels in the collection are both opaque and translucent.
+   * @type {Number}
+   * @constant
+   */
+  OPAQUE_AND_TRANSLUCENT: 2,
+};
+export default Object.freeze(BlendOption);

package/Source/Scene/BlendingState.js

@@ -0,0 +1,73 @@
+import BlendEquation from "./BlendEquation.js";
+import BlendFunction from "./BlendFunction.js";
+
+/**
+ * The blending state combines {@link BlendEquation} and {@link BlendFunction} and the
+ * <code>enabled</code> flag to define the full blending state for combining source and
+ * destination fragments when rendering.
+ * <p>
+ * This is a helper when using custom render states with {@link Appearance#renderState}.
+ * </p>
+ *
+ * @namespace
+ */
+const BlendingState = {
+  /**
+   * Blending is disabled.
+   *
+   * @type {Object}
+   * @constant
+   */
+  DISABLED: Object.freeze({
+    enabled: false,
+  }),
+
+  /**
+   * Blending is enabled using alpha blending, <code>source(source.alpha) + destination(1 - source.alpha)</code>.
+   *
+   * @type {Object}
+   * @constant
+   */
+  ALPHA_BLEND: Object.freeze({
+    enabled: true,
+    equationRgb: BlendEquation.ADD,
+    equationAlpha: BlendEquation.ADD,
+    functionSourceRgb: BlendFunction.SOURCE_ALPHA,
+    functionSourceAlpha: BlendFunction.ONE,
+    functionDestinationRgb: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+    functionDestinationAlpha: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+  }),
+
+  /**
+   * Blending is enabled using alpha blending with premultiplied alpha, <code>source + destination(1 - source.alpha)</code>.
+   *
+   * @type {Object}
+   * @constant
+   */
+  PRE_MULTIPLIED_ALPHA_BLEND: Object.freeze({
+    enabled: true,
+    equationRgb: BlendEquation.ADD,
+    equationAlpha: BlendEquation.ADD,
+    functionSourceRgb: BlendFunction.ONE,
+    functionSourceAlpha: BlendFunction.ONE,
+    functionDestinationRgb: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+    functionDestinationAlpha: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+  }),
+
+  /**
+   * Blending is enabled using additive blending, <code>source(source.alpha) + destination</code>.
+   *
+   * @type {Object}
+   * @constant
+   */
+  ADDITIVE_BLEND: Object.freeze({
+    enabled: true,
+    equationRgb: BlendEquation.ADD,
+    equationAlpha: BlendEquation.ADD,
+    functionSourceRgb: BlendFunction.SOURCE_ALPHA,
+    functionSourceAlpha: BlendFunction.ONE,
+    functionDestinationRgb: BlendFunction.ONE,
+    functionDestinationAlpha: BlendFunction.ONE,
+  }),
+};
+export default Object.freeze(BlendingState);

package/Source/Scene/BoxEmitter.js

@@ -0,0 +1,75 @@
+import Cartesian3 from "../Core/Cartesian3.js";
+import Check from "../Core/Check.js";
+import defaultValue from "../Core/defaultValue.js";
+import CesiumMath from "../Core/Math.js";
+
+const defaultDimensions = new Cartesian3(1.0, 1.0, 1.0);
+
+/**
+ * A ParticleEmitter that emits particles within a box.
+ * Particles will be positioned randomly within the box and have initial velocities emanating from the center of the box.
+ *
+ * @alias BoxEmitter
+ * @constructor
+ *
+ * @param {Cartesian3} dimensions The width, height and depth dimensions of the box.
+ */
+function BoxEmitter(dimensions) {
+  dimensions = defaultValue(dimensions, defaultDimensions);
+
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("dimensions", dimensions);
+  Check.typeOf.number.greaterThanOrEquals("dimensions.x", dimensions.x, 0.0);
+  Check.typeOf.number.greaterThanOrEquals("dimensions.y", dimensions.y, 0.0);
+  Check.typeOf.number.greaterThanOrEquals("dimensions.z", dimensions.z, 0.0);
+  //>>includeEnd('debug');
+
+  this._dimensions = Cartesian3.clone(dimensions);
+}
+
+Object.defineProperties(BoxEmitter.prototype, {
+  /**
+   * The width, height and depth dimensions of the box in meters.
+   * @memberof BoxEmitter.prototype
+   * @type {Cartesian3}
+   * @default new Cartesian3(1.0, 1.0, 1.0)
+   */
+  dimensions: {
+    get: function () {
+      return this._dimensions;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      Check.defined("value", value);
+      Check.typeOf.number.greaterThanOrEquals("value.x", value.x, 0.0);
+      Check.typeOf.number.greaterThanOrEquals("value.y", value.y, 0.0);
+      Check.typeOf.number.greaterThanOrEquals("value.z", value.z, 0.0);
+      //>>includeEnd('debug');
+      Cartesian3.clone(value, this._dimensions);
+    },
+  },
+});
+
+const scratchHalfDim = new Cartesian3();
+
+/**
+ * Initializes the given {Particle} by setting it's position and velocity.
+ *
+ * @private
+ * @param {Particle} particle The particle to initialize.
+ */
+BoxEmitter.prototype.emit = function (particle) {
+  const dim = this._dimensions;
+  const halfDim = Cartesian3.multiplyByScalar(dim, 0.5, scratchHalfDim);
+
+  const x = CesiumMath.randomBetween(-halfDim.x, halfDim.x);
+  const y = CesiumMath.randomBetween(-halfDim.y, halfDim.y);
+  const z = CesiumMath.randomBetween(-halfDim.z, halfDim.z);
+
+  particle.position = Cartesian3.fromElements(x, y, z, particle.position);
+  particle.velocity = Cartesian3.normalize(
+    particle.position,
+    particle.velocity
+  );
+};
+export default BoxEmitter;

package/Source/Scene/BrdfLutGenerator.js

@@ -0,0 +1,75 @@
+import BoundingRectangle from "../Core/BoundingRectangle.js";
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import Framebuffer from "../Renderer/Framebuffer.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import RenderState from "../Renderer/RenderState.js";
+import Sampler from "../Renderer/Sampler.js";
+import Texture from "../Renderer/Texture.js";
+import BrdfLutGeneratorFS from "../Shaders/BrdfLutGeneratorFS.js";
+
+/**
+ * @private
+ */
+function BrdfLutGenerator() {
+  this._colorTexture = undefined;
+  this._drawCommand = undefined;
+}
+
+Object.defineProperties(BrdfLutGenerator.prototype, {
+  colorTexture: {
+    get: function () {
+      return this._colorTexture;
+    },
+  },
+});
+
+function createCommand(generator, context, framebuffer) {
+  const drawCommand = context.createViewportQuadCommand(BrdfLutGeneratorFS, {
+    framebuffer: framebuffer,
+    renderState: RenderState.fromCache({
+      viewport: new BoundingRectangle(0.0, 0.0, 256.0, 256.0),
+    }),
+  });
+
+  generator._drawCommand = drawCommand;
+}
+
+BrdfLutGenerator.prototype.update = function (frameState) {
+  if (!defined(this._colorTexture)) {
+    const context = frameState.context;
+    const colorTexture = new Texture({
+      context: context,
+      width: 256,
+      height: 256,
+      pixelFormat: PixelFormat.RGBA,
+      pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+      sampler: Sampler.NEAREST,
+    });
+
+    this._colorTexture = colorTexture;
+    const framebuffer = new Framebuffer({
+      context: context,
+      colorTextures: [colorTexture],
+      destroyAttachments: false,
+    });
+
+    createCommand(this, context, framebuffer);
+    this._drawCommand.execute(context);
+    framebuffer.destroy();
+    this._drawCommand.shaderProgram =
+      this._drawCommand.shaderProgram &&
+      this._drawCommand.shaderProgram.destroy();
+  }
+};
+
+BrdfLutGenerator.prototype.isDestroyed = function () {
+  return false;
+};
+
+BrdfLutGenerator.prototype.destroy = function () {
+  this._colorTexture = this._colorTexture && this._colorTexture.destroy();
+  return destroyObject(this);
+};
+export default BrdfLutGenerator;

package/Source/Scene/BufferLoader.js

@@ -0,0 +1,146 @@
+import defaultValue from "../Core/defaultValue.js";
+import defined from "../Core/defined.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import ResourceLoader from "./ResourceLoader.js";
+import ResourceLoaderState from "./ResourceLoaderState.js";
+
+/**
+ * Loads an embedded or external buffer.
+ * <p>
+ * Implements the {@link ResourceLoader} interface.
+ * </p>
+ *
+ * @alias BufferLoader
+ * @constructor
+ * @augments ResourceLoader
+ *
+ * @param {Object} options Object with the following properties:
+ * @param {Uint8Array} [options.typedArray] The typed array containing the embedded buffer contents. Mutually exclusive with options.resource.
+ * @param {Resource} [options.resource] The {@link Resource} pointing to the external buffer. Mutually exclusive with options.typedArray.
+ * @param {String} [options.cacheKey] The cache key of the resource.
+ *
+ * @exception {DeveloperError} One of options.typedArray and options.resource must be defined.
+ *
+ * @private
+ */
+function BufferLoader(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  const typedArray = options.typedArray;
+  const resource = options.resource;
+  const cacheKey = options.cacheKey;
+
+  //>>includeStart('debug', pragmas.debug);
+  if (defined(typedArray) === defined(resource)) {
+    throw new DeveloperError(
+      "One of options.typedArray and options.resource must be defined."
+    );
+  }
+  //>>includeEnd('debug');
+
+  this._typedArray = typedArray;
+  this._resource = resource;
+  this._cacheKey = cacheKey;
+  this._state = ResourceLoaderState.UNLOADED;
+  this._promise = undefined;
+}
+
+if (defined(Object.create)) {
+  BufferLoader.prototype = Object.create(ResourceLoader.prototype);
+  BufferLoader.prototype.constructor = BufferLoader;
+}
+
+Object.defineProperties(BufferLoader.prototype, {
+  /**
+   * A promise that resolves to the resource when the resource is ready, or undefined if the resource hasn't started loading.
+   *
+   * @memberof BufferLoader.prototype
+   *
+   * @type {Promise.<BufferLoader>|undefined}
+   * @readonly
+   */
+  promise: {
+    get: function () {
+      return this._promise;
+    },
+  },
+  /**
+   * The cache key of the resource.
+   *
+   * @memberof BufferLoader.prototype
+   *
+   * @type {String}
+   * @readonly
+   */
+  cacheKey: {
+    get: function () {
+      return this._cacheKey;
+    },
+  },
+  /**
+   * The typed array containing the embedded buffer contents.
+   *
+   * @memberof BufferLoader.prototype
+   *
+   * @type {Uint8Array}
+   * @readonly
+   */
+  typedArray: {
+    get: function () {
+      return this._typedArray;
+    },
+  },
+});
+
+/**
+ * Loads the resource.
+ * @returns {Promise.<BufferLoader>} A promise which resolves to the loader when the resource loading is completed.
+ * @private
+ */
+BufferLoader.prototype.load = function () {
+  if (defined(this._typedArray)) {
+    this._promise = Promise.resolve(this);
+  } else {
+    this._promise = loadExternalBuffer(this);
+  }
+  return this._promise;
+};
+
+function loadExternalBuffer(bufferLoader) {
+  const resource = bufferLoader._resource;
+  bufferLoader._state = ResourceLoaderState.LOADING;
+  return BufferLoader._fetchArrayBuffer(resource)
+    .then(function (arrayBuffer) {
+      if (bufferLoader.isDestroyed()) {
+        return;
+      }
+      bufferLoader._typedArray = new Uint8Array(arrayBuffer);
+      bufferLoader._state = ResourceLoaderState.READY;
+      return bufferLoader;
+    })
+    .catch(function (error) {
+      if (bufferLoader.isDestroyed()) {
+        return;
+      }
+      bufferLoader._state = ResourceLoaderState.FAILED;
+      const errorMessage = `Failed to load external buffer: ${resource.url}`;
+      return Promise.reject(bufferLoader.getError(errorMessage, error));
+    });
+}
+
+/**
+ * Exposed for testing
+ * @private
+ */
+BufferLoader._fetchArrayBuffer = function (resource) {
+  return resource.fetchArrayBuffer();
+};
+
+/**
+ * Unloads the resource.
+ * @private
+ */
+BufferLoader.prototype.unload = function () {
+  this._typedArray = undefined;
+};
+
+export default BufferLoader;