@mlightcad/data-model 1.12.0 → 1.12.2

package/lib/misc/AcDbRenderingCache.js

@@ -1,3 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -9,15 +45,51 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { AcCmColor } from '@mlightcad/common';
+import { AcCmColor, AcCmUiYieldGate, accmYieldToUi } from '@mlightcad/common';
 import { AcGeMatrix3d } from '@mlightcad/geometry-engine';
 import { AcDbBlockTableRecord } from '../database/AcDbBlockTableRecord';
+/**
+ * Creates a zeroed top-level profile counter bag.
+ *
+ * @returns Fresh top-level stats object.
+ */
+var emptyTopLevel = function () { return ({
+    hits: 0,
+    misses: 0,
+    hitMs: 0,
+    missBuildMs: 0,
+    missCompactMs: 0,
+    cloneMs: 0,
+    setCloneMs: 0,
+    applyMs: 0
+}); };
+/**
+ * Creates a zeroed {@link AcDbRenderingCacheProfileStats} instance.
+ *
+ * @returns Fresh profile stats with empty `blockMisses`.
+ */
+var emptyProfileStats = function () { return ({
+    hits: 0,
+    misses: 0,
+    hitMs: 0,
+    missBuildMs: 0,
+    missCompactMs: 0,
+    cloneMs: 0,
+    setCloneMs: 0,
+    applyMs: 0,
+    topLevel: emptyTopLevel(),
+    blockMisses: []
+}); };
 /**
  * Internal class used to cache rendered results to avoid duplicated rendering.
  *
  * This class can be used to improve performance when rendering block references.
- * Because different colors will result in different materials, the block name and
- * color are used together to create the cache key.
+ * Blocks without ByBlock-colored entities share one color-independent template.
+ * Blocks that contain ByBlock entities still key by block name and color because
+ * different INSERT colors produce different materials.
+ *
+ * Templates are compacted (same-material leaves merged) before caching so each
+ * INSERT clones O(material) geometries instead of O(entity) geometries.
  *
  * @internal
  *
@@ -41,6 +113,24 @@ var AcDbRenderingCache = /** @class */ (function () {
     function AcDbRenderingCache() {
         this._blocks = new Map();
     }
+    Object.defineProperty(AcDbRenderingCache, "profileStats", {
+        /**
+         * Accumulated profile counters. Only updated while {@link profiling} is true.
+         */
+        get: function () {
+            return this._profileStats;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Clears {@link profileStats} and draw nesting depth.
+     * Leaves {@link profiling} unchanged.
+     */
+    AcDbRenderingCache.resetProfile = function () {
+        this._profileStats = emptyProfileStats();
+        this._drawDepth = 0;
+    };
     Object.defineProperty(AcDbRenderingCache, "instance", {
         /**
          * Gets the singleton instance of the rendering cache.
@@ -64,6 +154,9 @@ var AcDbRenderingCache = /** @class */ (function () {
     /**
      * Creates a cache key by combining the block name and color.
      *
+     * Prefer {@link createCacheKey} when the block's ByBlock dependency is known,
+     * so color-independent blocks can share one template.
+     *
      * @param name - The block name
      * @param color - The resolved block color
      * @returns A unique key for the cache entry
@@ -82,9 +175,29 @@ var AcDbRenderingCache = /** @class */ (function () {
         }
         return "".concat(name, "_").concat(colorKey);
     };
+    /**
+     * Creates a cache key, omitting color when the block has no ByBlock entities.
+     *
+     * Color-independent keys let INSERTs that differ only by layer (ByLayer
+     * traits remapped at instance time) share one compacted template.
+     *
+     * @param name - The block name
+     * @param color - The resolved INSERT color (used only when `hasByBlockColor`)
+     * @param hasByBlockColor - Whether any entity in the block uses ByBlock color
+     * @returns Cache key: `name` alone, or `name_color` when ByBlock entities exist
+     */
+    AcDbRenderingCache.prototype.createCacheKey = function (name, color, hasByBlockColor) {
+        if (!hasByBlockColor) {
+            return name;
+        }
+        return this.createKey(name, color);
+    };
     /**
      * Stores rendering results of a block in the cache.
      *
+     * Deep-clones `group` so later mutations of the live instance cannot corrupt
+     * the cached template.
+     *
      * @param key - The key for the rendering results
      * @param group - The rendering results to store
      * @returns The stored rendering results (deep cloned)
@@ -95,15 +208,29 @@ var AcDbRenderingCache = /** @class */ (function () {
      * ```
      */
     AcDbRenderingCache.prototype.set = function (key, group) {
-        group = group.fastDeepClone();
+        if (AcDbRenderingCache.profiling) {
+            var t0 = performance.now();
+            group = group.fastDeepClone();
+            var dt = performance.now() - t0;
+            AcDbRenderingCache._profileStats.setCloneMs += dt;
+            if (AcDbRenderingCache._drawDepth === 1) {
+                AcDbRenderingCache._profileStats.topLevel.setCloneMs += dt;
+            }
+        }
+        else {
+            group = group.fastDeepClone();
+        }
         this._blocks.set(key, group);
         return group;
     };
     /**
      * Gets rendering results with the specified key.
      *
+     * Returns a deep clone so callers can transform the instance without
+     * mutating the cached template.
+     *
      * @param name - The key of the rendering results
-     * @returns The rendering results with the specified key, or undefined if not found
+     * @returns The cloned rendering results, or `undefined` if not found
      *
      * @example
      * ```typescript
@@ -116,7 +243,18 @@ var AcDbRenderingCache = /** @class */ (function () {
     AcDbRenderingCache.prototype.get = function (name) {
         var block = this._blocks.get(name);
         if (block) {
-            block = block.fastDeepClone();
+            if (AcDbRenderingCache.profiling) {
+                var t0 = performance.now();
+                block = block.fastDeepClone();
+                var dt = performance.now() - t0;
+                AcDbRenderingCache._profileStats.cloneMs += dt;
+                if (AcDbRenderingCache._drawDepth === 1) {
+                    AcDbRenderingCache._profileStats.topLevel.cloneMs += dt;
+                }
+            }
+            else {
+                block = block.fastDeepClone();
+            }
         }
         return block;
     };
@@ -137,7 +275,7 @@ var AcDbRenderingCache = /** @class */ (function () {
         return this._blocks.has(name);
     };
     /**
-     * Clears all cached rendering results.
+     * Clears all cached rendering results and disposes owned geometry.
      *
      * @example
      * ```typescript
@@ -146,8 +284,95 @@ var AcDbRenderingCache = /** @class */ (function () {
      * ```
      */
     AcDbRenderingCache.prototype.clear = function () {
+        this._blocks.forEach(function (block) {
+            var _a;
+            (_a = block.dispose) === null || _a === void 0 ? void 0 : _a.call(block);
+        });
         this._blocks.clear();
     };
+    /**
+     * Prebuilds color-independent block templates before entity flush.
+     *
+     * Skips layout blocks (`*Model_Space` / `*Paper_Space*`), empty blocks,
+     * anonymous `*U` blocks, and blocks that contain ByBlock-colored entities
+     * (those require the INSERT color and are built on demand).
+     *
+     * @param renderer - Renderer used to convert block entities
+     * @param blocks - Iterator over block table records
+     * @param progress - Optional progress callback `(built, total, blockName)`
+     */
+    AcDbRenderingCache.prototype.prebuildAll = function (renderer, blocks, progress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var candidates, blocks_1, blocks_1_1, block, total, built, prebuildColor, yieldGate, candidates_1, candidates_1_1, block, key, e_1_1;
+            var e_2, _a, e_1, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        candidates = [];
+                        try {
+                            for (blocks_1 = __values(blocks), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+                                block = blocks_1_1.value;
+                                if (!block || !block.name) {
+                                    continue;
+                                }
+                                if (this.shouldSkipPrebuild(block)) {
+                                    continue;
+                                }
+                                candidates.push(block);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        total = candidates.length;
+                        built = 0;
+                        prebuildColor = new AcCmColor().setForeground();
+                        yieldGate = new AcCmUiYieldGate();
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 8, 9, 10]);
+                        candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next();
+                        _c.label = 2;
+                    case 2:
+                        if (!!candidates_1_1.done) return [3 /*break*/, 7];
+                        block = candidates_1_1.value;
+                        key = this.createCacheKey(block.name, prebuildColor, false);
+                        if (!this.has(key)) {
+                            this.draw(renderer, block, prebuildColor, [], true);
+                        }
+                        built++;
+                        if (!progress) return [3 /*break*/, 4];
+                        return [4 /*yield*/, progress(built, total, block.name)];
+                    case 3:
+                        _c.sent();
+                        _c.label = 4;
+                    case 4: return [4 /*yield*/, yieldGate.maybeYield(accmYieldToUi)];
+                    case 5:
+                        _c.sent();
+                        _c.label = 6;
+                    case 6:
+                        candidates_1_1 = candidates_1.next();
+                        return [3 /*break*/, 2];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _c.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (candidates_1_1 && !candidates_1_1.done && (_b = candidates_1.return)) _b.call(candidates_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Draws a block table record and optionally caches the result.
      *
@@ -157,9 +382,11 @@ var AcDbRenderingCache = /** @class */ (function () {
      * @param renderer - The renderer to use for drawing
      * @param blockTableRecord - The block table record to draw
      * @param blockColor - The resolved color to use for rendering
+     * @param attributes - Attribute graphics to attach (WCS); converted to
+     *   block-local space when `transform` is provided
      * @param cache - Whether to cache the rendering result (default: true)
-     * @param transform - Optional transformation matrix to apply
-     * @param normal - Optional normal vector
+     * @param transform - Optional block-reference transformation matrix
+     * @param normal - Optional extrusion / normal vector
      * @returns The rendered entity
      *
      * @example
@@ -168,6 +395,7 @@ var AcDbRenderingCache = /** @class */ (function () {
      *   renderer,
      *   blockRecord,
      *   new AcCmColor().setRGBValue(0xFF0000),
+     *   [],
      *   true,
      *   transform,
      *   normal
@@ -175,89 +403,232 @@ var AcDbRenderingCache = /** @class */ (function () {
      * ```
      */
     AcDbRenderingCache.prototype.draw = function (renderer, blockTableRecord, blockColor, attributes, cache, transform, normal) {
-        var e_1, _a;
+        var e_3, _a;
         var _b;
         if (attributes === void 0) { attributes = []; }
         if (cache === void 0) { cache = true; }
+        var profile = AcDbRenderingCache.profiling;
+        if (profile) {
+            AcDbRenderingCache._drawDepth++;
+        }
+        var isTop = profile && AcDbRenderingCache._drawDepth === 1;
+        var stats = AcDbRenderingCache._profileStats;
         var results = [];
-        if (blockTableRecord != null) {
-            var blockRgb = (_b = blockColor.RGB) !== null && _b !== void 0 ? _b : 0;
-            var key = this.createKey(blockTableRecord.name, blockColor);
-            var block_1;
-            if (this.has(key)) {
-                block_1 = this.get(key);
-            }
-            else {
-                var entities = blockTableRecord.newIterator();
-                try {
-                    for (var entities_1 = __values(entities), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
-                        var entity = entities_1_1.value;
-                        if (!entity.visibility) {
-                            continue;
+        try {
+            if (blockTableRecord != null) {
+                var blockRgb = (_b = blockColor.RGB) !== null && _b !== void 0 ? _b : 0;
+                var hasByBlockColor = this.blockHasByBlockColor(blockTableRecord);
+                var key = this.createCacheKey(blockTableRecord.name, blockColor, hasByBlockColor);
+                var block_1;
+                if (this.has(key)) {
+                    var tHit0 = profile ? performance.now() : 0;
+                    block_1 = this.get(key);
+                    if (profile) {
+                        var dt = performance.now() - tHit0;
+                        stats.hits++;
+                        stats.hitMs += dt;
+                        if (isTop) {
+                            stats.topLevel.hits++;
+                            stats.topLevel.hitMs += dt;
                         }
-                        // If the color of this entity is 'byBlock', then store the original color of this entity color
-                        // and set the color of this entity to block's color. After renderering this entity, restore
-                        // its original color
-                        if (entity.color.isByBlock) {
-                            _tmpColor.copy(entity.color);
-                            if (blockColor.isForeground) {
-                                entity.color.setForeground();
+                    }
+                }
+                else {
+                    var tBuild0 = profile ? performance.now() : 0;
+                    var entities = blockTableRecord.newIterator();
+                    try {
+                        for (var entities_1 = __values(entities), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
+                            var entity = entities_1_1.value;
+                            if (!entity.visibility) {
+                                continue;
+                            }
+                            // ByBlock entities temporarily inherit the INSERT color for material
+                            // creation. Use a local saved color so nested draw() calls cannot
+                            // corrupt a shared module-level scratch buffer.
+                            if (entity.color.isByBlock) {
+                                var savedColor = new AcCmColor().copy(entity.color);
+                                try {
+                                    if (blockColor.isForeground) {
+                                        entity.color.setForeground();
+                                    }
+                                    else {
+                                        entity.color.setRGBValue(blockRgb);
+                                    }
+                                    this.addEntity(entity, results, renderer);
+                                }
+                                finally {
+                                    entity.color.copy(savedColor);
+                                }
                             }
                             else {
-                                entity.color.setRGBValue(blockRgb);
+                                this.addEntity(entity, results, renderer);
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    block_1 = renderer.group(results);
+                    var buildMs = 0;
+                    if (profile) {
+                        buildMs = performance.now() - tBuild0;
+                        stats.missBuildMs += buildMs;
+                        if (isTop) {
+                            stats.topLevel.missBuildMs += buildMs;
+                        }
+                    }
+                    // Merge same-material leaves before caching so INSERT clones are cheap.
+                    var compactMs = 0;
+                    if (block_1 === null || block_1 === void 0 ? void 0 : block_1.compactForInstancing) {
+                        var tCompact0 = profile ? performance.now() : 0;
+                        block_1.compactForInstancing();
+                        if (profile) {
+                            compactMs = performance.now() - tCompact0;
+                            stats.missCompactMs += compactMs;
+                            if (isTop) {
+                                stats.topLevel.missCompactMs += compactMs;
                             }
-                            this.addEntity(entity, results, renderer);
-                            entity.color.copy(_tmpColor);
                         }
-                        else {
-                            this.addEntity(entity, results, renderer);
+                    }
+                    var setCloneBefore = profile ? stats.setCloneMs : 0;
+                    if (block_1 && cache) {
+                        // Transient anonymous blocks (*U…) are not reused across INSERTs.
+                        if (blockTableRecord.name &&
+                            !blockTableRecord.name.startsWith('*U')) {
+                            this.set(key, block_1);
                         }
                     }
+                    if (profile) {
+                        stats.misses++;
+                        if (isTop) {
+                            stats.topLevel.misses++;
+                        }
+                        stats.blockMisses.push({
+                            blockName: blockTableRecord.name || '(unnamed)',
+                            buildMs: buildMs,
+                            compactMs: compactMs,
+                            setCloneMs: stats.setCloneMs - setCloneBefore
+                        });
+                    }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                var tApply0 = profile ? performance.now() : 0;
+                if (block_1 && transform) {
+                    _tmpWorldTransform.copy(transform);
+                    block_1.applyMatrix(_tmpWorldTransform);
+                    if (normal && (normal.x != 0 || normal.y != 0 || normal.z != 1)) {
+                        _tmpExtrusion.setFromExtrusionDirection(normal);
+                        block_1.applyMatrix(_tmpExtrusion);
+                        _tmpWorldTransform.premultiply(_tmpExtrusion);
                     }
-                    finally { if (e_1) throw e_1.error; }
                 }
-                block_1 = renderer.group(results);
-                if (block_1 && cache) {
-                    // If one block is one transient block whose name starts with '*U', don't cache it
-                    if (AcDbBlockTableRecord.name &&
-                        !AcDbBlockTableRecord.name.startsWith('*U')) {
-                        this.set(key, block_1);
+                if (block_1 && attributes && attributes.length > 0) {
+                    // Attribute geometry is emitted in WCS. Convert it to block-local space so
+                    // the block reference transform applied above places it correctly.
+                    var inverse_1 = transform != null
+                        ? _tmpInverse.copy(_tmpWorldTransform).invert()
+                        : undefined;
+                    attributes.forEach(function (attrib) {
+                        if (inverse_1) {
+                            attrib.applyMatrix(inverse_1);
+                        }
+                        block_1.addChild(attrib);
+                    });
+                }
+                if (profile) {
+                    var dt = performance.now() - tApply0;
+                    stats.applyMs += dt;
+                    if (isTop) {
+                        stats.topLevel.applyMs += dt;
                     }
                 }
+                return block_1;
+            }
+            else {
+                return renderer.group(results);
             }
-            if (block_1 && transform) {
-                _tmpWorldTransform.copy(transform);
-                block_1.applyMatrix(_tmpWorldTransform);
-                if (normal && (normal.x != 0 || normal.y != 0 || normal.z != 1)) {
-                    _tmpExtrusion.setFromExtrusionDirection(normal);
-                    block_1.applyMatrix(_tmpExtrusion);
-                    _tmpWorldTransform.premultiply(_tmpExtrusion);
+        }
+        finally {
+            if (profile) {
+                AcDbRenderingCache._drawDepth--;
+            }
+        }
+    };
+    /**
+     * Returns whether `block` should be excluded from {@link prebuildAll}.
+     *
+     * Skips layout blocks, anonymous `*U` blocks, blocks with ByBlock colors
+     * (key depends on INSERT color), and blocks with no visible entities.
+     *
+     * @param block - Block table record to evaluate.
+     * @returns `true` when the block should not be prebuilt.
+     */
+    AcDbRenderingCache.prototype.shouldSkipPrebuild = function (block) {
+        var e_4, _a;
+        var name = block.name;
+        if (AcDbBlockTableRecord.isModelSapceName(name) ||
+            AcDbBlockTableRecord.isPaperSapceName(name)) {
+            return true;
+        }
+        if (name.startsWith('*U')) {
+            return true;
+        }
+        if (this.blockHasByBlockColor(block)) {
+            return true;
+        }
+        try {
+            // Empty blocks produce nothing useful to cache.
+            for (var _b = __values(block.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                if (entity.visibility) {
+                    return false;
                 }
             }
-            if (block_1 && attributes && attributes.length > 0) {
-                // Attribute geometry is emitted in WCS. Convert it to block-local space so
-                // the block reference transform applied above places it correctly.
-                var inverse_1 = transform != null
-                    ? _tmpInverse.copy(_tmpWorldTransform).invert()
-                    : undefined;
-                attributes.forEach(function (attrib) {
-                    if (inverse_1) {
-                        attrib.applyMatrix(inverse_1);
-                    }
-                    block_1.addChild(attrib);
-                });
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            return block_1;
+            finally { if (e_4) throw e_4.error; }
         }
-        else {
-            return renderer.group(results);
+        return true;
+    };
+    /**
+     * Returns whether any visible entity in the block uses ByBlock color.
+     *
+     * @param blockTableRecord - Block whose entities are scanned.
+     * @returns `true` when at least one visible ByBlock-colored entity exists.
+     */
+    AcDbRenderingCache.prototype.blockHasByBlockColor = function (blockTableRecord) {
+        var e_5, _a;
+        try {
+            for (var _b = __values(blockTableRecord.newIterator()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entity = _c.value;
+                if (entity.visibility && entity.color.isByBlock) {
+                    return true;
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
         }
+        return false;
     };
+    /**
+     * Draws one visible entity and appends its graphic result to `results`.
+     *
+     * @param entity - Database entity to convert.
+     * @param results - Accumulator for graphic-interface entities.
+     * @param renderer - Renderer used for `worldDraw`.
+     */
     AcDbRenderingCache.prototype.addEntity = function (entity, results, renderer) {
         if (!entity.visibility) {
             return;
@@ -268,17 +639,36 @@ var AcDbRenderingCache = /** @class */ (function () {
             results.push(object);
         }
     };
+    /**
+     * Copies database identity/layer/visibility onto a graphic-interface entity.
+     *
+     * @param target - Graphic entity produced by `worldDraw`.
+     * @param source - Source database entity.
+     */
     AcDbRenderingCache.prototype.attachEntityInfo = function (target, source) {
         target.objectId = source.objectId;
         target.ownerId = source.ownerId;
         target.layerName = source.layer;
         target.visible = source.visibility;
     };
+    /**
+     * When true, {@link draw} / {@link get} / {@link set} accumulate
+     * {@link profileStats}. Off by default (zero overhead when false).
+     */
+    AcDbRenderingCache.profiling = false;
+    /**
+     * Mutable profile accumulator used while {@link profiling} is true.
+     */
+    AcDbRenderingCache._profileStats = emptyProfileStats();
+    /** Nesting depth of {@link draw} while profiling (1 = outermost). */
+    AcDbRenderingCache._drawDepth = 0;
     return AcDbRenderingCache;
 }());
 export { AcDbRenderingCache };
-var _tmpColor = /*@__PURE__*/ new AcCmColor();
+/** Scratch matrix for the INSERT world transform applied in {@link AcDbRenderingCache.draw}. */
 var _tmpWorldTransform = /*@__PURE__*/ new AcGeMatrix3d();
+/** Scratch matrix for extrusion/normal correction in {@link AcDbRenderingCache.draw}. */
 var _tmpExtrusion = /*@__PURE__*/ new AcGeMatrix3d();
+/** Scratch inverse of the world transform used to bring ATTRIB geometry into block space. */
 var _tmpInverse = /*@__PURE__*/ new AcGeMatrix3d();
 //# sourceMappingURL=AcDbRenderingCache.js.map