@cesium/engine 0.1.0

package/Source/Scene/Model/ModelArticulation.js

@@ -0,0 +1,214 @@
+import Check from "../../Core/Check.js";
+import defaultValue from "../../Core/defaultValue.js";
+import defined from "../../Core/defined.js";
+import Matrix4 from "../../Core/Matrix4.js";
+import ModelArticulationStage from "./ModelArticulationStage.js";
+
+/**
+ * An in-memory representation of an articulation that affects nodes in the
+ * {@link ModelSceneGraph}. This is defined in a model by the
+ * <code>AGI_articulations</code> extension.
+ *
+ * @param {Object} options An object containing the following options:
+ * @param {ModelComponents.Articulation} options.articulation The articulation components from the 3D model.
+ * @param {ModelSceneGraph} options.sceneGraph The scene graph this articulation belongs to.
+ *
+ * @alias ModelArticulation
+ * @constructor
+ *
+ * @private
+ */
+function ModelArticulation(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  const articulation = options.articulation;
+  const sceneGraph = options.sceneGraph;
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("options.articulation", articulation);
+  Check.typeOf.object("options.sceneGraph", sceneGraph);
+  //>>includeEnd('debug');
+
+  this._articulation = articulation;
+  this._sceneGraph = sceneGraph;
+
+  this._name = articulation.name;
+  this._runtimeStages = [];
+  this._runtimeStagesByName = {};
+
+  // Will be populated as the runtime nodes are created
+  this._runtimeNodes = [];
+
+  // Set to true so that the first call to
+  // ModelSceneGraph.applyArticulations will work.
+  this._dirty = true;
+
+  initialize(this);
+}
+
+Object.defineProperties(ModelArticulation.prototype, {
+  /**
+   * The internal articulation that this runtime articulation represents.
+   *
+   * @memberof ModelArticulation.prototype
+   * @type {ModelComponents.Articulation}
+   * @readonly
+   *
+   * @private
+   */
+  articulation: {
+    get: function () {
+      return this._articulation;
+    },
+  },
+
+  /**
+   * The scene graph that this articulation belongs to.
+   *
+   * @memberof ModelArticulation.prototype
+   * @type {ModelSceneGraph}
+   * @readonly
+   *
+   * @private
+   */
+  sceneGraph: {
+    get: function () {
+      return this._sceneGraph;
+    },
+  },
+
+  /**
+   * The name of this articulation.
+   *
+   * @memberof ModelArticulation.prototype
+   * @type {String}
+   * @readonly
+   *
+   * @private
+   */
+  name: {
+    get: function () {
+      return this._name;
+    },
+  },
+
+  /**
+   * The runtime stages that belong to this articulation.
+   *
+   * @memberof ModelArticulation.prototype
+   * @type {ModelArticulationStage[]}
+   * @readonly
+   *
+   * @private
+   */
+  runtimeStages: {
+    get: function () {
+      return this._runtimeStages;
+    },
+  },
+
+  /**
+   * The runtime nodes that are affected by this articulation.
+   *
+   * @memberof ModelArticulation.prototype
+   * @type {ModelRuntimeNode[]}
+   * @readonly
+   *
+   * @private
+   */
+  runtimeNodes: {
+    get: function () {
+      return this._runtimeNodes;
+    },
+  },
+});
+
+function initialize(runtimeArticulation) {
+  const articulation = runtimeArticulation.articulation;
+
+  const stages = articulation.stages;
+  const length = stages.length;
+
+  const runtimeStages = runtimeArticulation._runtimeStages;
+  const runtimeStagesByName = runtimeArticulation._runtimeStagesByName;
+  for (let i = 0; i < length; i++) {
+    const stage = stages[i];
+    const runtimeStage = new ModelArticulationStage({
+      stage: stage,
+      runtimeArticulation: runtimeArticulation,
+    });
+
+    // Store the stages in an array to preserve the order in which
+    // they appeared in the 3D model.
+    runtimeStages.push(runtimeStage);
+
+    // Store the stages in a dictionary for retrieval by name.
+    const stageName = stage.name;
+    runtimeStagesByName[stageName] = runtimeStage;
+  }
+}
+
+/**
+ * Sets the current value of an articulation stage.
+ *
+ * @param {String} stageName The name of the articulation stage.
+ * @param {Number} value The numeric value of this stage of the articulation.
+ *
+ * @private
+ */
+ModelArticulation.prototype.setArticulationStage = function (stageName, value) {
+  const stage = this._runtimeStagesByName[stageName];
+  if (defined(stage)) {
+    stage.currentValue = value;
+  }
+};
+
+const scratchArticulationMatrix = new Matrix4();
+const scratchNodeMatrix = new Matrix4();
+
+/**
+ * Applies the chain of articulation stages to the transform of each node that
+ * participates in the articulation. This only recomputes the node transforms
+ * if any stage in the articulation has been modified.
+ * <p>
+ * Note that this will overwrite any existing transformations on participating
+ * nodes.
+ * </p>
+ *
+ * @private
+ */
+ModelArticulation.prototype.apply = function () {
+  if (!this._dirty) {
+    return;
+  }
+  this._dirty = false;
+
+  let articulationMatrix = Matrix4.clone(
+    Matrix4.IDENTITY,
+    scratchArticulationMatrix
+  );
+
+  let i;
+  const stages = this._runtimeStages;
+  const stagesLength = stages.length;
+
+  // Compute the result of the articulation stages...
+  for (i = 0; i < stagesLength; i++) {
+    const stage = stages[i];
+    articulationMatrix = stage.applyStageToMatrix(articulationMatrix);
+  }
+
+  // ...then apply it to the transforms of the affected nodes.
+  const nodes = this._runtimeNodes;
+  const nodesLength = nodes.length;
+  for (i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+    const transform = Matrix4.multiplyTransformation(
+      node.originalTransform,
+      articulationMatrix,
+      scratchNodeMatrix
+    );
+    node.transform = transform;
+  }
+};
+
+export default ModelArticulation;

