recude code size

Author: troublemaker52025

cocos/rendering/instanced-buffer.ts

@@ -39,14 +39,6 @@ export function instancingCompareFn (l: InstancedBuffer, r: InstancedBuffer): nu
     return (ls.hash - rs.hash) ||  (ls.shaderId - rs.shaderId);
 }
 
-// Combines a running hash `seed` with `value` into a single 32-bit integer.
-// Mirrors the native `ccstd::hash_combine` formula so merge keys can be plain
-// numbers instead of formatted strings, avoiding per-merge string allocation.
-function hashCombine (seed: number, value: number): number {
-    // eslint-disable-next-line no-bitwise
-    return (seed ^ (value + 0x9e3779b9 + (seed << 6) + (seed >> 2))) | 0;
-}
-
 export interface IInstancedItem {
     count: number;
     capacity: number;
@@ -74,7 +66,7 @@ export class InstancedBuffer {
     public sortRender: IRenderPass;
     private declare _passPool: RecyclePool<IRenderPass>;
     private declare _device: Device;
-    private readonly _instanceMap = new Map<number, IInstancedItem[]>();
+    private readonly _instanceMap = new Map<string, IInstancedItem[]>();
     constructor (pass: Pass) {
         this._device = pass.device;
         this.pass = pass;
@@ -118,13 +110,9 @@ export class InstancedBuffer {
         this.sortRender.shaderId = shader.typedID;
         this.sortRender.passIdx = passIdx;
 
-        let key = hashCombine(2, sourceIA.indexBuffer?.objectID ?? 0);
-        key = hashCombine(key, lightingMap.objectID);
-        key = hashCombine(key, useReflectionProbeType);
-        key = hashCombine(key, reflectionProbeCubemap.objectID);
-        key = hashCombine(key, reflectionProbePlanarMap.objectID);
-        key = hashCombine(key, ENABLE_PROBE_BLEND ? reflectionProbeBlendCubemap!.objectID : 0);
-        key = hashCombine(key, stride);
+        const key = `${sourceIA.indexBuffer?.objectID ?? 0}/${lightingMap.objectID}/${useReflectionProbeType}/`
+            + `${reflectionProbeCubemap.objectID}/${reflectionProbePlanarMap.objectID}/`
+            + `${ENABLE_PROBE_BLEND ? reflectionProbeBlendCubemap!.objectID : 0}/${stride}`;
         const mappedInstances = this._instanceMap.get(key);
         if (mappedInstances) {
             for (let i = 0; i < mappedInstances.length; ++i) {
@@ -167,7 +155,7 @@ export class InstancedBuffer {
     }
 
     private _createInstance (
-        key: number,
+        key: string,
         sourceIA: InputAssembler,
         instancedAttributes: Attribute[],
         instanceData: Uint8Array,

native/cocos/renderer/pipeline/InstancedBuffer.cpp

@@ -31,6 +31,7 @@
 #include "gfx-base/GFXDescriptorSet.h"
 #include "gfx-base/GFXDevice.h"
 #include "gfx-base/GFXInputAssembler.h"
+#include "base/StringUtil.h"
 
 namespace cc {
 namespace pipeline {
@@ -84,26 +85,24 @@ void InstancedBuffer::merge(scene::SubModel *subModel, uint32_t passIdx, gfx::Sh
     _sortRender.hash = hash;
     _sortRender.shaderID = shaderId;
     _sortRender.passIndex = passIdx;
-    const ccstd::hash_t key = [&]() {
-        ccstd::hash_t seed = 2;
-        ccstd::hash_combine(seed, gfx::GFXObject::getObjectID(sourceIA->getIndexBuffer()));
-        ccstd::hash_combine(seed, gfx::GFXObject::getObjectID(lightingMap));
-        ccstd::hash_combine(seed, reflectionProbeType);
-        ccstd::hash_combine(seed, gfx::GFXObject::getObjectID(reflectionProbeCubemap));
-        ccstd::hash_combine(seed, gfx::GFXObject::getObjectID(reflectionProbePlanarMap));
-        ccstd::hash_combine(seed, gfx::GFXObject::getObjectID(reflectionProbeBlendCubemap));
-        ccstd::hash_combine(seed, stride);
-        return seed;
-    }();
+    const ccstd::string key = StringUtil::format("%u/%u/%u/%u/%u/%u/%u",
+                                                 sourceIA->getIndexBuffer() ? sourceIA->getIndexBuffer()->getObjectID() : 0,
+                                                 lightingMap ? lightingMap->getObjectID() : 0,
+                                                 reflectionProbeType,
+                                                 reflectionProbeCubemap ? reflectionProbeCubemap->getObjectID() : 0,
+                                                 reflectionProbePlanarMap ? reflectionProbePlanarMap->getObjectID() : 0,
+                                                 reflectionProbeBlendCubemap ? reflectionProbeBlendCubemap->getObjectID() : 0,
+                                                 stride);
     const auto iter = _instancesMap.find(key);
     if (iter != _instancesMap.end()) {
-        for (size_t idx : iter->second) {
+        uint32_t idx = iter->second;
+        while (idx != InstancedItem::INVALID_INDEX) {
             auto &instance = _instances[idx];
-            if (instance.drawInfo.instanceCount >= MAX_CAPACITY) {
-                continue;
+            if (instance.drawInfo.instanceCount < MAX_CAPACITY) {
+                appendInstance(instance, attrs.buffer, shader, descriptorSet);
+                return;
             }
-            appendInstance(instance, attrs.buffer, shader, descriptorSet);
-            return;
+            idx = instance.nextWithSameKey;
         }
     }
 
@@ -147,7 +146,7 @@ void InstancedBuffer::appendInstance(InstancedItem &instance,
     _hasPendingModels = true;
 }
 
-void InstancedBuffer::createInstance(ccstd::hash_t key,
+void InstancedBuffer::createInstance(const ccstd::string &key,
                                       gfx::InputAssembler *sourceIA,
                                       const ccstd::vector<gfx::Attribute> &attributes,
                                       Uint8Array &buffer,
@@ -194,8 +193,10 @@ void InstancedBuffer::createInstance(ccstd::hash_t key,
                           reflectionProbeBlendCubemap,
                           ia->getDrawInfo()};
     item.drawInfo.instanceCount = 1;
+    const auto headIter = _instancesMap.find(key);
+    item.nextWithSameKey = headIter != _instancesMap.end() ? headIter->second : InstancedItem::INVALID_INDEX;
     _instances.emplace_back(item);
-    _instancesMap[key].emplace_back(_instances.size() - 1);
+    _instancesMap[key] = static_cast<uint32_t>(_instances.size() - 1);
     _hasPendingModels = true;
 }
 

native/cocos/renderer/pipeline/InstancedBuffer.h

@@ -27,7 +27,6 @@
 #include "Define.h"
 #include "base/RefCounted.h"
 #include "base/std/container/unordered_map.h"
-#include "base/std/hash/hash.h"
 #include "scene/Model.h"
 #include "scene/Pass.h"
 
@@ -39,6 +38,8 @@ namespace pipeline {
 struct PSOInfo;
 
 struct CC_DLL InstancedItem {
+    static constexpr uint32_t INVALID_INDEX = 0xFFFFFFFF;
+
     uint32_t capacity = 0;
     gfx::Buffer *vb = nullptr;
     uint8_t *data = nullptr;
@@ -52,6 +53,11 @@ struct CC_DLL InstancedItem {
     uint32_t reflectionProbeType = 0;
     gfx::Texture *reflectionProbeBlendCubemap = nullptr;
     gfx::DrawInfo drawInfo;
+    // Index (into `InstancedBuffer::_instances`) of the next item sharing the same merge
+    // key, or `INVALID_INDEX` if this is the last one. Forms an intrusive singly-linked
+    // list per key, so `_instancesMap` only needs to store one head index per key instead
+    // of a `ccstd::vector<size_t>`, avoiding an extra container template instantiation.
+    uint32_t nextWithSameKey = INVALID_INDEX;
 };
 using InstancedItemList = ccstd::vector<InstancedItem>;
 using DynamicOffsetList = ccstd::vector<uint32_t>;
@@ -83,7 +89,7 @@ class InstancedBuffer : public RefCounted {
         Uint8Array &buffer,
         gfx::Shader *shader,
         gfx::DescriptorSet *descriptorSet);
-    void createInstance(ccstd::hash_t key,
+    void createInstance(const ccstd::string &key,
         gfx::InputAssembler *sourceIA,
         const ccstd::vector<gfx::Attribute> &attributes,
         Uint8Array &buffer,
@@ -106,12 +112,11 @@ class InstancedBuffer : public RefCounted {
 
     InstancedItemList _instances;
     DynamicOffsetList _dynamicOffsets;
-    // Maps a merge key to the indices (into `_instances`) of items sharing that key.
-    // Storing indices (not copies or references) keeps this in sync with `_instances`
-    // and remains valid across `_instances` reallocation, since indices don't dangle.
-    // The key is a combined hash (see `ccstd::hash_combine`) instead of a formatted
-    // string, avoiding per-merge string allocation/formatting overhead.
-    ccstd::unordered_map<ccstd::hash_t, ccstd::vector<size_t>> _instancesMap;
+    // Maps a merge key to the index (into `_instances`) of the head item with that key.
+    // Remaining items sharing the key are reached via `InstancedItem::nextWithSameKey`,
+    // so this map only needs `uint32_t` values instead of `ccstd::vector<size_t>`,
+    // avoiding an extra map-of-vectors template instantiation.
+    ccstd::unordered_map<ccstd::string, uint32_t> _instancesMap;
 };
 
 } // namespace pipeline