切换模型的时候，执行gltfRootEntity.destroy()的方法，之前的模型不能销毁

[typ1758]

`/**

• @title GLTF Basic
• @category Basic
  */
  import { OrbitControl } from "@galacean/engine-toolkit-controls";
  import {
  Camera, GLTFResource, WebGLEngine, AmbientLight,
  AssetType,
  BackgroundMode,
  DirectLight,
  Logger,
  PrimitiveMesh,
  SkyBoxMaterial,
  Script,
  Vector3,
  Animator,
  SpotLight,
  PointLight,
  Entity
  } from "@galacean/engine";

const engine = new WebGLEngine("canvas");
Logger.enable();
//-- create engine object
let winHref = decodeURIComponent(window.location.href);
let r = winHref.split("?")[1]; //拿到路径后面的参数
console.log("r:", r);
let modalName = "";
let getlight: any = 1; //灯光选择
let getscal: any = 10; //3D 缩放比例
let bgNum: any = 3; //场景选择
let lightIntensity: any = 0.5; //环境光强度
let specularIntensity: any = 0.1; //镜面反射强度
let getangle: any = 330; //3D 模型旋转角度
let minDis: any = 1.5; //判定的距离操作合理范围的最小值 镜头距离
let maxDis: any = 9; //判定的距离操作合理范围的最大值 镜头距离
let distanceNum: any = 5; //距离默认值

let vSyncCountFlg = false;

// 默认模型链接
// modalName = "https://saas.sanxiaxiu.com/glb/1.glb";
// modalName = "https://file.zhenqingkongjian.com/3d/猫戏屏风08260522.glb";

engine.canvas.resizeByClientSize();

const scene = engine.sceneManager.activeScene;
const { ambientLight, background } = scene;
const rootEntity = scene.createRootEntity("root");

const newEntity = rootEntity.createChild("firstEntity");
const gltfRootEntity = rootEntity.createChild("gltf");
//Create camera 创建相机
const cameraNode = rootEntity.createChild("camera_node");
// setPosition 通过X, Y, Z值设置本地位置。
cameraNode.transform.setPosition(0, 0, distanceNum);
// cameraNode.enableFrustumCulling = false;
cameraNode.addComponent(Camera);
// cameraNode.addComponent(OrbitControl);

// 设置相机能够上下左右旋转的角度
const control = cameraNode.addComponent(OrbitControl);
// 判定的距离操作合理范围的最小值 镜头距离
control.minDistance = minDis;
// 判定的距离操作合理范围的最大值
control.maxDistance = maxDis;
//竖直方向操作合理范围的最大弧度
// control.maxPolarAngle = (Math.PI * 3) / 4;
//竖直方向操作合理范围的最小弧度
// control.minPolarAngle = (Math.PI * 1) / 4;
// 水平方向操作合理范围的最大弧度，默认为正无穷大
// control.maxAzimuthAngle = Math.PI / 2;
// 水平方向操作合理范围的最小弧度，默认为负无穷大
// control.minAzimuthAngle = -Math.PI / 2;
// 相机旋转速度，默认为 1.0
control.rotateSpeed = 0.7;
// 是否支持相机平移，默认为 true
control.enablePan = false;

// 手势缩放的速度
control.zoomSpeed = 0.7;
// 是否支持相机旋转，默认为 true
// control.enableRotate = true;

// 垂直同步 V-SYNC（垂直同步）将 GPU 的帧速率与显示器的最大刷新率同步。如果您发现视频游戏中出现明显的屏幕撕裂，则应启用它。
// engine.vSyncCount = 1;
// 非垂直同步

if (vSyncCountFlg) {
engine.vSyncCount = 0;
engine.targetFrameRate = 60;
} else {
engine.vSyncCount = 1;
}

// 默认情况下引擎采用垂直同步模式并使用 vSyncCount 控制渲染刷新率，该模式才渲染帧会等待屏幕的垂直同步信号， vSyncCount 代表了渲染帧之间期望的屏幕同步信号次数，默认值为 1，该属性的值必须为整数，例如我们想在一个屏幕刷新率为 60 帧的设备上期望每秒渲染 30 帧，则可以将该值设置为 2。
// 另外用户还可以关闭垂直同步，即将 vSyncCount 设置为 0，然后设置 targetFrameRate 为期望的帧数值，该模式下的渲染不考虑垂直同步信号，而是，如 120 表示 120 帧，即每秒期望刷新 120 次。
// Create sky 创建的天空
const sky = background.sky;
const skyMaterial = new SkyBoxMaterial(engine);
// background.mode = BackgroundMode.Sky;//有背景
background.mode = BackgroundMode.SolidColor; //无背景
//rgb(116, 111, 108)=(1-116/255,111/255,108/255,1(透明度))
// background.solidColor.set(0.485, 0.505, 0.516, 1);
background.solidColor.set(104 / 255, 101 / 255, 100 / 255, 1);

sky.material = skyMaterial;
sky.mesh = PrimitiveMesh.createCuboid(engine, 1, 1, 1);

// 光照
//平行光2背面
const lightEntityDirec = rootEntity.createChild("light");
const directLight = lightEntityDirec.addComponent(DirectLight);
//光照颜色
directLight.color.set(1, 1, 1, 1);
// directLight.color.set(1, 0.8431, 0.6941, 1);
//光照强度
directLight.intensity = 1;
// 调整方向
lightEntityDirec.transform.setRotation(-45, 180, 45);

// 聚光灯1正面
const lightEntitySpot1 = rootEntity.createChild("light");
const spotLight1 = lightEntitySpot1.addComponent(SpotLight);

spotLight1.angle = Math.PI / 11; // 散射角度
spotLight1.penumbra = Math.PI / 10; // 半影衰减角度
// spotLight1.color.set(1, 1, 1, 1);
spotLight1.color.set(1, 0.8431, 0.6941, 1);
// 光照强度
spotLight1.intensity = 7;
//光照距离
spotLight1.distance = 3;
//光照位置
lightEntitySpot1.transform.setPosition(-0.115, 2, 0.2);
//光照角度
lightEntitySpot1.transform.setRotation(-80, -30, 0);

// 聚光灯3正面
const lightEntitySpot33 = rootEntity.createChild("light");
const spotLight33 = lightEntitySpot33.addComponent(SpotLight);

spotLight33.angle = Math.PI / 11; // 散射角度
spotLight33.penumbra = Math.PI / 10; // 半影衰减角度
// spotLight1.color.set(1, 1, 1, 1);
spotLight33.color.set(1, 0.8431, 0.6941, 1);
// 光照强度
spotLight33.intensity = 5;
//光照距离
spotLight33.distance = 2;
//光照位置
lightEntitySpot33.transform.setPosition(0.866, 0.5, 0.5);
//光照角度
lightEntitySpot33.transform.setRotation(-90, 0, 0);

// 聚光灯2背面
const lightEntitySpot2 = rootEntity.createChild("light");
const spotLight2 = lightEntitySpot2.addComponent(SpotLight);

spotLight2.angle = Math.PI / 11; // 散射角度
spotLight2.penumbra = Math.PI / 10; // 半影衰减角度
// spotLight2.color.set(1, 1, 1, 1);
spotLight2.color.set(1, 0.8431, 0.6941, 1);
// 光照强度
spotLight2.intensity = 7;
//光照距离
spotLight2.distance = 3;
//光照位置
lightEntitySpot2.transform.setPosition(0.115, 2, -0.2);
//光照角度
lightEntitySpot2.transform.setRotation(-100, -30, 0);

//光照完结--------

window.onresize = () => {
return (() => {
// alert(1);
// 监听浏览器发生变化，并重新初始化模型，防止变形
engine.canvas.resizeByClientSize();
})();
};
function destroyGLTF (){
newEntity.destroy();
console.log('销毁');
};
export function createOasis(modalName) {
console.log(modalName);
destroyGLTF();
console.log('--------初始化模型');
let resourceManagerUrl: any = "";
//场景选择
resourceManagerUrl = "https://file.zhenqingkongjian.com/3d/bg.room.env";
// 设置下载模型时长
engine.resourceManager.timeout = 300000;
Promise.all([
engine.resourceManager
// GLTF资源路径
.load(modalName)
// .timeout:500000
.then((gltf) => {
const model = gltf.defaultSceneRoot;
// 设置模型默认旋转的角度
// model.transform.rotate(0, 0, 0);
// 设置模型偏移位置
model.transform.setPosition(0, 0, 0);
const entity = rootEntity.createChild("");
entity.addChild(gltf.defaultSceneRoot);
// 添加旋转方法
model.addComponent(Rotate);
})
.catch((e) => {
console.log("模型下载失败.....");
// ElMessage.error("模型下载失败");
console.log("e:", e);
}),
// 环境光
engine.resourceManager
.load({
type: AssetType.Env,
url: resourceManagerUrl, // 环境光链接
})
.then((ambientLight) => {
// const model = ambientLight.defaultSceneRoot;
scene.ambientLight = ambientLight;
skyMaterial.textureCubeMap = ambientLight.specularTexture;
skyMaterial.textureDecodeRGBM = true;
// 设置环境光颜色
// ambientLight.diffuseSolidColor.set(1, 0.6817, 0.4419, 1);
// 设置环境光强度
ambientLight.diffuseIntensity = lightIntensity;
// 设置环境光的镜面反射强度
ambientLight.specularIntensity = specularIntensity;
// model.addComponent(Rotate);
// openDebug(ambientLight.specularTexture);
}),
]).then((results) => {
console.log("results:", results);
engine.run();
let getNum = 0;
let getNumber = setInterval(() => {
getNum++;
if (getNum == 10) {
clearInterval(getNumber);
engine.canvas.resizeByClientSize();
// hide();
}
}, 50);
$("#loadding").hide(),
console.log("加载完成.....");
});

// 旋转逻辑
class Rotate extends Script {
	// a / 125
	private _tempVector = new Vector3(0, parseFloat(getangle) / 125, 0); //旋转方向和速度控制，现为绕Y轴旋转，每帧旋转0.625°
	private _totalTime: number = 0;
	private _countNum: number = 0;
	private _scal: number = (parseFloat(getscal) - 0.2) / 125;

	onStart() {
		console.log("_countNum:", this._countNum);
	}
	onUpdate(deltaTime: number) {
		if (this._countNum < 125) {
			this._countNum++; //时间累进
			this.entity.transform.rotate(this._tempVector); //控制旋转，旋转时长为240ms，旋转角度为125*2.64 = 330°
			// const scaleFactor = 1; //缩放的倍数控制，由最大倍数缩小至1.25（250/200）倍
			// (b-0.2)/125
			const scaleFactor = this._scal * this._countNum + 0.2; //缩放的倍数控制，由最大倍数缩小至1.2（0.008*150）倍
			this.entity.transform.scale = new Vector3(
				scaleFactor,
				scaleFactor,
				scaleFactor
			);
		}
	}
}

};

`

[cptbtptpbcptdtptp]

感谢提问，出问题的原因是您在已经销毁的节点上添加子节点，同时引擎也对此情况增加了一些预防，详情请参照：
galacean/engine#1688