package/Source/Scene/Model/ModelArticulationStage.js

@@ -0,0 +1,261 @@
+import ArticulationStageType from "../../Core/ArticulationStageType.js";
+import Cartesian3 from "../../Core/Cartesian3.js";
+import CesiumMath from "../../Core/Math.js";
+import Check from "../../Core/Check.js";
+import defaultValue from "../../Core/defaultValue.js";
+import Matrix3 from "../../Core/Matrix3.js";
+import Matrix4 from "../../Core/Matrix4.js";
+
+const articulationEpsilon = CesiumMath.EPSILON16;
+
+/**
+ * An in-memory representation of an articulation stage belonging to a
+ * {@link ModelArticulation}.
+ *
+ * @param {Object} options An object containing the following options:
+ * @param {ModelComponents.ArticulationStage} options.stage The articulation stage components from the 3D model.
+ * @param {ModelArticulation} options.runtimeArticulation The runtime articulation that this stage belongs to.
+ *
+ * @alias ModelArticulationStage
+ * @constructor
+ *
+ * @private
+ */
+function ModelArticulationStage(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  const stage = options.stage;
+  const runtimeArticulation = options.runtimeArticulation;
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("options.stage", stage);
+  Check.typeOf.object("options.runtimeArticulation", runtimeArticulation);
+  //>>includeEnd('debug');
+
+  this._stage = stage;
+  this._runtimeArticulation = runtimeArticulation;
+
+  this._name = stage.name;
+  this._type = stage.type;
+  this._minimumValue = stage.minimumValue;
+  this._maximumValue = stage.maximumValue;
+  this._currentValue = stage.initialValue;
+}
+
+Object.defineProperties(ModelArticulationStage.prototype, {
+  /**
+   * The internal articulation stage that this runtime stage represents.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {ModelComponents.ArticulationStage}
+   * @readonly
+   *
+   * @private
+   */
+  stage: {
+    get: function () {
+      return this._stage;
+    },
+  },
+
+  /**
+   * The runtime articulation that this stage belongs to.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {ModelArticulation}
+   * @readonly
+   *
+   * @private
+   */
+  runtimeArticulation: {
+    get: function () {
+      return this._runtimeArticulation;
+    },
+  },
+
+  /**
+   * The name of this articulation stage.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {String}
+   * @readonly
+   *
+   * @private
+   */
+  name: {
+    get: function () {
+      return this._name;
+    },
+  },
+
+  /**
+   * The type of this articulation stage. This specifies which of the
+   * node's properties is modified by the stage's value.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {ArticulationStageType}
+   * @readonly
+   *
+   * @private
+   */
+  type: {
+    get: function () {
+      return this._type;
+    },
+  },
+
+  /**
+   * The minimum value of this articulation stage.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {Number}
+   * @readonly
+   *
+   * @private
+   */
+  minimumValue: {
+    get: function () {
+      return this._minimumValue;
+    },
+  },
+
+  /**
+   * The maximum value of this articulation stage.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {Number}
+   * @readonly
+   *
+   * @private
+   */
+  maximumValue: {
+    get: function () {
+      return this._maximumValue;
+    },
+  },
+
+  /**
+   * The current value of this articulation stage.
+   *
+   * @memberof ModelArticulationStage.prototype
+   * @type {Number}
+   *
+   * @private
+   */
+  currentValue: {
+    get: function () {
+      return this._currentValue;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      Check.typeOf.number("value", value);
+      //>>includeEnd('debug');
+
+      value = CesiumMath.clamp(value, this.minimumValue, this.maximumValue);
+      if (
+        !CesiumMath.equalsEpsilon(
+          this._currentValue,
+          value,
+          articulationEpsilon
+        )
+      ) {
+        this._currentValue = value;
+        this.runtimeArticulation._dirty = true;
+      }
+    },
+  },
+});
+
+const scratchArticulationCartesian = new Cartesian3();
+const scratchArticulationRotation = new Matrix3();
+
+/**
+ * Modifies a Matrix4 by applying a transformation for a given value of a stage.
+ * Note that the <code>result</code> parameter is not just a container for the
+ * returned value. The incoming value of <code>result</code> is part of the
+ * computation itself. Various stages of an articulation can be multiplied
+ * together, so their transformations are all merged into a composite Matrix4
+ * representing them all.
+ *
+ * @param {Matrix4} result The matrix to be modified.
+ * @returns {Matrix4} The transformed matrix as requested by the articulation stage.
+ *
+ * @private
+ */
+ModelArticulationStage.prototype.applyStageToMatrix = function (result) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("result", result);
+  //>>includeEnd('debug');
+
+  const type = this.type;
+  const value = this.currentValue;
+  const cartesian = scratchArticulationCartesian;
+  let rotation;
+  switch (type) {
+    case ArticulationStageType.XROTATE:
+      rotation = Matrix3.fromRotationX(
+        CesiumMath.toRadians(value),
+        scratchArticulationRotation
+      );
+      result = Matrix4.multiplyByMatrix3(result, rotation, result);
+      break;
+    case ArticulationStageType.YROTATE:
+      rotation = Matrix3.fromRotationY(
+        CesiumMath.toRadians(value),
+        scratchArticulationRotation
+      );
+      result = Matrix4.multiplyByMatrix3(result, rotation, result);
+      break;
+    case ArticulationStageType.ZROTATE:
+      rotation = Matrix3.fromRotationZ(
+        CesiumMath.toRadians(value),
+        scratchArticulationRotation
+      );
+      result = Matrix4.multiplyByMatrix3(result, rotation, result);
+      break;
+    case ArticulationStageType.XTRANSLATE:
+      cartesian.x = value;
+      cartesian.y = 0.0;
+      cartesian.z = 0.0;
+      result = Matrix4.multiplyByTranslation(result, cartesian, result);
+      break;
+    case ArticulationStageType.YTRANSLATE:
+      cartesian.x = 0.0;
+      cartesian.y = value;
+      cartesian.z = 0.0;
+      result = Matrix4.multiplyByTranslation(result, cartesian, result);
+      break;
+    case ArticulationStageType.ZTRANSLATE:
+      cartesian.x = 0.0;
+      cartesian.y = 0.0;
+      cartesian.z = value;
+      result = Matrix4.multiplyByTranslation(result, cartesian, result);
+      break;
+    case ArticulationStageType.XSCALE:
+      cartesian.x = value;
+      cartesian.y = 1.0;
+      cartesian.z = 1.0;
+      result = Matrix4.multiplyByScale(result, cartesian, result);
+      break;
+    case ArticulationStageType.YSCALE:
+      cartesian.x = 1.0;
+      cartesian.y = value;
+      cartesian.z = 1.0;
+      result = Matrix4.multiplyByScale(result, cartesian, result);
+      break;
+    case ArticulationStageType.ZSCALE:
+      cartesian.x = 1.0;
+      cartesian.y = 1.0;
+      cartesian.z = value;
+      result = Matrix4.multiplyByScale(result, cartesian, result);
+      break;
+    case ArticulationStageType.UNIFORMSCALE:
+      result = Matrix4.multiplyByUniformScale(result, value, result);
+      break;
+    default:
+      break;
+  }
+
+  return result;
+};
+
+export default ModelArticulationStage;

