!2925 优化:点选复合实体时,右侧栏材质单独显示子实体的材质

src/Add-on/DropMaterialApply.ts

@@ -0,0 +1,44 @@
+import { Vector3 } from "three";
+import { app } from "../ApplicationServices/Application";
+import { ApplyMtlToSelectedObjs, ApplyPartMtlToInterFace } from "../Common/ApplyMaterial";
+import { GetEntity } from "../Common/Utils";
+import { PhysicalMaterialRecord } from "../DatabaseServices/PhysicalMaterialRecord";
+import { CommandWrap } from "../Editor/CommandMachine";
+import { GenerateRaycaster, PointPick, Raycast } from "../Editor/PointPick";
+import { userConfig } from "../Editor/UserConfig";
+
+export async function DropMaterialApply(pt: Vector3, getMtlFunction: () => Promise<PhysicalMaterialRecord>)
+{
+    let raycaster = GenerateRaycaster(pt, app.Viewer);
+    let intersection = Raycast(raycaster, app.Viewer.VisibleObjects, { filterErase: true });
+    if (intersection && intersection.object)
+    {
+        if (intersection.face?.materialIndex !== undefined)
+        {
+            let obj = intersection.object;
+            let en = GetEntity(obj);
+
+            await CommandWrap(async () =>
+            {
+                let mtl = await getMtlFunction();
+                if (!mtl) return;
+
+                ApplyPartMtlToInterFace(mtl, en, intersection, raycaster);
+            }, "拽拖材质应用");
+
+            return;
+        }
+    }
+
+    let selectObj = PointPick(pt, app.Viewer, { filterErase: true }, app.Viewer.VisibleObjects, userConfig.cursorSize.SquareSize);
+    if (selectObj.length > 0)
+    {
+        CommandWrap(async () =>
+        {
+            let mtl = await getMtlFunction();
+            if (!mtl) return;
+
+            ApplyMtlToSelectedObjs(mtl, selectObj, raycaster);
+        }, "拽拖材质应用");
+    }
+}

src/Common/ApplyMaterial.ts

@@ -1,19 +1,25 @@
 import { Intent } from "@blueprintjs/core";
-import { Curve, Intersection, Object3D } from "three";
+import { Curve, Intersection, Object3D, Raycaster } from "three";
 import { app } from "../ApplicationServices/Application";
 import { Board } from "../DatabaseServices/Entity/Board";
 import { Entity } from "../DatabaseServices/Entity/Entity";
+import { HardwareCompositeEntity } from "../DatabaseServices/Hardware/HardwareCompositeEntity";
 import { PhysicalMaterialRecord } from "../DatabaseServices/PhysicalMaterialRecord";
 import { BulkheadCeiling } from "../DatabaseServices/Room/Entity/Ceiling/BulkheadCeiling";
+import { Text } from "../DatabaseServices/Text/Text";
 import { CommandWrap } from "../Editor/CommandMachine";
+import { Raycast } from "../Editor/PointPick";
 import { userConfig } from "../Editor/UserConfig";
 import { VisualSpaceBox } from "../Editor/VisualSpaceBox";
+import { RenderType } from "../GraphicsSystem/RenderType";
 import { ApplyGoodInfo } from "../UI/Components/ApplyGoodInfo";
 import { AppToaster } from "../UI/Components/Toaster";
 import { CommandNames } from "./CommandNames";
 import { IsMeshMaterialEntity } from "./IsMeshMaterialEntity";
 import { GetEntity } from "./Utils";
 
