@cesium/engine 23.0.1 → 25.0.0

package/Source/Renderer/DrawCommand.js

@@ -1,7 +1,24 @@
+// @ts-check
+
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import PrimitiveType from "../Core/PrimitiveType.js";
 
+/** @import Context from "./Context.js"; */
+/** @import Framebuffer from "./Framebuffer.js"; */
+/** @import Matrix4 from "../Core/Matrix4.js"; */
+/** @import OrientedBoundingBox from "../Core/OrientedBoundingBox.js"; */
+/** @import Pass from "./Pass.js"; */
+/** @import PassState from "./PassState.js"; */
+/** @import PickedMetadataInfo from "../Scene/PickedMetadataInfo.js"; */
+/** @import RenderState from "./RenderState.js"; */
+/** @import ShaderProgram from "./ShaderProgram.js"; */
+/** @import VertexArray from "./VertexArray.js"; */
+
+/**
+ * @enum {number}
+ * @ignore
+ */
 const Flags = {
   CULL: 1,
   OCCLUDE: 2,
@@ -14,69 +31,106 @@ const Flags = {
 };
 
 /**
- * Represents a command to the renderer for drawing.
+ * @typedef {object} DrawCommandOptions
+ * @property {object} [boundingVolume]
+ * @property {OrientedBoundingBox} [orientedBoundingBox]
+ * @property {Matrix4} [modelMatrix]
+ * @property {PrimitiveType} [primitiveType=PrimitiveType.TRIANGLES]
+ * @property {VertexArray} [vertexArray]
+ * @property {number} [count]
+ * @property {number} [offset]
+ * @property {number} [instanceCount]
+ * @property {ShaderProgram} [shaderProgram]
+ * @property {object} [uniformMap]
+ * @property {RenderState} [renderState]
+ * @property {Framebuffer} [framebuffer]
+ * @property {Pass} [pass]
+ * @property {object} [owner]
+ * @property {string} [pickId]
+ * @property {boolean} [pickMetadataAllowed=false]
+ * @property {boolean} [cull=true]
+ * @property {boolean} [occlude=true]
+ * @property {boolean} [executeInClosestFrustum=false]
+ * @property {boolean} [debugShowBoundingVolume=false]
+ * @property {boolean} [castShadows=false]
+ * @property {boolean} [receiveShadows=false]
+ * @property {boolean} [pickOnly=false]
+ * @property {boolean} [depthForTranslucentClassification=false]
  *
- * @alias DrawCommand
- * @constructor
+ * @ignore
+ */
+
+/**
+ * Represents a command to the renderer for drawing.
  *
  * @private
  */
-function DrawCommand(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
-
-  this._boundingVolume = options.boundingVolume;
-  this._orientedBoundingBox = options.orientedBoundingBox;
-  this._modelMatrix = options.modelMatrix;
-  this._primitiveType = options.primitiveType ?? PrimitiveType.TRIANGLES;
-  this._vertexArray = options.vertexArray;
-  this._count = options.count;
-  this._offset = options.offset ?? 0;
-  this._instanceCount = options.instanceCount ?? 0;
-  this._shaderProgram = options.shaderProgram;
-  this._uniformMap = options.uniformMap;
-  this._renderState = options.renderState;
-  this._framebuffer = options.framebuffer;
-  this._pass = options.pass;
-  this._owner = options.owner;
-  this._debugOverlappingFrustums = 0;
-  this._pickId = options.pickId;
-  this._pickMetadataAllowed = options.pickMetadataAllowed === true;
-  this._pickedMetadataInfo = undefined;
-
-  // Set initial flags.
-  this._flags = 0;
-  this.cull = options.cull ?? true;
-  this.occlude = options.occlude ?? true;
-  this.executeInClosestFrustum = options.executeInClosestFrustum ?? false;
-  this.debugShowBoundingVolume = options.debugShowBoundingVolume ?? false;
-  this.castShadows = options.castShadows ?? false;
-  this.receiveShadows = options.receiveShadows ?? false;
-  this.pickOnly = options.pickOnly ?? false;
-  this.depthForTranslucentClassification =
-    options.depthForTranslucentClassification ?? false;
-
-  this.dirty = true;
-  this.lastDirtyTime = 0;
-
+class DrawCommand {
   /**
-   * @private
+   * @param {DrawCommandOptions} [options]
    */
-  this.derivedCommands = {};
-}
-
-function hasFlag(command, flag) {
-  return (command._flags & flag) === flag;
-}
-
-function setFlag(command, flag, value) {
-  if (value) {
-    command._flags |= flag;
-  } else {
-    command._flags &= ~flag;
+  constructor(options = Frozen.EMPTY_OBJECT) {
+    /** @private */
+    this._boundingVolume = options.boundingVolume;
+    /** @private */
+    this._orientedBoundingBox = options.orientedBoundingBox;
+    /** @private */
+    this._modelMatrix = options.modelMatrix;
+    /** @private */
+    this._primitiveType = options.primitiveType ?? PrimitiveType.TRIANGLES;
+    /** @private */
+    this._vertexArray = options.vertexArray;
+    /** @private */
+    this._count = options.count;
+    /** @private */
+    this._offset = options.offset ?? 0;
+    /** @private */
+    this._instanceCount = options.instanceCount ?? 0;
+    /** @private */
+    this._shaderProgram = options.shaderProgram;
+    /** @private */
+    this._uniformMap = options.uniformMap;
+    /** @private */
+    this._renderState = options.renderState;
+    /** @private */
+    this._framebuffer = options.framebuffer;
+    /** @private */
+    this._pass = options.pass;
+    /** @private */
+    this._owner = options.owner;
+    /** @private */
+    this._debugOverlappingFrustums = 0;
+    /** @private */
+    this._pickId = options.pickId;
+    /** @private */
+    this._pickMetadataAllowed = options.pickMetadataAllowed === true;
+    /**
+     * @type {PickedMetadataInfo|undefined}
+     * @private
+     */
+    this._pickedMetadataInfo = undefined;
+
+    // Set initial flags.
+    this._flags = 0;
+    this.cull = options.cull ?? true;
+    this.occlude = options.occlude ?? true;
+    this.executeInClosestFrustum = options.executeInClosestFrustum ?? false;
+    this.debugShowBoundingVolume = options.debugShowBoundingVolume ?? false;
+    this.castShadows = options.castShadows ?? false;
+    this.receiveShadows = options.receiveShadows ?? false;
+    this.pickOnly = options.pickOnly ?? false;
+    this.depthForTranslucentClassification =
+      options.depthForTranslucentClassification ?? false;
+
+    this.dirty = true;
+    this.lastDirtyTime = 0;
+
+    /**
+     * @private
+     */
+    this.derivedCommands = {};
   }
-}
 
-Object.defineProperties(DrawCommand.prototype, {
   /**
    * The bounding volume of the geometry in world space.  This is used for culling and frustum selection.
    * <p>
@@ -86,85 +140,77 @@ Object.defineProperties(DrawCommand.prototype, {
    * minimize the number of frustums needed.
    * </p>
    *
-   * @memberof DrawCommand.prototype
    * @type {object}
    * @default undefined
    *
    * @see DrawCommand#debugShowBoundingVolume
    */
-  boundingVolume: {
-    get: function () {
-      return this._boundingVolume;
-    },
-    set: function (value) {
-      if (this._boundingVolume !== value) {
-        this._boundingVolume = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get boundingVolume() {
+    return this._boundingVolume;
+  }
+
+  set boundingVolume(value) {
+    if (this._boundingVolume !== value) {
+      this._boundingVolume = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The oriented bounding box of the geometry in world space. If this is defined, it is used instead of
    * {@link DrawCommand#boundingVolume} for plane intersection testing.
    *
-   * @memberof DrawCommand.prototype
    * @type {OrientedBoundingBox}
    * @default undefined
    *
    * @see DrawCommand#debugShowBoundingVolume
    */
-  orientedBoundingBox: {
-    get: function () {
-      return this._orientedBoundingBox;
-    },
-    set: function (value) {
-      if (this._orientedBoundingBox !== value) {
-        this._orientedBoundingBox = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get orientedBoundingBox() {
+    return this._orientedBoundingBox;
+  }
+
+  set orientedBoundingBox(value) {
+    if (this._orientedBoundingBox !== value) {
+      this._orientedBoundingBox = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * When <code>true</code>, the renderer frustum and horizon culls the command based on its {@link DrawCommand#boundingVolume}.
    * If the command was already culled, set this to <code>false</code> for a performance improvement.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default true
    */
-  cull: {
-    get: function () {
-      return hasFlag(this, Flags.CULL);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.CULL) !== value) {
-        setFlag(this, Flags.CULL, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get cull() {
+    return hasFlag(this, Flags.CULL);
+  }
+
+  set cull(value) {
+    if (hasFlag(this, Flags.CULL) !== value) {
+      setFlag(this, Flags.CULL, value);
+      this.dirty = true;
+    }
+  }
 
   /**
    * When <code>true</code>, the horizon culls the command based on its {@link DrawCommand#boundingVolume}.
    * {@link DrawCommand#cull} must also be <code>true</code> in order for the command to be culled.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default true
    */
-  occlude: {
-    get: function () {
-      return hasFlag(this, Flags.OCCLUDE);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.OCCLUDE) !== value) {
-        setFlag(this, Flags.OCCLUDE, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get occlude() {
+    return hasFlag(this, Flags.OCCLUDE);
+  }
+
+  set occlude(value) {
+    if (hasFlag(this, Flags.OCCLUDE) !== value) {
+      setFlag(this, Flags.OCCLUDE, value);
+      this.dirty = true;
+    }
+  }
 
   /**
    * The transformation from the geometry in model space to world space.
@@ -172,270 +218,242 @@ Object.defineProperties(DrawCommand.prototype, {
    * When <code>undefined</code>, the geometry is assumed to be defined in world space.
    * </p>
    *
-   * @memberof DrawCommand.prototype
    * @type {Matrix4}
    * @default undefined
    */
-  modelMatrix: {
-    get: function () {
-      return this._modelMatrix;
-    },
-    set: function (value) {
-      if (this._modelMatrix !== value) {
-        this._modelMatrix = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get modelMatrix() {
+    return this._modelMatrix;
+  }
+
+  set modelMatrix(value) {
+    if (this._modelMatrix !== value) {
+      this._modelMatrix = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The type of geometry in the vertex array.
    *
-   * @memberof DrawCommand.prototype
    * @type {PrimitiveType}
    * @default PrimitiveType.TRIANGLES
    */
-  primitiveType: {
-    get: function () {
-      return this._primitiveType;
-    },
-    set: function (value) {
-      if (this._primitiveType !== value) {
-        this._primitiveType = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get primitiveType() {
+    return this._primitiveType;
+  }
+
+  set primitiveType(value) {
+    if (this._primitiveType !== value) {
+      this._primitiveType = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The vertex array.
    *
-   * @memberof DrawCommand.prototype
    * @type {VertexArray}
    * @default undefined
    */
-  vertexArray: {
-    get: function () {
-      return this._vertexArray;
-    },
-    set: function (value) {
-      if (this._vertexArray !== value) {
-        this._vertexArray = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get vertexArray() {
+    return this._vertexArray;
+  }
+
+  set vertexArray(value) {
+    if (this._vertexArray !== value) {
+      this._vertexArray = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The number of vertices to draw in the vertex array.
    *
-   * @memberof DrawCommand.prototype
    * @type {number}
    * @default undefined
    */
-  count: {
-    get: function () {
-      return this._count;
-    },
-    set: function (value) {
-      if (this._count !== value) {
-        this._count = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get count() {
+    return this._count;
+  }
+
+  set count(value) {
+    if (this._count !== value) {
+      this._count = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The offset to start drawing in the vertex array.
    *
-   * @memberof DrawCommand.prototype
    * @type {number}
    * @default 0
    */
-  offset: {
-    get: function () {
-      return this._offset;
-    },
-    set: function (value) {
-      if (this._offset !== value) {
-        this._offset = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get offset() {
+    return this._offset;
+  }
+
+  set offset(value) {
+    if (this._offset !== value) {
+      this._offset = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The number of instances to draw.
    *
-   * @memberof DrawCommand.prototype
    * @type {number}
    * @default 0
    */
-  instanceCount: {
-    get: function () {
-      return this._instanceCount;
-    },
-    set: function (value) {
-      if (this._instanceCount !== value) {
-        this._instanceCount = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get instanceCount() {
+    return this._instanceCount;
+  }
+
+  set instanceCount(value) {
+    if (this._instanceCount !== value) {
+      this._instanceCount = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The shader program to apply.
    *
-   * @memberof DrawCommand.prototype
    * @type {ShaderProgram}
    * @default undefined
    */
-  shaderProgram: {
-    get: function () {
-      return this._shaderProgram;
-    },
-    set: function (value) {
-      if (this._shaderProgram !== value) {
-        this._shaderProgram = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get shaderProgram() {
+    return this._shaderProgram;
+  }
+
+  set shaderProgram(value) {
+    if (this._shaderProgram !== value) {
+      this._shaderProgram = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * Whether this command should cast shadows when shadowing is enabled.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default false
    */
-  castShadows: {
-    get: function () {
-      return hasFlag(this, Flags.CAST_SHADOWS);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.CAST_SHADOWS) !== value) {
-        setFlag(this, Flags.CAST_SHADOWS, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get castShadows() {
+    return hasFlag(this, Flags.CAST_SHADOWS);
+  }
+
+  set castShadows(value) {
+    if (hasFlag(this, Flags.CAST_SHADOWS) !== value) {
+      setFlag(this, Flags.CAST_SHADOWS, value);
+      this.dirty = true;
+    }
+  }
 
   /**
    * Whether this command should receive shadows when shadowing is enabled.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default false
    */
-  receiveShadows: {
-    get: function () {
-      return hasFlag(this, Flags.RECEIVE_SHADOWS);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.RECEIVE_SHADOWS) !== value) {
-        setFlag(this, Flags.RECEIVE_SHADOWS, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get receiveShadows() {
+    return hasFlag(this, Flags.RECEIVE_SHADOWS);
+  }
+
+  set receiveShadows(value) {
+    if (hasFlag(this, Flags.RECEIVE_SHADOWS) !== value) {
+      setFlag(this, Flags.RECEIVE_SHADOWS, value);
+      this.dirty = true;
+    }
+  }
 
   /**
    * An object with functions whose names match the uniforms in the shader program
    * and return values to set those uniforms.
    *
-   * @memberof DrawCommand.prototype
    * @type {object}
    * @default undefined
    */
-  uniformMap: {
-    get: function () {
-      return this._uniformMap;
-    },
-    set: function (value) {
-      if (this._uniformMap !== value) {
-        this._uniformMap = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get uniformMap() {
+    return this._uniformMap;
+  }
+
+  set uniformMap(value) {
+    if (this._uniformMap !== value) {
+      this._uniformMap = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The render state.
    *
-   * @memberof DrawCommand.prototype
    * @type {RenderState}
    * @default undefined
    */
-  renderState: {
-    get: function () {
-      return this._renderState;
-    },
-    set: function (value) {
-      if (this._renderState !== value) {
-        this._renderState = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get renderState() {
+    return this._renderState;
+  }
+
+  set renderState(value) {
+    if (this._renderState !== value) {
+      this._renderState = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The framebuffer to draw to.
    *
-   * @memberof DrawCommand.prototype
    * @type {Framebuffer}
    * @default undefined
    */
-  framebuffer: {
-    get: function () {
-      return this._framebuffer;
-    },
-    set: function (value) {
-      if (this._framebuffer !== value) {
-        this._framebuffer = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get framebuffer() {
+    return this._framebuffer;
+  }
+
+  set framebuffer(value) {
+    if (this._framebuffer !== value) {
+      this._framebuffer = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * The pass when to render.
    *
-   * @memberof DrawCommand.prototype
    * @type {Pass}
    * @default undefined
    */
-  pass: {
-    get: function () {
-      return this._pass;
-    },
-    set: function (value) {
-      if (this._pass !== value) {
-        this._pass = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get pass() {
+    return this._pass;
+  }
+
+  set pass(value) {
+    if (this._pass !== value) {
+      this._pass = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * Specifies if this command is only to be executed in the frustum closest
    * to the eye containing the bounding volume. Defaults to <code>false</code>.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default false
    */
-  executeInClosestFrustum: {
-    get: function () {
-      return hasFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM) !== value) {
-        setFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get executeInClosestFrustum() {
+    return hasFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM);
+  }
+
+  set executeInClosestFrustum(value) {
+    if (hasFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM) !== value) {
+      setFlag(this, Flags.EXECUTE_IN_CLOSEST_FRUSTUM, value);
+      this.dirty = true;
+    }
+  }
 
   /**
    * The object who created this command.  This is useful for debugging command
@@ -443,23 +461,21 @@ Object.defineProperties(DrawCommand.prototype, {
    * reference to the command, and can be used to selectively execute commands
    * with {@link Scene#debugCommandFilter}.
    *
-   * @memberof DrawCommand.prototype
    * @type {object}
    * @default undefined
    *
    * @see Scene#debugCommandFilter
    */
-  owner: {
-    get: function () {
-      return this._owner;
-    },
-    set: function (value) {
-      if (this._owner !== value) {
-        this._owner = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get owner() {
+    return this._owner;
+  }
+
+  set owner(value) {
+    if (this._owner !== value) {
+      this._owner = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * This property is for debugging only; it is not for production use nor is it optimized.
@@ -467,58 +483,54 @@ Object.defineProperties(DrawCommand.prototype, {
    * Draws the {@link DrawCommand#boundingVolume} for this command, assuming it is a sphere, when the command executes.
    * </p>
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default false
    *
    * @see DrawCommand#boundingVolume
    */
-  debugShowBoundingVolume: {
-    get: function () {
-      return hasFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME) !== value) {
-        setFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get debugShowBoundingVolume() {
+    return hasFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME);
+  }
+
+  set debugShowBoundingVolume(value) {
+    if (hasFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME) !== value) {
+      setFlag(this, Flags.DEBUG_SHOW_BOUNDING_VOLUME, value);
+      this.dirty = true;
+    }
+  }
 
   /**
    * Used to implement Scene.debugShowFrustums.
-   * @private
+   * @ignore
    */
-  debugOverlappingFrustums: {
-    get: function () {
-      return this._debugOverlappingFrustums;
-    },
-    set: function (value) {
-      if (this._debugOverlappingFrustums !== value) {
-        this._debugOverlappingFrustums = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get debugOverlappingFrustums() {
+    return this._debugOverlappingFrustums;
+  }
+
+  set debugOverlappingFrustums(value) {
+    if (this._debugOverlappingFrustums !== value) {
+      this._debugOverlappingFrustums = value;
+      this.dirty = true;
+    }
+  }
+
   /**
    * A GLSL string that will evaluate to a pick id. When <code>undefined</code>, the command will only draw depth
    * during the pick pass.
    *
-   * @memberof DrawCommand.prototype
    * @type {string|undefined}
    * @default undefined
    */
-  pickId: {
-    get: function () {
-      return this._pickId;
-    },
-    set: function (value) {
-      if (this._pickId !== value) {
-        this._pickId = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get pickId() {
+    return this._pickId;
+  }
+
+  set pickId(value) {
+    if (this._pickId !== value) {
+      this._pickId = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * Whether metadata picking is allowed.
@@ -527,118 +539,138 @@ Object.defineProperties(DrawCommand.prototype, {
    * part of a `ModelDrawCommand`, to check whether a derived command
    * for metadata picking has to be created.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default undefined
    * @private
    */
-  pickMetadataAllowed: {
-    get: function () {
-      return this._pickMetadataAllowed;
-    },
-  },
+  get pickMetadataAllowed() {
+    return this._pickMetadataAllowed;
+  }
 
   /**
    * Information about picked metadata.
    *
-   * @memberof DrawCommand.prototype
    * @type {PickedMetadataInfo|undefined}
    * @default undefined
    */
-  pickedMetadataInfo: {
-    get: function () {
-      return this._pickedMetadataInfo;
-    },
-    set: function (value) {
-      if (this._pickedMetadataInfo !== value) {
-        this._pickedMetadataInfo = value;
-        this.dirty = true;
-      }
-    },
-  },
+  get pickedMetadataInfo() {
+    return this._pickedMetadataInfo;
+  }
+
+  set pickedMetadataInfo(value) {
+    if (this._pickedMetadataInfo !== value) {
+      this._pickedMetadataInfo = value;
+      this.dirty = true;
+    }
+  }
 
   /**
    * Whether this command should be executed in the pick pass only.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default false
    */
-  pickOnly: {
-    get: function () {
-      return hasFlag(this, Flags.PICK_ONLY);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.PICK_ONLY) !== value) {
-        setFlag(this, Flags.PICK_ONLY, value);
-        this.dirty = true;
-      }
-    },
-  },
+  get pickOnly() {
+    return hasFlag(this, Flags.PICK_ONLY);
+  }
+
+  set pickOnly(value) {
+    if (hasFlag(this, Flags.PICK_ONLY) !== value) {
+      setFlag(this, Flags.PICK_ONLY, value);
+      this.dirty = true;
+    }
+  }
+
   /**
    * Whether this command should be derived to draw depth for classification of translucent primitives.
    *
-   * @memberof DrawCommand.prototype
    * @type {boolean}
    * @default false
    */
-  depthForTranslucentClassification: {
-    get: function () {
-      return hasFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION);
-    },
-    set: function (value) {
-      if (hasFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION) !== value) {
-        setFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION, value);
-        this.dirty = true;
-      }
-    },
-  },
-});
+  get depthForTranslucentClassification() {
+    return hasFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION);
+  }
+
+  set depthForTranslucentClassification(value) {
+    if (hasFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION) !== value) {
+      setFlag(this, Flags.DEPTH_FOR_TRANSLUCENT_CLASSIFICATION, value);
+      this.dirty = true;
+    }
+  }
+
+  /**
+   * @param {DrawCommand} command
+   * @param {DrawCommand} result
+   * @returns {DrawCommand}
+   * @private
+   */
+  static shallowClone(command, result) {
+    if (!defined(command)) {
+      return undefined;
+    }
+    if (!defined(result)) {
+      result = new DrawCommand();
+    }
+
+    result._boundingVolume = command._boundingVolume;
+    result._orientedBoundingBox = command._orientedBoundingBox;
+    result._modelMatrix = command._modelMatrix;
+    result._primitiveType = command._primitiveType;
+    result._vertexArray = command._vertexArray;
+    result._count = command._count;
+    result._offset = command._offset;
+    result._instanceCount = command._instanceCount;
+    result._shaderProgram = command._shaderProgram;
+    result._uniformMap = command._uniformMap;
+    result._renderState = command._renderState;
+    result._framebuffer = command._framebuffer;
+    result._pass = command._pass;
+    result._owner = command._owner;
+    result._debugOverlappingFrustums = command._debugOverlappingFrustums;
+    result._pickId = command._pickId;
+    result._pickMetadataAllowed = command._pickMetadataAllowed;
+    result._pickedMetadataInfo = command._pickedMetadataInfo;
+    result._flags = command._flags;
+
+    result.dirty = true;
+    result.lastDirtyTime = 0;
+
+    return result;
+  }
+
+  /**
+   * Executes the draw command.
+   *
+   * @param {Context} context The renderer context in which to draw.
+   * @param {PassState} [passState] The state for the current render pass.
+   */
+  execute(context, passState) {
+    context.draw(this, passState);
+  }
+}
 
 /**
- * @private
+ * @param {DrawCommand} command
+ * @param {Flags} flag
+ * @returns {boolean}
+ * @ignore
  */
-DrawCommand.shallowClone = function (command, result) {
-  if (!defined(command)) {
-    return undefined;
-  }
-  if (!defined(result)) {
-    result = new DrawCommand();
-  }
-
-  result._boundingVolume = command._boundingVolume;
-  result._orientedBoundingBox = command._orientedBoundingBox;
-  result._modelMatrix = command._modelMatrix;
-  result._primitiveType = command._primitiveType;
-  result._vertexArray = command._vertexArray;
-  result._count = command._count;
-  result._offset = command._offset;
-  result._instanceCount = command._instanceCount;
-  result._shaderProgram = command._shaderProgram;
-  result._uniformMap = command._uniformMap;
-  result._renderState = command._renderState;
-  result._framebuffer = command._framebuffer;
-  result._pass = command._pass;
-  result._owner = command._owner;
-  result._debugOverlappingFrustums = command._debugOverlappingFrustums;
-  result._pickId = command._pickId;
-  result._pickMetadataAllowed = command._pickMetadataAllowed;
-  result._pickedMetadataInfo = command._pickedMetadataInfo;
-  result._flags = command._flags;
-
-  result.dirty = true;
-  result.lastDirtyTime = 0;
-
-  return result;
-};
+function hasFlag(command, flag) {
+  return (command._flags & flag) === flag;
+}
 
 /**
- * Executes the draw command.
- *
- * @param {Context} context The renderer context in which to draw.
- * @param {PassState} [passState] The state for the current render pass.
+ * @param {DrawCommand} command
+ * @param {Flags} flag
+ * @param {boolean} value
+ * @ignore
  */
-DrawCommand.prototype.execute = function (context, passState) {
-  context.draw(this, passState);
-};
+function setFlag(command, flag, value) {
+  if (value) {
+    command._flags |= flag;
+  } else {
+    command._flags &= ~flag;
+  }
+}
+
 export default DrawCommand;