package/Source/Scene/Model/ModelClippingPlanesPipelineStage.js

@@ -0,0 +1,126 @@
+import Cartesian2 from "../../Core/Cartesian2.js";
+import ClippingPlaneCollection from "../ClippingPlaneCollection.js";
+import combine from "../../Core/combine.js";
+import Color from "../../Core/Color.js";
+import ModelClippingPlanesStageFS from "../../Shaders/Model/ModelClippingPlanesStageFS.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+
+/**
+ * The model clipping planes stage is responsible for applying clipping planes to the model.
+ *
+ * @namespace ModelClippingPlanesPipelineStage
+ *
+ * @private
+ */
+const ModelClippingPlanesPipelineStage = {
+  name: "ModelClippingPlanesPipelineStage", // Helps with debugging
+};
+
+const textureResolutionScratch = new Cartesian2();
+/**
+ * Process a model. This modifies the following parts of the render resources:
+ *
+ * <ul>
+ *  <li>adds a define to the fragment shader to indicate that the model has clipping planes</li>
+ *  <li>adds the defines to the fragment shader for parameters related to clipping planes, such as the number of planes</li>
+ *  <li>adds a function to the fragment shader to apply the clipping planes to the model's base color</li>
+ *  <li>adds the uniforms for the fragment shader for the clipping plane texture and matrix</li>
+ *</ul>
+ *
+ * @param {ModelRenderResources} renderResources The render resources for this model.
+ * @param {Model} model The model.
+ * @param {FrameState} frameState The frameState.
+ *
+ * @private
+ */
+ModelClippingPlanesPipelineStage.process = function (
+  renderResources,
+  model,
+  frameState
+) {
+  const clippingPlanes = model.clippingPlanes;
+  const context = frameState.context;
+  const shaderBuilder = renderResources.shaderBuilder;
+
+  shaderBuilder.addDefine(
+    "HAS_CLIPPING_PLANES",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
+
+  shaderBuilder.addDefine(
+    "CLIPPING_PLANES_LENGTH",
+    clippingPlanes.length,
+    ShaderDestination.FRAGMENT
+  );
+
+  if (clippingPlanes.unionClippingRegions) {
+    shaderBuilder.addDefine(
+      "UNION_CLIPPING_REGIONS",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  if (ClippingPlaneCollection.useFloatTexture(context)) {
+    shaderBuilder.addDefine(
+      "USE_CLIPPING_PLANES_FLOAT_TEXTURE",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
+  }
+
+  const textureResolution = ClippingPlaneCollection.getTextureResolution(
+    clippingPlanes,
+    context,
+    textureResolutionScratch
+  );
+
+  shaderBuilder.addDefine(
+    "CLIPPING_PLANES_TEXTURE_WIDTH",
+    textureResolution.x,
+    ShaderDestination.FRAGMENT
+  );
+
+  shaderBuilder.addDefine(
+    "CLIPPING_PLANES_TEXTURE_HEIGHT",
+    textureResolution.y,
+    ShaderDestination.FRAGMENT
+  );
+
+  shaderBuilder.addUniform(
+    "sampler2D",
+    "model_clippingPlanes",
+    ShaderDestination.FRAGMENT
+  );
+  shaderBuilder.addUniform(
+    "vec4",
+    "model_clippingPlanesEdgeStyle",
+    ShaderDestination.FRAGMENT
+  );
+  shaderBuilder.addUniform(
+    "mat4",
+    "model_clippingPlanesMatrix",
+    ShaderDestination.FRAGMENT
+  );
+
+  shaderBuilder.addFragmentLines(ModelClippingPlanesStageFS);
+
+  const uniformMap = {
+    model_clippingPlanes: function () {
+      return clippingPlanes.texture;
+    },
+    model_clippingPlanesEdgeStyle: function () {
+      const style = Color.clone(clippingPlanes.edgeColor);
+      style.alpha = clippingPlanes.edgeWidth;
+      return style;
+    },
+    model_clippingPlanesMatrix: function () {
+      return model._clippingPlanesMatrix;
+    },
+  };
+
+  renderResources.uniformMap = combine(uniformMap, renderResources.uniformMap);
+};
+
+export default ModelClippingPlanesPipelineStage;

package/Source/Scene/Model/ModelColorPipelineStage.js

@@ -0,0 +1,99 @@
+import ColorBlendMode from "../ColorBlendMode.js";
+import combine from "../../Core/combine.js";
+import ModelColorStageFS from "../../Shaders/Model/ModelColorStageFS.js";
+import Pass from "../../Renderer/Pass.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+
+/**
+ * The model color pipeline stage is responsible for handling the application of a static color to the model.
+ *
+ * @namespace ModelColorPipelineStage
+ *
+ * @private
+ */
+const ModelColorPipelineStage = {
+  name: "ModelColorPipelineStage", // Helps with debugging
+
+  COLOR_UNIFORM_NAME: "model_color",
+  COLOR_BLEND_UNIFORM_NAME: "model_colorBlend",
+};
+
+/**
+ * Process a model. This modifies the following parts of the render resources:
+ *
+ * <ul>
+ *  <li>adds a define to the fragment shader to indicate that the model has a color</li>
+ *  <li>adds a function to the fragment shader to apply the color to the model's base color</li>
+ *  <li>adds the uniforms for the fragment shader for the model's color and blending properties</li>
+ *  <li>updates the pass type in the render resources based on translucency of the model's color</li>
+ *</ul>
+ *
+ * @param {ModelRenderResources} renderResources The render resources for this model.
+ * @param {Model} model The model.
+ * @param {FrameState} frameState The frameState.
+ *
+ * @private
+ */
+ModelColorPipelineStage.process = function (
+  renderResources,
+  model,
+  frameState
+) {
+  const shaderBuilder = renderResources.shaderBuilder;
+
+  shaderBuilder.addDefine(
+    "HAS_MODEL_COLOR",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
+  shaderBuilder.addFragmentLines(ModelColorStageFS);
+
+  const stageUniforms = {};
+
+  // Pass the model's color as a uniform. Set the pass type to translucent, if needed.
+  const color = model.color;
+
+  if (color.alpha === 0.0 && !model.hasSilhouette(frameState)) {
+    renderResources.renderStateOptions.colorMask = {
+      red: false,
+      green: false,
+      blue: false,
+      alpha: false,
+    };
+  }
+
+  if (color.alpha < 1.0) {
+    renderResources.alphaOptions.pass = Pass.TRANSLUCENT;
+  }
+
+  shaderBuilder.addUniform(
+    "vec4",
+    ModelColorPipelineStage.COLOR_UNIFORM_NAME,
+    ShaderDestination.FRAGMENT
+  );
+  stageUniforms[ModelColorPipelineStage.COLOR_UNIFORM_NAME] = function () {
+    return model.color;
+  };
+
+  // Create a colorBlend from the model's colorBlendMode and colorBlendAmount and pass it as a uniform.
+  shaderBuilder.addUniform(
+    "float",
+    ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME,
+    ShaderDestination.FRAGMENT
+  );
+  stageUniforms[
+    ModelColorPipelineStage.COLOR_BLEND_UNIFORM_NAME
+  ] = function () {
+    return ColorBlendMode.getColorBlend(
+      model.colorBlendMode,
+      model.colorBlendAmount
+    );
+  };
+
+  renderResources.uniformMap = combine(
+    stageUniforms,
+    renderResources.uniformMap
+  );
+};
+
+export default ModelColorPipelineStage;