102 lines
3.4 KiB
TypeScript
102 lines
3.4 KiB
TypeScript
import { Component, Node, Prefab, director, instantiate } from 'cc';
|
|
import IPoolable from './IPoolable';
|
|
|
|
export default class ObjectPool {
|
|
private _inactives: Node[] = [];
|
|
private _actives: Node[] = [];
|
|
private _prefab: Prefab;
|
|
private _expandable;
|
|
private _poolHandlerComp: new () => any;
|
|
|
|
public get countInactive() {
|
|
return this._inactives.length;
|
|
}
|
|
|
|
public get countActive() {
|
|
return this._actives.length;
|
|
}
|
|
|
|
public get countAll() {
|
|
return this.countInactive + this.countActive;
|
|
}
|
|
|
|
constructor(prefab: Prefab, size: number, expandable = true, poolHandlerComp?: new () => any | string) {
|
|
this._prefab = prefab;
|
|
this._expandable = expandable;
|
|
this._poolHandlerComp = poolHandlerComp;
|
|
for (let i = 0; i < size; ++i) {
|
|
let obj = instantiate(this._prefab); // create node instance
|
|
obj.removeFromParent();
|
|
this._inactives.push(obj);
|
|
ObjectPool._poolLookUp[obj.uuid] = this;
|
|
}
|
|
}
|
|
|
|
//#region Static
|
|
private static _poolLookUp: { [key: string]: ObjectPool } = {};
|
|
public static release(obj: Node) {
|
|
ObjectPool._poolLookUp[obj.uuid].release(obj);
|
|
}
|
|
//#endregion
|
|
|
|
public get(parent?: Node): Node;
|
|
public get<T extends Component>(parent?: Node, classConstructor?: new () => T): T;
|
|
public get<T extends Component>(parent?: Node, classConstructor?: new () => T): T | Node {
|
|
let obj: Node = null;
|
|
let p = parent || director.getScene();
|
|
if (this._inactives.length > 0) {
|
|
// Pop the last object in pool
|
|
obj = this._inactives.pop();
|
|
} else if (this._expandable) {
|
|
// if not enough node in the pool, we call cc.instantiate to create node
|
|
obj = instantiate(this._prefab);
|
|
ObjectPool._poolLookUp[obj.uuid] = this;
|
|
} else {
|
|
obj = this._actives.shift();
|
|
}
|
|
|
|
obj.setParent(p);
|
|
this._actives.push(obj);
|
|
// Invoke pool handler
|
|
const handler = this._poolHandlerComp ? obj.getComponent(this._poolHandlerComp) : null;
|
|
if (handler) {
|
|
(handler as unknown as IPoolable)?.reuse();
|
|
}
|
|
|
|
if (classConstructor) {
|
|
return handler == classConstructor ? handler : obj.getComponent(classConstructor);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
public release(obj: Node): void;
|
|
public release<T extends Component>(obj: T): void;
|
|
public release<T extends Component>(obj: T | Node): void {
|
|
let node = obj instanceof Node ? obj : obj.node;
|
|
const index = this._actives.indexOf(node);
|
|
//check obj is belongs to pool
|
|
if (index === -1) return;
|
|
this._actives.splice(index, 1);
|
|
this._inactives.push(node);
|
|
// Invoke pool handler
|
|
|
|
const handler = this._poolHandlerComp ? node.getComponent(this._poolHandlerComp) : null;
|
|
if (handler) {
|
|
(handler as unknown as IPoolable)?.unuse();
|
|
}
|
|
// Remove from parent, but don't cleanup
|
|
node.removeFromParent();
|
|
}
|
|
|
|
public clear() {
|
|
this._inactives.forEach((obj) => obj.destroy());
|
|
this._inactives = [];
|
|
this._actives = [];
|
|
Object.keys(ObjectPool._poolLookUp).forEach((key) => {
|
|
if (ObjectPool._poolLookUp[key] === this) {
|
|
delete ObjectPool._poolLookUp[key];
|
|
}
|
|
});
|
|
}
|
|
}
|