+export const FilterTypes = [Curve, VisualSpaceBox, Text];
+
 /**
  * 应用材质命令：应用材质到 app SelectEntityList
  * @param material 要应用的材质
@@ -44,10 +50,7 @@ export function ApplyMtlToSelectEntityList(material: PhysicalMaterialRecord, can
     const entityList = app.Editor.SelectCtrl.SelectSet.SelectEntityList;
     for (let en of entityList)
     {
-        if (en instanceof Curve) continue;
+        if (FilterTypes.some(T => en instanceof T)) continue;
-        if (en instanceof VisualSpaceBox) continue;
-        if (en instanceof Text) continue;
-        // if (en instanceof Hole) continue;
 
         // 实体材质锁
         if (en.LockMaterial)
@@ -97,8 +100,32 @@ export function ApplyMtlToSelectEntityList(material: PhysicalMaterialRecord, can
  * @param en 实体
  * @param intersection 射线相交信息
  */
-export function ApplyPartMtlToInterFace(material: PhysicalMaterialRecord, en: Entity, intersection: Intersection)
+export function ApplyPartMtlToInterFace(material: PhysicalMaterialRecord, en: Entity, intersection: Intersection, raycaster: Raycaster)
 {
+    if (en instanceof HardwareCompositeEntity)
+    {
+        let hwdEnts: Entity[] = [];
+        en.Traverse((childrenEnt =>
+        {
+            if (childrenEnt && childrenEnt !== en && !childrenEnt.IsErase && !FilterTypes.some(T => childrenEnt instanceof T))
+                hwdEnts.push(childrenEnt);
+        }));
+
+        let objects = hwdEnts.map(childrenEnt => childrenEnt.GetDrawObjectFromRenderType(RenderType.Physical));
+        let intersection = Raycast(raycaster, objects, { filterErase: true });
+
+        let obj = intersection?.object;
+        if (obj)
+        {
+            let index = objects.findIndex(o => o === obj);
+            if (index !== -1 && hwdEnts[index])
+            {
+                en.WriteAllObjectRecord();
+                en = hwdEnts[index];
+            }
+        }
+    }
+
     if (en.LockMaterial)
     {
         LockMtlToaster(1, true);
@@ -124,7 +151,7 @@ export function ApplyPartMtlToInterFace(material: PhysicalMaterialRecord, en: En
  * @param {PhysicalMaterialRecord} material 材质
  * @param {Object3D[]} selectedObj 选中的实体
  */
-export function ApplyMtlToSelectedObjs(material: PhysicalMaterialRecord, selectedObj: Object3D[])
+export function ApplyMtlToSelectedObjs(material: PhysicalMaterialRecord, selectedObj: Object3D[], raycaster: Raycaster)
 {
     let meshMaterialCount = 0;
     const entMap = new Map();
@@ -139,6 +166,30 @@ export function ApplyMtlToSelectedObjs(material: PhysicalMaterialRecord, selecte
         if (entMap.get(en)) continue;
         entMap.set(en, true);
 
+        if (en instanceof HardwareCompositeEntity)
+        {
+            let hwdEnts: Entity[] = [];
+            en.Traverse((childrenEnt =>
+            {
+                if (childrenEnt && !childrenEnt.IsErase && !FilterTypes.some(T => childrenEnt instanceof T))
+                    hwdEnts.push(childrenEnt);
+            }));
+
+            let objects = hwdEnts.map(childrenEnt => childrenEnt.GetDrawObjectFromRenderType(RenderType.Physical));
+            let intersection = Raycast(raycaster, objects, { filterErase: true });
+
+            let obj = intersection?.object;
+            if (obj)
+            {
+                let index = objects.findIndex(o => o === obj);
+                if (index !== -1 && hwdEnts[index])
+                {
+                    en.WriteAllObjectRecord();
+                    en = hwdEnts[index];
+                }
+            }
+        }
+
         if (en.LockMaterial)
         {
             hasEntMtlLocked = true;

src/UI/Components/MaterialExplorer.tsx

@@ -5,20 +5,20 @@ import * as React from 'react';
 import Split from "react-split";
 import { Vector3 } from 'three';
 import { end } from 'xaop';
+import { DropMaterialApply } from '../../Add-on/DropMaterialApply';
 import { app } from '../../ApplicationServices/Application';
-import { ApplyMtlToSelectedObjs, ApplyPartMtlToInterFace } from '../../Common/ApplyMaterial';
+import { FilterTypes } from '../../Common/ApplyMaterial';
-import { GetEntity } from '../../Common/Utils';
+import { Entity } from '../../DatabaseServices/Entity/Entity';
-import { Hole } from '../../DatabaseServices/3DSolid/Hole';
+import { HardwareCompositeEntity } from '../../DatabaseServices/Hardware/HardwareCompositeEntity';
-import { Curve } from '../../DatabaseServices/Entity/Curve';
 import { PhysicalMaterialRecord } from '../../DatabaseServices/PhysicalMaterialRecord';
 import { MaterialTable } from '../../DatabaseServices/Tables/MaterialTable';
-import { Text } from '../../DatabaseServices/Text/Text';
 import { TextureTableEventBus, TextureTableRecord } from '../../DatabaseServices/Texture';
-import { CommandWrap } from '../../Editor/CommandMachine';
+import { PointPickOneObject } from '../../Editor/PointPick';
-import { GenerateRaycaster, PointPick, Raycast } from '../../Editor/PointPick';
 import { SelectSetBase } from '../../Editor/SelectBase';
+import { SelectBox } from '../../Editor/SelectBox';
+import { SelectPick } from '../../Editor/SelectPick';
 import { userConfig } from '../../Editor/UserConfig';
-import { VisualSpaceBox } from '../../Editor/VisualSpaceBox';
+import { RenderType } from '../../GraphicsSystem/RenderType';
 import { userConfigStore } from '../Store/UserConfigStore';
 import { Asset } from './Asset';
 import { BoardModalType } from "./Board/BoardModalType";
@@ -76,15 +76,54 @@ export class MaterialExplorer extends React.Component<{ materialTable: MaterialT
                 runInAction(() =>
                 {
                     this._selectMtls.clear();
+                    const selectEntityList = ss.SelectEntityList;
 
-                    for (let en of app.Editor.SelectCtrl.SelectSet.SelectEntityList)
+                    for (let en of selectEntityList)
                     {
-                        if (en instanceof Curve) continue;
+                        if (FilterTypes.some(T => en instanceof T)) continue;
-                        if (en instanceof VisualSpaceBox) continue;
-                        if (en instanceof Text) continue;
-                        if (en instanceof Hole) continue;
 
-                        let mtl = (en.Material?.Object as PhysicalMaterialRecord) ?? app.Database.DefaultMaterial;
+                        let mtl: PhysicalMaterialRecord = (en.Material?.Object as PhysicalMaterialRecord) ?? app.Database.DefaultMaterial;
+
+                        //复合实体能够获取子实体的材质
+                        if (en instanceof HardwareCompositeEntity)
+                        {
+                            let hwdEnts: Entity[] = [];
+
+                            en.Traverse((childrenEnt =>
+                            {
+                                if (childrenEnt && childrenEnt !== en && !childrenEnt.IsErase && !FilterTypes.some(T => childrenEnt instanceof T))
+                                    hwdEnts.push(childrenEnt);
+                            }));
+
+                            let objects = hwdEnts.map(childrenEnt => childrenEnt.GetDrawObjectFromRenderType(RenderType.Physical));
+
+                            if (ss instanceof SelectPick)
+                            {
+                                //用PointPickOneObject防止单选穿透
+                                let pickObj = PointPickOneObject(ss._PickPointVcs, app.Viewer, {}, objects);
+                                let index = objects.findIndex(obj => obj === pickObj);
+                                if (index !== -1)
+                                {
+                                    let childrenEnt = hwdEnts[index];
+                                    mtl = (childrenEnt?.Material?.Object as PhysicalMaterialRecord) ?? app.Database.DefaultMaterial;
+                                }
+                            }
+                            else if (ss instanceof SelectBox)
+                            {
+                                let pickObjs = objects.filter(obj => ss.CheckSelectTraverse(obj));
+                                for (let obj of pickObjs)
+                                {
+                                    let index = objects.findIndex(o => o === obj);
+                                    if (index !== -1)
+                                    {
+                                        let childrenEnt = hwdEnts[index];
+                                        mtl = (childrenEnt?.Material?.Object as PhysicalMaterialRecord) ?? app.Database.DefaultMaterial;
+                                        this._selectMtls.add(mtl);
+                                    }
+                                }
+                                continue;
+                            }
+                        }
 
                         this._selectMtls.add(mtl);
                     }
@@ -145,32 +184,10 @@ export class MaterialExplorer extends React.Component<{ materialTable: MaterialT
             return;
         e.stopPropagation();
 
-        let pt = new Vector3(e.offsetX, e.offsetY, 0);
+        let pt = new Vector3(e.offsetX, e.offsetY);
-        let raycaster = GenerateRaycaster(pt, app.Viewer);
-        let intersection = Raycast(raycaster, app.Viewer.VisibleObjects, { filterErase: true });
-        if (intersection && intersection.object)
-        {
-            if (intersection.face?.materialIndex !== undefined)
-            {
-                let obj = intersection.object;
-                let en = GetEntity(obj);
-                CommandWrap(() =>
-                {
-                    ApplyPartMtlToInterFace(material, en, intersection);
-                }, "拽拖材质槽应用");
-
-                return;
-            }
-        }
 
-        let selectObj = PointPick(pt, app.Viewer, { filterErase: true }, app.Viewer.VisibleObjects, userConfig.cursorSize.SquareSize);
+        const GetMtlFunction = async () => { return material; };
-        if (selectObj.length > 0)
+        await DropMaterialApply(pt, GetMtlFunction);
-        {
-            CommandWrap(() =>
-            {
-                ApplyMtlToSelectedObjs(material, selectObj);
-            }, "拽拖材质应用");
-        }
     };
     handleClick = (mat: PhysicalMaterialRecord) =>
     {

src/UI/Components/SourceManage/MaterialList.tsx

@@ -3,18 +3,19 @@ import { IObservableValue } from 'mobx';
 import { observer } from 'mobx-react';
 import * as React from 'react';
 import { Vector3 } from 'three';
+import { DropMaterialApply } from '../../../Add-on/DropMaterialApply';
 import { app } from '../../../ApplicationServices/Application';
-import { ApplyMtlToSelectEntityList, ApplyMtlToSelectedObjs, ApplyPartMtlToInterFace } from '../../../Common/ApplyMaterial';
+import { ApplyMtlToSelectEntityList } from '../../../Common/ApplyMaterial';
 import { CommandNames } from '../../../Common/CommandNames';
 import { MaterialUrls, PublishMaterialUrl } from '../../../Common/HostUrl';
 import { PostJson, RequestStatus } from '../../../Common/Request';
 import { MaterialIn, MaterialInAndAppendAppData } from '../../../Common/SerializeMaterial';
 import { DuplicateRecordCloning } from '../../../Common/Status';
-import { GetEntity, copyTextToClipboard, getFileSize } from '../../../Common/Utils';
+import { copyTextToClipboard, getFileSize } from '../../../Common/Utils';
 import { inflateBase64 } from "../../../Common/inflate";
 import { PhysicalMaterialRecord } from '../../../DatabaseServices/PhysicalMaterialRecord';
 import { CommandWrap } from '../../../Editor/CommandMachine';
-import { GenerateRaycaster, PointPick, Raycast } from '../../../Editor/PointPick';
+import { PointPick } from '../../../Editor/PointPick';
 import { userConfig } from '../../../Editor/UserConfig';
 import { appUi } from '../../Layout/ApplicationLayout';
 import { DataList } from '../Common/Datalist';
@@ -79,67 +80,50 @@ export class MaterialList extends React.Component<IImgListProps, {}>
             let selectObj = PointPick(pt, app.Viewer, { filterErase: true }, app.Viewer.VisibleObjects, userConfig.cursorSize.SquareSize);
             if (selectObj.length > 0)
             {
-                CommandWrap(async () =>
+                let mtlName = this.readyMtl.name;
-                {
+                let mtl = app.Database.MaterialTable.GetAt(mtlName);
-                    let mtlName = this.readyMtl.name;
-                    let mtl = app.Database.MaterialTable.GetAt(mtlName);
 
-                    if (!mtl)
+                if (!mtl)
+                {
+                    let json = await GetMtlJson(this.readyMtl);
+                    if (json)
                     {
-                        let json = await GetMtlJson(this.readyMtl);
+                        let mtlOut = MaterialIn(JSON.parse(json) as Object[]) as PhysicalMaterialRecord;
-                        if (json)
+                        mtlOut.Name = mtlName;
-                        {
+                        mtl = app.Database.WblockCloneObejcts(
-                            let mtlOut = MaterialIn(JSON.parse(json) as Object[]) as PhysicalMaterialRecord;
+                            [mtlOut],
-                            mtlOut.Name = mtlName;
+                            app.Database.MaterialTable,
-                            mtl = app.Database.WblockCloneObejcts(
+                            new Map(),
-                                [mtlOut],
+                            DuplicateRecordCloning.Ignore
-                                app.Database.MaterialTable,
+                        )[0] as PhysicalMaterialRecord;
-                                new Map(),
-                                DuplicateRecordCloning.Ignore
-                            )[0] as PhysicalMaterialRecord;
-                        }
-                        else
-                        {
-                            AppToaster.show({
-                                message: "错误:无法从远程获取到材质数据!",
-                                timeout: 5000,
-                                intent: Intent.DANGER,
-                            }, "no_mtl_data");
-                            return;
-                        }
-
-                        AppToaster.show({
-                            message: "材质成功加入到图纸!",
-                            timeout: 5000,
-                            intent: Intent.SUCCESS,
-                        }, "add_new_mtl");
                     }
                     else
+                    {
                         AppToaster.show({
-                            message: "图纸中已经有该材质,直接复用该材质!",
+                            message: "错误:无法从远程获取到材质数据!",
                             timeout: 5000,
-                            intent: Intent.SUCCESS,
+                            intent: Intent.DANGER,
-                        }, "dwg_has_mtl");
+                        }, "no_mtl_data");
-
+                        return;
-                    this.readyMtl = null;
+                    }
 
-                    //射线投射
+                    AppToaster.show({
-                    let raycaster = GenerateRaycaster(pt, app.Viewer);
+                        message: "材质成功加入到图纸!",
-                    let intersection = Raycast(raycaster, app.Viewer.VisibleObjects, { filterErase: true });
+                        timeout: 5000,
-                    if (intersection && intersection.object)
+                        intent: Intent.SUCCESS,
-                    {
+                    }, "add_new_mtl");
-                        if (intersection.face?.materialIndex !== undefined)
+                }
-                        {
+                else
-                            let obj = intersection.object;
+                    AppToaster.show({
-                            let en = GetEntity(obj);
+                        message: "图纸中已经有该材质,直接复用该材质!",
+                        timeout: 5000,
+                        intent: Intent.SUCCESS,
+                    }, "dwg_has_mtl");
 
-                            ApplyPartMtlToInterFace(mtl, en, intersection);
+                this.readyMtl = null;
-                            return;
-                        }
-                    }
 
-                    ApplyMtlToSelectedObjs(mtl, selectObj);
+                const GetMtlFunction = async () => { return mtl; };
-                }, "拽拖材质应用");
+                await DropMaterialApply(pt, GetMtlFunction);
             }
             else
                 this.readyMtl = null;

src/UI/Components/ToolBar/ResourceLibrary/RsourceStore.ts

@@ -2,13 +2,13 @@ import { Intent } from "@blueprintjs/core";
 import { action, observable, toJS } from "mobx";
 import { Color, MathUtils, Matrix4, RepeatWrapping, Vector3 } from "three";
 import { begin } from "xaop";
+import { DropMaterialApply } from "../../../../Add-on/DropMaterialApply";
 import { CreateDoorTr, CreateWindowTr } from "../../../../Add-on/Room/CreateWindowDoorTr";
 import { Command_DrawHole, DrawHoleType, IHoleType } from "../../../../Add-on/Room/DrawHole";
 import { GenerateCdnUrl } from "../../../../Add-on/testEntity/GenerateCdnUrl";
 import { ParseUrlName } from "../../../../Add-on/testEntity/ParseMaterialImage";
 import { U_MOVE, U_REP, U_RO, U_WORLD_MOVE, U_WORLD_REP, U_WORLD_RO, V_MOVE, V_REP, V_WORLD_MOVE, V_WORLD_REP } from "../../../../Add-on/testEntity/USE_WORLD_UV";
 import { app } from "../../../../ApplicationServices/Application";
-import { ApplyMtlToSelectedObjs, ApplyPartMtlToInterFace } from "../../../../Common/ApplyMaterial";
 import { CommandNames } from "../../../../Common/CommandNames";
 import { UserCollection } from "../../../../Common/HostUrl";
 import { KeyBoard } from "../../../../Common/KeyEnum";
@@ -25,10 +25,8 @@ import { TemplateRecord } from "../../../../DatabaseServices/Template/TemplateRe
 import { TextureTableRecord } from "../../../../DatabaseServices/Texture";
 import { CommandWrap } from "../../../../Editor/CommandMachine";
 import { JigUtils } from "../../../../Editor/JigUtils";
-import { GenerateRaycaster, PointPick, Raycast } from "../../../../Editor/PointPick";
 import { PromptStatus } from "../../../../Editor/PromptResult";
 import { ParsePlacePos } from "../../../../Editor/TranstrolControl/ParsePlacePos";
-import { userConfig } from "../../../../Editor/UserConfig";
 import { DynamicInputManage } from "../../../DynamicPrompt/DynamicInputManage";
 import { PromptBlock } from "../../../DynamicPrompt/PromptBlock";
 import { IResourceStoreIcon } from "../../../Store/OptionInterface/IOptionInterface";
@@ -744,41 +742,16 @@ export default class ResourceStore
 
             //鼠标坐标
             let pt = new Vector3(e.offsetX, e.offsetY, 0);
-            let raycaster = GenerateRaycaster(pt, app.Viewer);
-            let intersection = Raycast(raycaster, app.Viewer.VisibleObjects, { filterErase: true });
-            if (intersection && intersection.object)
-            {
-                if (intersection.face?.materialIndex !== undefined)
-                {
-                    let module_detail = await module_detailPromise;
-                    if (!module_detail) return;
-
-                    let material = await this.PraseMaterial(module_detail.path) as PhysicalMaterialRecord;
-                    if (!material) return;
-
-                    let obj = intersection.object;
-                    let en = GetEntity(obj);
-                    CommandWrap(() =>
-                    {
-                        ApplyPartMtlToInterFace(material, en, intersection);
-                    }, "拽拖材质应用");
-                    return;
-                }
-            }
 
-            let selectObj = PointPick(pt, app.Viewer, { filterErase: true }, app.Viewer.VisibleObjects, userConfig.cursorSize.SquareSize);
+            const GetMtlFunction = async () =>
-            if (selectObj.length > 0)
             {
-                CommandWrap(async () =>
+                let module_detail = await module_detailPromise;
-                {
+                if (!module_detail) return;
-                    let module_detail = await module_detailPromise;
-                    if (!module_detail) return;
 
-                    let material = await this.PraseMaterial(module_detail.path) as PhysicalMaterialRecord;
+                return await this.PraseMaterial(module_detail.path);
-                    if (!material) return;
+            };
-                    ApplyMtlToSelectedObjs(material, selectObj);
+
-                }, "拽拖材质应用");
+            await DropMaterialApply(pt, GetMtlFunction);
-            }
         }
     };