You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
677 lines
21 KiB
677 lines
21 KiB
import * as THREE from 'three'
|
|
import { BufferGeometry } from 'three'
|
|
import BaseRenderer from '@/core/base/BaseRenderer.ts'
|
|
import { decimalSumBy } from '@/core/ModelUtils'
|
|
import Constract from '@/core/Constract.ts'
|
|
import Plastic_Rough_JPG from '@/assets/Models/Plastic_Rough.jpg'
|
|
import storageBar_PNG from '@/assets/Models/storageBar.png'
|
|
import { Material } from 'three/src/materials/Material'
|
|
import { InstancedMesh } from 'three/src/objects/InstancedMesh'
|
|
//@ts-ignore
|
|
import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js'
|
|
import InstancePointManager from '@/core/manager/InstancePointManager.ts'
|
|
import InstanceMeshManager from '@/core/manager/InstanceMeshManager.ts'
|
|
import type { Object3DLike } from '@/types/ModelTypes.ts'
|
|
|
|
/**
|
|
* 货架货位渲染器
|
|
*/
|
|
export default class RackRenderer extends BaseRenderer {
|
|
static POINT_NAME = 'rack'
|
|
|
|
pointMaterial: THREE.Material
|
|
|
|
/**
|
|
* 默认点的高度, 防止和地面重合
|
|
*/
|
|
readonly defulePositionY: number = Constract.HEIGHT_WAY
|
|
readonly defaultScale: THREE.Vector3 = new THREE.Vector3(1, 1, 1)
|
|
readonly defaultRotation: THREE.Vector3 = new THREE.Vector3(0, 0, 0)
|
|
readonly defaultLineWidth: number = 0.05
|
|
|
|
|
|
bottomBarHeight = 0.2
|
|
bottomLinkHeight = 0.2
|
|
|
|
barSectionPoints = [
|
|
{ x: -0.05, y: -0.05 },
|
|
{ x: -0.025, y: -0.05 },
|
|
{ x: -0.01, y: -0.045 },
|
|
{ x: 0.05, y: -0.045 },
|
|
{ x: 0.025, y: -0.05 },
|
|
{ x: 0.05, y: -0.05 },
|
|
{ x: 0.05, y: 0.042 },
|
|
{ x: 0.042, y: 0.05 },
|
|
{ x: 0.025, y: 0.05 },
|
|
{ x: 0.025, y: 0.042 },
|
|
{ x: 0.042, y: 0.042 },
|
|
{ x: 0.042, y: -0.042 },
|
|
{ x: -0.042, y: -0.042 },
|
|
{ x: -0.042, y: 0.042 },
|
|
{ x: -0.025, y: 0.042 },
|
|
{ x: -0.025, y: 0.05 },
|
|
{ x: -0.042, y: 0.05 },
|
|
{ x: -0.05, y: 0.042 },
|
|
{ x: -0.05, y: -0.05 }
|
|
]
|
|
|
|
linkSectionPoints = [
|
|
{ x: -0.05, y: -0.05 },
|
|
{ x: -0.05, y: 0.05 },
|
|
{ x: 0, y: 0.05 },
|
|
{ x: 0, y: 0.06 },
|
|
{ x: -0.06, y: 0.06 },
|
|
{ x: -0.06, y: -0.05 },
|
|
{ x: -0.05, y: -0.05 }
|
|
]
|
|
|
|
linkBarSectionPoints = [
|
|
{ x: -0.025, y: -0.025 },
|
|
{ x: 0.025, y: -0.025 },
|
|
{ x: 0.025, y: 0.025 },
|
|
{ x: -0.025, y: 0.025 },
|
|
{ x: -0.025, y: -0.025 }
|
|
]
|
|
rackVerticalBarWidth = 0.1
|
|
rackVerticalBarDepth = 0.08
|
|
rackVerticalBarColor = 0xFF35499C
|
|
rackVerticalBarMaterial: Material = this.createVerticalBarMaterial()
|
|
|
|
rackLinkBarColor = 0xFF35499C
|
|
rackLinkBarGeometry: BufferGeometry = null
|
|
rackLinkBarMaterial: Material = this.createLinkBarMaterial()
|
|
|
|
rackHorizontalBarWidth = 0.1
|
|
rackHorizontalBarDepth = 0.08
|
|
rackHorizontalBarColor = 0xFFF97F27
|
|
rackHorizontalBarMaterial: Material = this.createHorizontalBarMaterial()
|
|
|
|
|
|
constructor(itemTypeName: string) {
|
|
super(itemTypeName)
|
|
}
|
|
|
|
/**
|
|
* 所有的点，必须使用 storeWidth/storeDepth, 改TF无效
|
|
*/
|
|
override afterCreateOrUpdatePoint(item: ItemJson, option: RendererCudOption, object: THREE.Object3D) {
|
|
super.afterCreateOrUpdatePoint(item, option, object)
|
|
|
|
const point = object
|
|
point.position.y = this.defulePositionY
|
|
|
|
//point.scale.set(_.sumBy(item.dt.bays, b=>b.bayWidth), this.defaultScale.y, item.dt.rackDepth)
|
|
point.rotation.set(
|
|
THREE.MathUtils.degToRad(item.tf[1][0]),
|
|
THREE.MathUtils.degToRad(item.tf[1][1]),
|
|
THREE.MathUtils.degToRad(item.tf[1][2])
|
|
)
|
|
}
|
|
|
|
|
|
createLineBasic(start: ItemJson, end: ItemJson, type: LinkType): THREE.Object3D {
|
|
throw new Error('not allow store line.')
|
|
}
|
|
|
|
updateLine(start: ItemJson, end: ItemJson, type: LinkType, option?: RendererCudOption) {
|
|
throw new Error('not allow store line.')
|
|
}
|
|
|
|
|
|
createPoint(item: ItemJson, option?: RendererCudOption): Object3DLike {
|
|
// 创建平面几何体
|
|
if (!item.dt.bays || !item.dt.rackDepth) {
|
|
system.showErrorDialog('RackRenderer field bays / rackDepth is null!')
|
|
return null
|
|
}
|
|
|
|
const group = new THREE.Group()
|
|
group.name = RackRenderer.POINT_NAME
|
|
|
|
// const rackWidth = decimalSumBy(item.dt.bays, (b: any) => b.bayWidth)
|
|
// const heights = []
|
|
// for (let i = 0; i < item.dt.bays.length; i++) {
|
|
// const bay = item.dt.bays[i]
|
|
// const bayHeight = decimalSumBy(bay.levelHeight)
|
|
// heights.push(bayHeight)
|
|
// }
|
|
// const rackHeight = _.max(heights)
|
|
// // 绘制背景矩形框
|
|
// const planeGeometry = new THREE.PlaneGeometry(rackWidth, item.dt.rackDepth)
|
|
//
|
|
// planeGeometry.rotateX(Math.PI / 2)
|
|
//
|
|
// const planeMaterial = new THREE.MeshBasicMaterial({
|
|
// color: '#9a9090',
|
|
// transparent: true, // 启用透明
|
|
// opacity: 0.5, // 50%透明度
|
|
// depthWrite: false, // 防止深度冲突
|
|
// side: THREE.DoubleSide // 双面渲染:ml-citation{ref="5,8" data="citationList"}
|
|
// })
|
|
// const planeMesh = new THREE.Mesh(planeGeometry, planeMaterial)
|
|
// group.add(planeMesh)
|
|
//
|
|
//
|
|
// // 绘制边框
|
|
// const lineXLen = rackWidth - this.defaultLineWidth
|
|
// const lineYLen = item.dt.rackDepth - this.defaultLineWidth
|
|
//
|
|
// const lineGeometry = new LineGeometry().setPositions([
|
|
// -(lineXLen / 2), 0, -(lineYLen / 2),
|
|
// lineXLen / 2, 0, -(lineYLen / 2),
|
|
// lineXLen / 2, 0, lineYLen / 2,
|
|
// -(lineXLen / 2), 0, lineYLen / 2,
|
|
// -(lineXLen / 2), 0, -(lineYLen / 2)
|
|
// ])
|
|
// const lineMaterial = new LineMaterial({
|
|
// color: '#0d89a5',
|
|
// linewidth: this.defaultLineWidth,
|
|
// worldUnits: true,
|
|
// resolution: new THREE.Vector2(window.innerWidth, window.innerHeight),
|
|
// side: THREE.DoubleSide
|
|
// })
|
|
// const line = new Line2(lineGeometry, lineMaterial)
|
|
// group.add(line as THREE.Object3D)
|
|
//
|
|
// let lineDistanceX = 0
|
|
//
|
|
// for (let i = 0; item.dt.bays.length > 1 && i < item.dt.bays.length - 1; i++) {
|
|
// const bay = item.dt.bays[i]
|
|
// lineDistanceX += bay.bayWidth
|
|
// const lineGeometryT = new LineGeometry().setPositions([
|
|
// -(lineDistanceX) + (lineXLen / 2), 0, lineYLen / 2,
|
|
// -(lineDistanceX) + (lineXLen / 2), 0, -(lineYLen / 2)
|
|
// ])
|
|
// const lineT = new Line2(lineGeometryT, lineMaterial)
|
|
// group.add(lineT as THREE.Object3D)
|
|
// }
|
|
|
|
const meshes = this.createRack(item, option)
|
|
|
|
// 设置位置
|
|
// group.position.set(item.tf[0][0], item.tf[0][1], item.tf[0][2])
|
|
//
|
|
// item.dt.rackWidth = rackWidth
|
|
// item.dt.rackHeight = rackHeight
|
|
return meshes
|
|
}
|
|
|
|
dispose() {
|
|
super.dispose()
|
|
this.pointMaterial?.dispose()
|
|
}
|
|
|
|
createPointBasic(item: ItemJson, option?: RendererCudOption): THREE.Object3D {
|
|
throw new Error('Rack createPointBasic not allow!')
|
|
}
|
|
|
|
createVerticalBar(length: number): THREE.BufferGeometry {
|
|
// 创建一个形状 柱子的截面形状
|
|
const shape = new THREE.Shape()
|
|
shape.moveTo(this.barSectionPoints[0].x, this.barSectionPoints[0].y)
|
|
for (let i = 1; i < this.barSectionPoints.length; i++) {
|
|
shape.lineTo(this.barSectionPoints[i].x, this.barSectionPoints[i].y)
|
|
}
|
|
|
|
// 拉伸轨迹线
|
|
const curve = new THREE.CatmullRomCurve3(
|
|
[new THREE.Vector3(0, 0, 0), new THREE.Vector3(0, length, 0)],
|
|
false, // 闭合曲线
|
|
'catmullrom',
|
|
0
|
|
)
|
|
|
|
// 挤出几何图形 参数
|
|
const options = {
|
|
steps: 1,
|
|
bevelEnabled: false,
|
|
extrudePath: curve // 设置挤出轨迹
|
|
}
|
|
// 创建挤出几何体
|
|
const geometry = new THREE.ExtrudeGeometry(shape, options)
|
|
// 调整uv方便正确贴图
|
|
this.resetUVs(geometry)
|
|
return geometry
|
|
}
|
|
|
|
createVerticalBarMaterial(): THREE.Material {
|
|
|
|
let textureLoader = new THREE.TextureLoader()
|
|
|
|
// 加载纹理
|
|
const textureHole = textureLoader.load(storageBar_PNG) // 孔洞
|
|
const textureMaterial = textureLoader.load(Plastic_Rough_JPG) // 表面材质
|
|
|
|
textureHole.repeat.set(10, 18) // X轴重复，Y轴重复
|
|
textureMaterial.repeat.set(2, 2) // X轴重复，Y轴重复
|
|
// textureHole.offset.set(0.5, 0)
|
|
// textureHole.center.set(0.5, 0)
|
|
|
|
// 必须设置包裹模式为重复
|
|
textureHole.wrapS = THREE.RepeatWrapping
|
|
textureHole.wrapT = THREE.RepeatWrapping
|
|
textureMaterial.wrapS = THREE.RepeatWrapping
|
|
textureMaterial.wrapT = THREE.RepeatWrapping
|
|
|
|
const material = new THREE.MeshPhongMaterial()
|
|
material.alphaMap = textureHole
|
|
material.normalMap = textureMaterial
|
|
material.color.setHex(this.rackVerticalBarColor, 'srgb')
|
|
material.specular.setHex(0xff6d6d6d, 'srgb')
|
|
material.transparent = true
|
|
material.needsUpdate = true
|
|
|
|
return material
|
|
}
|
|
|
|
createLinkBar(vBarLength: number, depth: number, bottomDistance: number, topDistance: number): THREE.BufferGeometry {
|
|
|
|
const bgs: BufferGeometry[] = []
|
|
const top = vBarLength - topDistance
|
|
// 创建一个形状 柱子的截面形状
|
|
const shape = new THREE.Shape()
|
|
shape.moveTo(this.linkBarSectionPoints[0].x, this.linkBarSectionPoints[0].y)
|
|
for (let i = 1; i < this.linkBarSectionPoints.length; i++) {
|
|
shape.lineTo(this.linkBarSectionPoints[i].x, this.linkBarSectionPoints[i].y)
|
|
}
|
|
|
|
// 拉伸轨迹线 横向 底部
|
|
const curveHBottom = new THREE.CatmullRomCurve3(
|
|
[new THREE.Vector3(0, bottomDistance, 0), new THREE.Vector3(0, bottomDistance, depth)],
|
|
false, // 闭合曲线
|
|
'catmullrom',
|
|
0
|
|
)
|
|
|
|
// 挤出几何图形 参数
|
|
const optionsHBottom = {
|
|
steps: 1,
|
|
bevelEnabled: false,
|
|
extrudePath: curveHBottom // 设置挤出轨迹
|
|
}
|
|
|
|
// 拉伸轨迹线 横向 底部
|
|
const curveHTop = new THREE.CatmullRomCurve3(
|
|
[new THREE.Vector3(0, top, 0), new THREE.Vector3(0, top, depth)],
|
|
false, // 闭合曲线
|
|
'catmullrom',
|
|
0
|
|
)
|
|
|
|
// 挤出几何图形 参数
|
|
const optionsHTop = {
|
|
steps: 1,
|
|
bevelEnabled: false,
|
|
extrudePath: curveHTop // 设置挤出轨迹
|
|
}
|
|
|
|
// 创建挤出几何体
|
|
const geometryHBottom = new THREE.ExtrudeGeometry(shape, optionsHBottom)
|
|
const geometryHTop = new THREE.ExtrudeGeometry(shape, optionsHTop)
|
|
bgs.push(geometryHBottom, geometryHTop)
|
|
|
|
let remainingHeight = vBarLength - bottomDistance - topDistance
|
|
|
|
// 需要创建斜杆
|
|
|
|
for (let i = 0; i < Math.floor(remainingHeight / depth); i++) {
|
|
// 拉伸轨迹线 斜向
|
|
const curveD = new THREE.CatmullRomCurve3(
|
|
(i % 2 == 0) ? [new THREE.Vector3(0, bottomDistance + depth * i, 0), new THREE.Vector3(0, bottomDistance + depth * (i + 1), depth)]
|
|
: [new THREE.Vector3(0, bottomDistance + depth * (i + 1), 0), new THREE.Vector3(0, bottomDistance + depth * (i), depth)],
|
|
false, // 闭合曲线
|
|
'catmullrom',
|
|
0
|
|
)
|
|
|
|
const optionsD = {
|
|
steps: 1,
|
|
bevelEnabled: false,
|
|
extrudePath: curveD // 设置挤出轨迹
|
|
}
|
|
|
|
const geometryD = new THREE.ExtrudeGeometry(shape, optionsD)
|
|
bgs.push(geometryD)
|
|
}
|
|
|
|
if (vBarLength - bottomDistance - topDistance > depth) {
|
|
|
|
|
|
}
|
|
|
|
// 调整uv方便正确贴图
|
|
// this.resetUVs(geometry);
|
|
return mergeGeometries(bgs)
|
|
}
|
|
|
|
createLinkBarMaterial(): THREE.Material {
|
|
|
|
const material = new THREE.MeshPhongMaterial()
|
|
material.color.setHex(this.rackLinkBarColor, 'srgb')
|
|
material.specular.setHex(0xff6d6d6d, 'srgb')
|
|
material.transparent = true
|
|
material.needsUpdate = true
|
|
|
|
return material
|
|
}
|
|
|
|
createHorizontalBar(length: number): THREE.BufferGeometry {
|
|
// 创建一个形状 柱子的截面形状
|
|
const shape = new THREE.Shape()
|
|
shape.moveTo(this.barSectionPoints[0].x, this.barSectionPoints[0].y)
|
|
for (let i = 1; i < this.barSectionPoints.length; i++) {
|
|
shape.lineTo(this.barSectionPoints[i].x, this.barSectionPoints[i].y)
|
|
}
|
|
|
|
// 拉伸轨迹线
|
|
const curve = new THREE.CatmullRomCurve3(
|
|
[new THREE.Vector3(0.05, 0, 0), new THREE.Vector3(length - 0.05, 0, 0)],
|
|
false, // 闭合曲线
|
|
'catmullrom',
|
|
0
|
|
)
|
|
|
|
// 挤出几何图形 参数
|
|
const options = {
|
|
steps: 1,
|
|
bevelEnabled: false,
|
|
extrudePath: curve // 设置挤出轨迹
|
|
}
|
|
// 创建挤出几何体
|
|
const geometry = new THREE.ExtrudeGeometry(shape, options)
|
|
|
|
const linkShapeL = new THREE.Shape()
|
|
const linkShapeR = new THREE.Shape()
|
|
linkShapeL.moveTo(this.linkSectionPoints[0].x, this.linkSectionPoints[0].y)
|
|
linkShapeR.moveTo(this.linkSectionPoints[0].x + (length), this.linkSectionPoints[0].y)
|
|
for (let i = 1; i < this.linkSectionPoints.length; i++) {
|
|
linkShapeL.lineTo(this.linkSectionPoints[i].x, this.linkSectionPoints[i].y)
|
|
linkShapeR.lineTo(this.linkSectionPoints[i].x + (length), this.linkSectionPoints[i].y)
|
|
}
|
|
|
|
// 拉伸轨迹线
|
|
const linkCurve = new THREE.CatmullRomCurve3(
|
|
[new THREE.Vector3(0, 0, -0.08), new THREE.Vector3(0, 0, 0.08)],
|
|
false, // 闭合曲线
|
|
'catmullrom',
|
|
0
|
|
)
|
|
|
|
// 挤出几何图形 参数
|
|
const linkOptions = {
|
|
steps: 1,
|
|
bevelEnabled: false,
|
|
extrudePath: linkCurve // 设置挤出轨迹
|
|
}
|
|
// 创建挤出几何体
|
|
const linkGeometryL = new THREE.ExtrudeGeometry(linkShapeL, linkOptions)
|
|
linkGeometryL.rotateZ(-Math.PI / 2)
|
|
const linkGeometryR = new THREE.ExtrudeGeometry(linkShapeR, linkOptions)
|
|
linkGeometryR.rotateX(-Math.PI)
|
|
linkGeometryR.rotateZ(-Math.PI / 2)
|
|
|
|
// 调整uv方便正确贴图
|
|
// this.resetUVs(geometry);
|
|
return mergeGeometries([geometry, linkGeometryL, linkGeometryR])
|
|
}
|
|
|
|
createHorizontalBarMaterial(): THREE.Material {
|
|
|
|
const material = new THREE.MeshPhongMaterial()
|
|
material.color.setHex(this.rackHorizontalBarColor, 'srgb')
|
|
material.specular.setHex(0xff6d6d6d, 'srgb')
|
|
material.transparent = true
|
|
material.needsUpdate = true
|
|
|
|
return material
|
|
}
|
|
|
|
createRack(item: ItemJson, option?: RendererCudOption): Object3DLike {
|
|
if (!item.dt.bays || !item.dt.rackDepth) {
|
|
system.showErrorDialog('RackRenderer field bays / rackDepth is null!')
|
|
return null
|
|
}
|
|
|
|
const rackPoint = {
|
|
x: item.tf[0][0],
|
|
y: item.tf[0][1],
|
|
z: item.tf[0][2]
|
|
}
|
|
|
|
const heights = []
|
|
for (let i = 0; i < item.dt.bays.length; i++) {
|
|
const bay = item.dt.bays[i]
|
|
const bayHeight = decimalSumBy(bay.levelHeight)
|
|
heights.push(bayHeight)
|
|
}
|
|
const rackHeight = _.max(heights)
|
|
|
|
// 计算立住坐标点和长度
|
|
const vBarMatrix: { x: number, y: number, z: number, sx: number, sy: number, sz: number, rx: number, ry: number, rz: number, l: number }[] = []
|
|
|
|
// 计算
|
|
const linkBarMatrix: { x: number, y: number, z: number, sx: number, sy: number, sz: number, rx: number, ry: number, rz: number, l: number }[] = []
|
|
|
|
let distanceX = 0, distanceY = 0
|
|
|
|
for (let i = -1; i < item.dt.bays.length; i++) {
|
|
if (i >= 0) {
|
|
const bay = item.dt.bays[i]
|
|
distanceX += bay.bayWidth
|
|
}
|
|
vBarMatrix.push({
|
|
x: rackPoint.x + distanceX,
|
|
y: rackPoint.y,
|
|
z: rackPoint.z,
|
|
sx: 0.8,
|
|
sy: 1,
|
|
sz: 1,
|
|
rx: 0,
|
|
ry: Math.PI / 2,
|
|
rz: 0,
|
|
l: rackHeight
|
|
})
|
|
vBarMatrix.push({
|
|
x: rackPoint.x + distanceX,
|
|
y: rackPoint.y,
|
|
z: rackPoint.z + item.dt.rackDepth,
|
|
sx: 0.8,
|
|
sy: 1,
|
|
sz: 1,
|
|
rx: 0,
|
|
ry: -Math.PI / 2,
|
|
rz: 0,
|
|
l: rackHeight
|
|
})
|
|
linkBarMatrix.push({
|
|
x: rackPoint.x + distanceX,
|
|
y: rackPoint.y,
|
|
z: i % 2 == 0 ? (rackPoint.z + item.dt.rackDepth) : rackPoint.z,
|
|
sx: 1,
|
|
sy: 1,
|
|
sz: 1,
|
|
rx: 0,
|
|
ry: i % 2 == 0 ? Math.PI : 0,
|
|
rz: 0,
|
|
l: rackHeight
|
|
})
|
|
}
|
|
|
|
// 计算横梁数量
|
|
const hBarMatrix: { x: number, y: number, z: number, sx: number, sy: number, sz: number, rx: number, ry: number, rz: number, l: number }[] = []
|
|
distanceX = 0
|
|
for (let i = 0; i < item.dt.bays.length; i++) {
|
|
distanceY = this.bottomBarHeight
|
|
const bay = item.dt.bays[i]
|
|
for (let j = 0; j < bay.levelHeight.length; j++) {
|
|
const levelHeight = bay.levelHeight[j]
|
|
if (distanceY <= 0) {
|
|
continue
|
|
}
|
|
hBarMatrix.push({
|
|
x: rackPoint.x + distanceX,
|
|
y: rackPoint.y + distanceY,
|
|
z: rackPoint.z,
|
|
sx: 1,
|
|
sy: 0.8,
|
|
sz: 1,
|
|
rx: Math.PI / 2,
|
|
ry: 0,
|
|
rz: 0,
|
|
l: bay.bayWidth
|
|
})
|
|
hBarMatrix.push({
|
|
x: rackPoint.x + distanceX,
|
|
y: rackPoint.y + distanceY,
|
|
z: rackPoint.z + item.dt.rackDepth,
|
|
sx: 1,
|
|
sy: 0.8,
|
|
sz: 1,
|
|
rx: -Math.PI / 2,
|
|
ry: 0,
|
|
rz: 0,
|
|
l: bay.bayWidth
|
|
})
|
|
distanceY += levelHeight
|
|
}
|
|
distanceX += bay.bayWidth
|
|
}
|
|
|
|
if (vBarMatrix.length > 0) {
|
|
const dummy = new THREE.Object3D()
|
|
|
|
// const vBarMesh = new THREE.InstancedMesh(this.rackVerticalBarGeometry, this.rackVerticalBarMaterial, vBarMatrix.length)
|
|
for (let i = 0; i < vBarMatrix.length; i++) {
|
|
const vp = vBarMatrix[i]
|
|
const wrap = this.getVBarMesh(vp.l).create(item.id)
|
|
|
|
dummy.position.set(vp.x, vp.y, vp.z)
|
|
dummy.rotation.set(vp.rx, vp.ry, vp.rz)
|
|
dummy.scale.set(vp.sx, vp.sy, vp.sz)
|
|
dummy.updateMatrix()
|
|
wrap.setMatrix4(dummy.matrix)
|
|
}
|
|
}
|
|
|
|
if (linkBarMatrix.length > 0) {
|
|
// if (!this.rackLinkBarGeometry) {
|
|
// this.rackLinkBarGeometry = this.createLinkBar(rackHeight, item.dt.rackDepth, this.bottomLinkHeight, 0.2)
|
|
// }
|
|
const meshInstance = this.getLinkBarMesh(rackHeight, item.dt.rackDepth, this.bottomLinkHeight, 0.2)
|
|
const dummy = new THREE.Object3D()
|
|
const linkBarMesh = new THREE.InstancedMesh(this.rackLinkBarGeometry, this.rackLinkBarMaterial, linkBarMatrix.length)
|
|
for (let i = 0; i < linkBarMatrix.length; i++) {
|
|
|
|
const wrap = meshInstance.create(item.id)
|
|
|
|
const lp = linkBarMatrix[i]
|
|
dummy.position.set(lp.x, lp.y, lp.z)
|
|
dummy.rotation.set(lp.rx, lp.ry, lp.rz)
|
|
dummy.scale.set(lp.sx, lp.sy, lp.sz)
|
|
dummy.updateMatrix()
|
|
// linkBarMesh.setMatrixAt(i, dummy.matrix)
|
|
wrap.setMatrix4(dummy.matrix)
|
|
}
|
|
}
|
|
|
|
if (hBarMatrix.length > 0) {
|
|
const dummy = new THREE.Object3D()
|
|
// const hBarMesh = new THREE.InstancedMesh(this.rackHorizontalBarGeometry, this.rackHorizontalBarMaterial, hBarMatrix.length)
|
|
for (let i = 0; i < hBarMatrix.length; i++) {
|
|
const hp = hBarMatrix[i]
|
|
const wrap = this.getHBarMesh(hp.l).create(item.id)
|
|
|
|
dummy.position.set(hp.x, hp.y, hp.z)
|
|
dummy.rotation.set(hp.rx, hp.ry, hp.rz)
|
|
dummy.scale.set(hp.sx, hp.sy, hp.sz)
|
|
dummy.updateMatrix()
|
|
wrap.setMatrix4(dummy.matrix)
|
|
}
|
|
}
|
|
|
|
return new THREE.Group()
|
|
}
|
|
|
|
|
|
resetUVs(geometry: THREE.ExtrudeGeometry) {
|
|
if (geometry == undefined) return
|
|
const pos = geometry.getAttribute('position'),
|
|
nor = geometry.getAttribute('normal'),
|
|
uvs = geometry.getAttribute('uv')
|
|
|
|
for (let i = 0; i < pos.count; i++) {
|
|
let x = 0, y = 0
|
|
|
|
const nx = Math.abs(nor.getX(i)), ny = Math.abs(nor.getY(i)), nz = Math.abs(nor.getZ(i))
|
|
|
|
// if facing X
|
|
if (nx >= ny && nx >= nz) {
|
|
x = pos.getZ(i)
|
|
y = pos.getY(i)
|
|
}
|
|
|
|
// if facing Y
|
|
if (ny >= nx && ny >= nz) {
|
|
x = pos.getX(i)
|
|
y = pos.getZ(i)
|
|
}
|
|
|
|
// if facing Z
|
|
if (nz >= nx && nz >= ny) {
|
|
x = pos.getX(i)
|
|
y = pos.getY(i)
|
|
}
|
|
uvs.setXY(i, x, y)
|
|
}
|
|
}
|
|
|
|
getLinkBarMesh(vBarLength: number, depth: number, bottomDistance: number, topDistance: number): InstanceMeshManager {
|
|
if (!this.tempViewport) {
|
|
throw new Error('tempViewport is not set.')
|
|
}
|
|
|
|
// rackHeight, item.dt.rackDepth, this.bottomLinkHeight, 0.2
|
|
const geometry = this.createLinkBar(vBarLength, depth, bottomDistance, topDistance)
|
|
const name = 'rack_linkbar_' + vBarLength + '_' + depth + '_' + bottomDistance + '_' + topDistance
|
|
|
|
return this.tempViewport.getOrCreateMeshManager(name, () =>
|
|
// 构建 InstanceMesh 代理对象
|
|
new InstanceMeshManager(name,
|
|
this.tempViewport,
|
|
geometry, this.rackLinkBarMaterial,
|
|
false, false, 100000)
|
|
)
|
|
}
|
|
|
|
getVBarMesh(length: number): InstanceMeshManager {
|
|
if (!this.tempViewport) {
|
|
throw new Error('tempViewport is not set.')
|
|
}
|
|
|
|
const name = 'rack_vbar' + length
|
|
|
|
return this.tempViewport.getOrCreateMeshManager(name, () => {
|
|
const geometry = this.createVerticalBar(length)
|
|
return new InstanceMeshManager(name,
|
|
this.tempViewport,
|
|
geometry, this.rackVerticalBarMaterial,
|
|
false, false, 100000)
|
|
})
|
|
}
|
|
|
|
getHBarMesh(length: number): InstanceMeshManager {
|
|
if (!this.tempViewport) {
|
|
throw new Error('tempViewport is not set.')
|
|
}
|
|
|
|
const name = 'rack_hbar' + length
|
|
|
|
return this.tempViewport.getOrCreateMeshManager(name, () => {
|
|
const geometry = this.createHorizontalBar(length)
|
|
return new InstanceMeshManager(name,
|
|
this.tempViewport,
|
|
geometry, this.rackHorizontalBarMaterial,
|
|
false, false, 100000)
|
|
})
|
|
}
|
|
}
|
|
|