745 lines
24 KiB
TypeScript
745 lines
24 KiB
TypeScript
import { ImportMeshAsync, ISceneLoaderProgressEvent } from '@babylonjs/core/Loading/sceneLoader';
|
||
import '@babylonjs/loaders/glTF';
|
||
import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
|
||
import { Mesh } from '@babylonjs/core/Meshes/mesh';
|
||
import { Quaternion, Vector3 } from '@babylonjs/core/Maths/math.vector';
|
||
import { Scene } from '@babylonjs/core/scene';
|
||
import { Monobehiver } from '../base/Monobehiver';
|
||
import { Dictionary } from '../utils/Dictionary';
|
||
import { AppConfig } from './AppConfig';
|
||
import { EventBridge } from '../event/bridge';
|
||
import { DragConfig } from './AppModelDrag';
|
||
|
||
type LoadResult = {
|
||
success: boolean;
|
||
meshes?: AbstractMesh[];
|
||
skeletons?: unknown[];
|
||
error?: string;
|
||
};
|
||
|
||
type ModelConfig = {
|
||
name: string;
|
||
url: string;
|
||
};
|
||
|
||
type ModelControlType = 'rotation' | 'color';
|
||
|
||
type ModelTransform = {
|
||
position?: { x: number; y: number; z: number };
|
||
rotation?: { x: number; y: number; z: number };
|
||
scale?: { x: number; y: number; z: number };
|
||
};
|
||
|
||
type ModelMetadata = {
|
||
modelName: string;
|
||
modelId: string;
|
||
modelUrl: string;
|
||
modelControlType?: ModelControlType;
|
||
drag?: DragConfig;
|
||
transform?: ModelTransform;
|
||
};
|
||
|
||
/**
|
||
* 模型管理类 - 负责加载、缓存和管理3D模型
|
||
*/
|
||
export class AppModel extends Monobehiver {
|
||
private modelDic: Dictionary<AbstractMesh[]>;
|
||
private modelMetadataDic: Dictionary<ModelMetadata>;
|
||
private loadedMeshes: AbstractMesh[];
|
||
private isLoading: boolean;
|
||
|
||
constructor(mainApp: any) {
|
||
super(mainApp);
|
||
this.modelDic = new Dictionary<AbstractMesh[]>();
|
||
this.modelMetadataDic = new Dictionary<ModelMetadata>();
|
||
this.loadedMeshes = [];
|
||
this.isLoading = false;
|
||
}
|
||
|
||
initManagers(): void {
|
||
// 预留接口
|
||
}
|
||
|
||
/** 加载配置中的所有模型 */
|
||
async loadModel(): Promise<void> {
|
||
if (!AppConfig.modelUrlList?.length || this.isLoading) return;
|
||
|
||
this.isLoading = true;
|
||
try {
|
||
await this.loadMultipleModels(AppConfig.modelUrlList);
|
||
EventBridge.modelLoaded({ urls: AppConfig.modelUrlList });
|
||
} finally {
|
||
this.isLoading = false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量加载模型（内部方法）
|
||
* @param urls 模型URL数组
|
||
*/
|
||
private async loadMultipleModels(urls: string[]): Promise<void> {
|
||
const total = urls.length;
|
||
EventBridge.modelLoadProgress({ loaded: 0, total, urls, progress: 0, percentage: 0 });
|
||
|
||
for (let i = 0; i < urls.length; i++) {
|
||
const url = urls[i];
|
||
const result = await this.loadSingleModel(url, (event) => {
|
||
this.emitProgress(i, total, url, event);
|
||
});
|
||
|
||
this.emitProgress(i + 1, total, url, null, result.success);
|
||
|
||
if (!result.success) {
|
||
EventBridge.modelLoadError({ url, error: result.error });
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送加载进度事件
|
||
*/
|
||
private emitProgress(
|
||
loaded: number,
|
||
total: number,
|
||
url: string,
|
||
event: ISceneLoaderProgressEvent | null,
|
||
success?: boolean
|
||
): void {
|
||
const currentProgress = event?.lengthComputable && event.total > 0
|
||
? Math.min(1, event.loaded / event.total)
|
||
: 0;
|
||
const overallProgress = Math.min(1, (loaded + (event ? currentProgress : 0)) / total);
|
||
|
||
EventBridge.modelLoadProgress({
|
||
loaded: loaded + (event ? currentProgress : 0),
|
||
total,
|
||
url,
|
||
success,
|
||
progress: overallProgress,
|
||
percentage: Number((overallProgress * 100).toFixed(2)),
|
||
detail: event ? {
|
||
url,
|
||
lengthComputable: event.lengthComputable,
|
||
loadedBytes: event.loaded,
|
||
totalBytes: event.total
|
||
} : undefined
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 加载单个模型文件
|
||
* @param modelUrl 模型URL
|
||
* @param onProgress 进度回调
|
||
*/
|
||
private async loadSingleModel(
|
||
modelUrl: string,
|
||
onProgress?: (event: ISceneLoaderProgressEvent) => void
|
||
): Promise<LoadResult> {
|
||
try {
|
||
const scene = this.mainApp.appScene.object;
|
||
if (!scene) return { success: false, error: '场景未初始化' };
|
||
|
||
const result = await ImportMeshAsync(modelUrl, scene, { onProgress });
|
||
if (!result?.meshes?.length) return { success: false, error: '未找到网格' };
|
||
|
||
this.loadedMeshes.push(...result.meshes);
|
||
return { success: true, meshes: result.meshes, skeletons: result.skeletons };
|
||
} catch (e: any) {
|
||
console.error(`模型加载失败: ${modelUrl}`, e);
|
||
return { success: false, error: e?.message };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 克隆模型材质，避免多个模型共享同名材质
|
||
* @param meshes 网格数组
|
||
* @param modelId 模型ID
|
||
*/
|
||
private cloneMaterials(meshes: AbstractMesh[], modelId: string): void {
|
||
const scene = this.mainApp.appScene.object;
|
||
const clonedMaterials = new Map<string, any>();
|
||
|
||
meshes.forEach(mesh => {
|
||
if (mesh.material) {
|
||
const originalMaterial = mesh.material;
|
||
const originalName = originalMaterial.name;
|
||
|
||
// 如果该材质还没有被克隆过，则克隆它
|
||
if (!clonedMaterials.has(originalName)) {
|
||
const newName = `${originalName}_${modelId}`;
|
||
const clonedMaterial = originalMaterial.clone(newName);
|
||
clonedMaterials.set(originalName, clonedMaterial);
|
||
|
||
}
|
||
|
||
// 应用克隆的材质
|
||
mesh.material = clonedMaterials.get(originalName);
|
||
}
|
||
});
|
||
|
||
|
||
}
|
||
|
||
/** 为网格设置阴影（投射和接收） */
|
||
private createModelRoot(modelId: string, meshes: AbstractMesh[]): AbstractMesh[] {
|
||
const scene = this.mainApp.appScene.object;
|
||
const root = new Mesh(`${modelId}__root`, scene);
|
||
const meshSet = new Set<AbstractMesh>(meshes);
|
||
root.position.copyFrom(this.getMeshesBoundingCenter(meshes));
|
||
|
||
meshes.forEach(mesh => {
|
||
if (!mesh.parent || !meshSet.has(mesh.parent as AbstractMesh)) {
|
||
mesh.setParent(root, true, true);
|
||
}
|
||
});
|
||
|
||
this.loadedMeshes.push(root);
|
||
return [root, ...meshes];
|
||
}
|
||
|
||
private getMeshesBoundingCenter(meshes: AbstractMesh[]): Vector3 {
|
||
const renderableMeshes = meshes.filter(mesh => !mesh.isDisposed() && mesh.getTotalVertices() > 0);
|
||
if (!renderableMeshes.length) return Vector3.Zero();
|
||
|
||
const min = new Vector3(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
|
||
const max = new Vector3(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
|
||
|
||
renderableMeshes.forEach(mesh => {
|
||
mesh.computeWorldMatrix(true);
|
||
const boundingBox = mesh.getBoundingInfo().boundingBox;
|
||
min.minimizeInPlace(boundingBox.minimumWorld);
|
||
max.maximizeInPlace(boundingBox.maximumWorld);
|
||
});
|
||
|
||
return min.add(max).scaleInPlace(0.5);
|
||
}
|
||
|
||
|
||
setupShadows(meshes: AbstractMesh[]): void {
|
||
const appLight = this.mainApp.appLight;
|
||
if (!appLight) return;
|
||
|
||
meshes.forEach(mesh => {
|
||
if (mesh.getTotalVertices() > 0) {
|
||
appLight.addShadowCaster(mesh);
|
||
mesh.receiveShadows = true;
|
||
}
|
||
});
|
||
}
|
||
|
||
/** 获取缓存的网格 */
|
||
getCachedMeshes(name: string): AbstractMesh[] | undefined {
|
||
return this.modelDic.Get(name);
|
||
}
|
||
|
||
/** 清理所有资源 */
|
||
clean(): void {
|
||
this.modelDic.Clear();
|
||
this.loadedMeshes.forEach(m => m?.dispose());
|
||
this.loadedMeshes = [];
|
||
this.isLoading = false;
|
||
}
|
||
|
||
/**
|
||
* 添加模型到场景（支持单个或批量）
|
||
* @param modelConfig 模型配置对象 或 模型配置数组
|
||
*/
|
||
async add(
|
||
modelConfig: ModelMetadata | ModelMetadata[]
|
||
): Promise<LoadResult | { success: boolean; results: LoadResult[] }> {
|
||
// 批量加载
|
||
if (Array.isArray(modelConfig)) {
|
||
return await this.addMultiple(modelConfig);
|
||
}
|
||
|
||
// 单个加载
|
||
return await this.addSingle(
|
||
modelConfig.modelName,
|
||
modelConfig.modelId,
|
||
modelConfig.modelUrl,
|
||
modelConfig.modelControlType,
|
||
modelConfig.drag,
|
||
modelConfig.transform
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 添加单个模型
|
||
*/
|
||
private async addSingle(modelName: string, modelId: string, modelUrl: string, modelControlType?: ModelControlType, drag?: DragConfig, transform?: ModelTransform): Promise<LoadResult> {
|
||
// 检查是否已存在
|
||
const existingMeshes = this.modelDic.Get(modelName + '_' + modelId);
|
||
if (existingMeshes?.length && !existingMeshes[0].isDisposed()) {
|
||
console.log(`模型 ${modelName + modelId} 已存在，直接显示`);
|
||
this.showMeshes(existingMeshes);
|
||
return { success: true, meshes: existingMeshes };
|
||
}
|
||
|
||
// 加载模型
|
||
const result = await this.loadSingleModel(modelUrl, (event) => {
|
||
this.emitSingleProgress(modelUrl, event);
|
||
});
|
||
|
||
if (result.success && result.meshes) {
|
||
// 克隆材质，确保每个模型有独立的材质
|
||
this.cloneMaterials(result.meshes, modelId);
|
||
|
||
// 存储模型
|
||
result.meshes = this.createModelRoot(modelName + '_' + modelId, result.meshes);
|
||
this.modelDic.Set(modelName + '_' + modelId, result.meshes);
|
||
|
||
// 存储元数据
|
||
this.modelMetadataDic.Set(modelName + '_' + modelId, {
|
||
modelName: modelName,
|
||
modelId: modelId,
|
||
modelUrl: modelUrl,
|
||
modelControlType: modelControlType,
|
||
drag: drag,
|
||
transform: transform
|
||
});
|
||
|
||
// 应用 transform
|
||
if (transform) {
|
||
this.applyTransform(modelName + '_' + modelId, transform);
|
||
}
|
||
|
||
// 配置拖拽功能
|
||
if (drag) {
|
||
this.mainApp.appModelDrag?.configureDrag(modelName + '_' + modelId, drag);
|
||
}
|
||
|
||
// 更新 GameManager 的字典
|
||
this.mainApp.gameManager?.updateDictionaries();
|
||
|
||
EventBridge.modelLoaded({ urls: [modelUrl] });
|
||
} else {
|
||
EventBridge.modelLoadError({ url: modelUrl, error: result.error });
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 批量添加模型
|
||
*/
|
||
private async addMultiple(models: ModelMetadata[]): Promise<{ success: boolean; results: LoadResult[] }> {
|
||
const total = models.length;
|
||
const results: LoadResult[] = [];
|
||
|
||
EventBridge.modelLoadProgress({ loaded: 0, total, progress: 0, percentage: 0 });
|
||
|
||
for (let i = 0; i < models.length; i++) {
|
||
const { modelName, modelId, modelUrl, modelControlType, drag, transform } = models[i];
|
||
|
||
const result = await this.loadSingleModel(modelUrl, (event) => {
|
||
this.emitProgress(i, total, modelUrl, event);
|
||
});
|
||
|
||
if (result.success && result.meshes) {
|
||
// 克隆材质，确保每个模型有独立的材质
|
||
this.cloneMaterials(result.meshes, modelId);
|
||
|
||
result.meshes = this.createModelRoot(modelName, result.meshes);
|
||
this.modelDic.Set(modelName + '_' + modelId, result.meshes);
|
||
|
||
// 存储元数据
|
||
this.modelMetadataDic.Set(modelName + '_' + modelId, {
|
||
modelName: modelName,
|
||
modelId: modelId,
|
||
modelUrl: modelUrl,
|
||
modelControlType: modelControlType,
|
||
drag: drag,
|
||
transform: transform
|
||
});
|
||
|
||
// 应用 transform
|
||
if (transform) {
|
||
this.applyTransform(modelName + '_' + modelId, transform);
|
||
}
|
||
|
||
// 配置拖拽功能
|
||
if (drag) {
|
||
this.mainApp.appModelDrag?.configureDrag(modelName + '_' + modelId, drag);
|
||
}
|
||
}
|
||
|
||
results.push(result);
|
||
this.emitProgress(i + 1, total, modelUrl, null, result.success);
|
||
}
|
||
|
||
// 批量加载完成后统一更新字典
|
||
this.mainApp.gameManager?.updateDictionaries();
|
||
|
||
EventBridge.modelLoaded({ urls: models.map(m => m.modelUrl) });
|
||
|
||
return {
|
||
success: results.every(r => r.success),
|
||
results
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 显示网格
|
||
*/
|
||
private showMeshes(meshes: AbstractMesh[]): void {
|
||
meshes.forEach(mesh => {
|
||
mesh.setEnabled(true);
|
||
mesh.getChildMeshes().forEach(child => child.setEnabled(true));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 发送单个模型加载进度
|
||
*/
|
||
private emitSingleProgress(url: string, event: ISceneLoaderProgressEvent): void {
|
||
const progress = event.lengthComputable && event.total > 0
|
||
? Math.min(1, event.loaded / event.total)
|
||
: 0;
|
||
|
||
EventBridge.modelLoadProgress({
|
||
loaded: progress,
|
||
total: 1,
|
||
url,
|
||
progress,
|
||
percentage: Number((progress * 100).toFixed(2)),
|
||
detail: {
|
||
url,
|
||
lengthComputable: event.lengthComputable,
|
||
loadedBytes: event.loaded,
|
||
totalBytes: event.total
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 根据 mesh 名称查找 mesh 对象
|
||
* @param meshName mesh 名称
|
||
* @returns mesh 对象，未找到返回 undefined
|
||
*/
|
||
private findMeshByName(meshName: string): AbstractMesh | undefined {
|
||
const keys = this.modelDic.Keys();
|
||
for (const key of keys) {
|
||
const meshes = this.modelDic.Get(key);
|
||
const found = meshes?.find(m => m.name === meshName);
|
||
if (found) return found;
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
/**
|
||
* 根据 mesh 查找所属的模型名称
|
||
* @param mesh 网格对象
|
||
* @returns 模型名称，未找到返回 undefined
|
||
*/
|
||
findModelNameByMesh(mesh: AbstractMesh): string | undefined {
|
||
|
||
const keys = this.modelDic.Keys();
|
||
for (const key of keys) {
|
||
const meshes = this.modelDic.Get(key);
|
||
if (meshes?.some(m => m === mesh || m.uniqueId === mesh.uniqueId)) {
|
||
|
||
return key;
|
||
}
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
/**
|
||
* 根据 mesh 或 mesh 名称移除所属的整个模型
|
||
* @param meshOrName 网格对象或网格名称
|
||
* @returns 是否成功移除
|
||
*/
|
||
remove(meshOrName: AbstractMesh | string): boolean {
|
||
let mesh: AbstractMesh | undefined;
|
||
|
||
|
||
// 判断传入的是对象还是字符串
|
||
if (typeof meshOrName === 'string') {
|
||
mesh = this.findMeshByName(meshOrName);
|
||
if (!mesh) {
|
||
console.warn(`未找到名为 ${meshOrName} 的网格`);
|
||
return false;
|
||
}
|
||
} else {
|
||
mesh = meshOrName;
|
||
}
|
||
|
||
const modelName = this.findModelNameByMesh(mesh);
|
||
if (modelName) {
|
||
this.removeByName(modelName);
|
||
return true;
|
||
}
|
||
console.warn('未找到该 mesh 所属的模型');
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 替换模型
|
||
* @param modelConfig 模型配置对象
|
||
*/
|
||
async replaceModel(modelConfig: ModelMetadata): Promise<LoadResult> {
|
||
|
||
|
||
|
||
this.removeByName(modelConfig.modelId);
|
||
return await this.addSingle(
|
||
modelConfig.modelName,
|
||
modelConfig.modelId,
|
||
modelConfig.modelUrl,
|
||
modelConfig.modelControlType,
|
||
modelConfig.drag,
|
||
modelConfig.transform
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 销毁指定模型
|
||
* @param modelName 模型名称
|
||
*/
|
||
removeByName(modelName: string): boolean {
|
||
const meshes = this.modelDic.Get(modelName);
|
||
if (!meshes?.length) {
|
||
console.warn(`Model not found: ${modelName}`);
|
||
return false;
|
||
}
|
||
|
||
this.getModelTransformTargets(meshes).forEach(mesh => mesh.dispose(false, true));
|
||
this.modelDic.Remove(modelName);
|
||
this.modelMetadataDic.Remove(modelName);
|
||
this.mainApp.gameManager?.updateDictionaries();
|
||
return true;
|
||
|
||
}
|
||
|
||
/**
|
||
* 清除所有已添加的模型并释放内存
|
||
* 主要用于切换尺寸后清除不适用的配件
|
||
*/
|
||
removeAll(): void {
|
||
const modelNames = this.modelDic.Keys();
|
||
|
||
|
||
|
||
modelNames.forEach(modelName => {
|
||
const meshes = this.modelDic.Get(modelName);
|
||
if (meshes?.length) {
|
||
this.getModelTransformTargets(meshes).forEach(mesh => mesh.dispose(false, true));
|
||
}
|
||
});
|
||
|
||
this.modelDic.Clear();
|
||
this.modelMetadataDic.Clear();
|
||
this.mainApp.gameManager?.updateDictionaries();
|
||
|
||
console.log('所有模型已清除，内存已释放');
|
||
}
|
||
|
||
/**
|
||
* 获取模型元数据
|
||
* @param modelName 模型名称
|
||
*/
|
||
getModelMetadata(modelName: string): ModelMetadata | undefined {
|
||
return this.modelMetadataDic.Get(modelName);
|
||
}
|
||
|
||
/**
|
||
* 根据网格查找模型元数据
|
||
* @param mesh 网格对象
|
||
*/
|
||
getMetadataByMesh(mesh: AbstractMesh): ModelMetadata | undefined {
|
||
const modelName = this.findModelNameByMesh(mesh);
|
||
if (modelName) {
|
||
return this.modelMetadataDic.Get(modelName);
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
private getModelTransformTargets(meshes: AbstractMesh[]): AbstractMesh[] {
|
||
const meshSet = new Set<AbstractMesh>(meshes);
|
||
const rootMeshes = meshes.filter(mesh => !mesh.parent || !meshSet.has(mesh.parent as AbstractMesh));
|
||
|
||
return rootMeshes.length ? rootMeshes : meshes.slice(0, 1);
|
||
}
|
||
|
||
getModelTransformTargetByMesh(mesh: AbstractMesh): AbstractMesh | undefined {
|
||
const modelName = this.findModelNameByMesh(mesh);
|
||
if (!modelName) return mesh;
|
||
|
||
const meshes = this.modelDic.Get(modelName);
|
||
if (!meshes?.length) return mesh;
|
||
|
||
return this.getModelTransformTargets(meshes)[0] ?? mesh;
|
||
}
|
||
|
||
getModelMeshesByMesh(mesh: AbstractMesh): AbstractMesh[] {
|
||
const modelName = this.findModelNameByMesh(mesh);
|
||
if (!modelName) return [mesh];
|
||
|
||
const meshes = this.modelDic.Get(modelName);
|
||
return meshes?.length ? meshes : [mesh];
|
||
}
|
||
|
||
/**
|
||
* 设置模型旋转
|
||
* @param modelId 模型ID
|
||
* @param rotation 旋转向量 {x, y, z}（默认使用角度）
|
||
* @param useDegrees 是否使用角度（默认true）
|
||
*/
|
||
setRotation(modelId: string, rotation: { x: number; y: number; z: number }, useDegrees: boolean = true): void {
|
||
const meshes = this.modelDic.Get(modelId);
|
||
if (!meshes?.length) {
|
||
console.warn(`Model not found: ${modelId}`);
|
||
return;
|
||
}
|
||
|
||
// 如果使用角度，转换为弧度
|
||
const toRadians = (degrees: number) => degrees * Math.PI / 180;
|
||
const rotationValues = useDegrees ? {
|
||
x: toRadians(rotation.x),
|
||
y: toRadians(rotation.y),
|
||
z: toRadians(rotation.z)
|
||
} : rotation;
|
||
|
||
this.getModelTransformTargets(meshes).forEach(mesh => {
|
||
if (mesh.rotationQuaternion) {
|
||
mesh.rotationQuaternion = Quaternion.FromEulerAngles(
|
||
rotationValues.x,
|
||
rotationValues.y,
|
||
rotationValues.z
|
||
);
|
||
return;
|
||
}
|
||
|
||
mesh.rotation.set(rotationValues.x, rotationValues.y, rotationValues.z);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 累加模型旋转
|
||
* @param modelId 模型ID
|
||
* @param rotation 旋转向量 {x, y, z}（默认使用角度）
|
||
* @param useDegrees 是否使用角度（默认true）
|
||
*/
|
||
addRotation(modelId: string, rotation: { x: number; y: number; z: number }, useDegrees: boolean = true): void {
|
||
const meshes = this.modelDic.Get(modelId);
|
||
if (!meshes?.length) {
|
||
console.warn(`Model not found: ${modelId}`);
|
||
return;
|
||
}
|
||
|
||
// 如果使用角度，转换为弧度
|
||
const toRadians = (degrees: number) => degrees * Math.PI / 180;
|
||
const rotationValues = useDegrees ? {
|
||
x: toRadians(rotation.x),
|
||
y: toRadians(rotation.y),
|
||
z: toRadians(rotation.z)
|
||
} : rotation;
|
||
|
||
this.getModelTransformTargets(meshes).forEach(mesh => {
|
||
mesh.addRotation(rotationValues.x, rotationValues.y, rotationValues.z);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 设置模型位置
|
||
* @param modelId 模型ID
|
||
* @param position 位置向量 {x, y, z}
|
||
*/
|
||
setPosition(modelId: string, position: { x: number; y: number; z: number }): void {
|
||
const meshes = this.modelDic.Get(modelId);
|
||
if (!meshes?.length) {
|
||
console.warn(`Model not found: ${modelId}`);
|
||
return;
|
||
}
|
||
|
||
this.getModelTransformTargets(meshes).forEach(mesh => {
|
||
mesh.position.x = position.x;
|
||
mesh.position.y = position.y;
|
||
mesh.position.z = position.z;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 设置模型缩放
|
||
* @param modelId 模型ID
|
||
* @param scale 缩放向量 {x, y, z}
|
||
*/
|
||
setScale(modelId: string, scale: { x: number; y: number; z: number }): void {
|
||
const meshes = this.modelDic.Get(modelId);
|
||
if (!meshes?.length) {
|
||
console.warn(`Model not found: ${modelId}`);
|
||
return;
|
||
}
|
||
|
||
this.getModelTransformTargets(meshes).forEach(mesh => {
|
||
mesh.scaling.x = scale.x;
|
||
mesh.scaling.y = scale.y;
|
||
mesh.scaling.z = scale.z;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 将模型放置到指定的放置区域
|
||
* @param modelId 模型ID
|
||
* @param zoneInfo 放置区域信息
|
||
* @param offsetDistance 距离墙面的偏移距离（默认0.1，正数向外）
|
||
*/
|
||
placeToZone(modelId: string, zoneInfo: any, offsetDistance: number = 0): void {
|
||
const meshes = this.modelDic.Get(modelId);
|
||
if (!meshes?.length) {
|
||
console.warn(`Model not found: ${modelId}`);
|
||
return;
|
||
}
|
||
|
||
// 计算放置位置：中心点 + 法线方向的偏移
|
||
const targetPosition = zoneInfo.center.add(zoneInfo.normal.scale(offsetDistance));
|
||
|
||
// 计算旋转角度：让模型面向墙面（法线的反方向）
|
||
const targetDirection = zoneInfo.normal.scale(-1);
|
||
const angle = Math.atan2(targetDirection.x, targetDirection.z);
|
||
|
||
this.getModelTransformTargets(meshes).forEach(mesh => {
|
||
// 设置位置
|
||
mesh.position.copyFrom(targetPosition);
|
||
|
||
// 设置旋转（只旋转Y轴，让模型面向墙面）
|
||
if (mesh.rotationQuaternion) {
|
||
mesh.rotationQuaternion = Quaternion.FromEulerAngles(0, angle, 0);
|
||
} else {
|
||
mesh.rotation.set(0, angle, 0);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 检查模型是否存在
|
||
* @param modelId 模型ID
|
||
* @returns 模型是否存在
|
||
*/
|
||
exists(modelId: string): boolean {
|
||
return this.modelDic.Has(modelId);
|
||
}
|
||
|
||
/**
|
||
* 应用 transform 到模型
|
||
* @param modelId 模型ID
|
||
* @param transform 变换信息
|
||
*/
|
||
private applyTransform(modelId: string, transform: ModelTransform): void {
|
||
// 应用位置
|
||
if (transform.position) {
|
||
this.setPosition(modelId, transform.position);
|
||
}
|
||
|
||
// 应用旋转（角度制）
|
||
if (transform.rotation) {
|
||
this.setRotation(modelId, transform.rotation, true);
|
||
}
|
||
|
||
// 应用缩放
|
||
if (transform.scale) {
|
||
this.setScale(modelId, transform.scale);
|
||
}
|
||
}
|
||
}
|