fuse/src/views/draw-file/board/editCAD/Renderer/Render.js

import VectorType from '../enum/VectorType.js'
import { floorplanService } from '../Service/FloorplanService.js'
import { elementService } from '../Service/ElementService.js'
import { coordinate } from '../Coordinate.js'
import { draw } from './Draw.js'
import { floorplanData } from '../FloorplanData.js'
import { furnitureService } from '../Service/FurnitureService.js'

export default class Render {
    constructor(layer) {
        this.layer = layer
        this.displayPanos = false
    }

    //绘制户型
    drawGeometry(vector, styleType, flag) {
        if (draw.context == null) {
            return
        }
        switch (vector.geoType) {
            case VectorType.Wall:
                draw.drawWall(vector, styleType)
                //draw.drawMeasures(vector);
                return
            case VectorType.Point:
                draw.drawPoint(vector)
                return
            case VectorType.SingleDoor:
                draw.drawSingleDoor(vector, styleType, flag)
                return
            case VectorType.DoubleDoor:
                draw.drawDoubleDoor(vector, styleType, flag)
                return
            case VectorType.SlideDoor:
                draw.drawSlideDoor(vector, styleType, flag)
                return
            case VectorType.SingleWindow:
                draw.drawSingleWindow(vector, styleType)
                return
            case VectorType.FrenchWindow:
                draw.drawFrenchWindow(vector, styleType)
                return
            case VectorType.BayWindow:
                draw.drawBayWindow(vector, styleType)
                return
            case VectorType.Pass:
                draw.drawPass(vector)
                return
            case VectorType.Beam:
                draw.drawBeam(vector)
                return
            case VectorType.Flue:
                draw.drawFlue(vector)
                return
            case VectorType.Corridor:
                draw.drawCorridor(vector)
                return
            case VectorType.Tag:
                draw.drawTag(vector, styleType, flag)
                return
        }

        if (furnitureService.isFurniture(vector.geoType)) {
            draw.drawFurniture(vector)
        }
    }

    //绘制交互的元素
    drawElement(vector) {
        if (draw.context == null) {
            return
        }
        switch (vector.geoType) {
            case VectorType.Point:
                draw.drawCircle(vector)
                break
            case VectorType.Line:
                draw.drawLine(vector)
                break
        }
    }

    drawPanos(panos) {
        // const angle = floorplanService.getAngle()
        // for (let i = 0; i < panos.length; ++i) {
        //     let pano = JSON.parse(JSON.stringify(panos[i]))
        //     //可能要旋转角度
        //     pano = coordinate.getVectorForRotate(pano, angle)
        //     draw.drawCircle(pano)
        //     //draw.drawText(pano, pano.vectorId)
        // }

        for (let i = 0; i < panos.length; ++i) {
            draw.drawCircle(panos[i])
        }
    }

    redrawElements() {
        if (elementService.vCheckLines.X && elementService.vCheckLines.X.display) {
            this.drawElement(elementService.vCheckLines.X)
        }

        if (elementService.vCheckLines.Y && elementService.vCheckLines.Y.display) {
            this.drawElement(elementService.vCheckLines.Y)
        }

        if (elementService.startAddWall && elementService.startAddWall.display) {
            this.drawElement(elementService.startAddWall)
        }

        if (elementService.newWall && elementService.newWall.display) {
            this.drawElement(elementService.newWall)
        }

        if (elementService.symbolPoints.Start && elementService.symbolPoints.Start.display) {
            this.drawElement(elementService.symbolPoints.Start)
        }

        if (elementService.symbolPoints.End && elementService.symbolPoints.End.display) {
            this.drawElement(elementService.symbolPoints.End)
        }

        if (elementService.checkLines.X && elementService.checkLines.X.display) {
            this.drawElement(elementService.checkLines.X)
        }

        if (elementService.checkLines.Y && elementService.checkLines.Y.display) {
            this.drawElement(elementService.checkLines.Y)
        }
    }

    redrawRooms(floor) {
        let rooms = roomService.getRooms(floor)
        for (let i = 0; i < rooms.length; ++i) {
            let img = null
            for (let j = 0; j < this.layer.app.CadManager.labels.length; ++j) {
                if (rooms[i].tagName != null && rooms[i].tagName.trim() == this.layer.app.CadManager.labels[j].text) {
                    if (this.layer.app.CadManager.labels[j].type == 'hall') {
                        img = roomService.getHallImg()
                        draw.drawRoomBackGround(rooms[i], img)
                    } else if (this.layer.app.CadManager.labels[j].type == 'room') {
                        img = roomService.getDefaultImg()
                        draw.drawRoomBackGround(rooms[i], img)
                    } else if (this.layer.app.CadManager.labels[j].type == 'other') {
                        img = roomService.getOtherImg()
                        draw.drawRoomBackGround(rooms[i], img)
                    }
                    break
                }
            }

            if (img == null) {
                img = roomService.getOtherImg()
                draw.drawRoomBackGround(rooms[i], img)
            }
        }
    }

    autoRedraw() {
        draw.clear()
        if (this.displayPanos) {
            this.drawPanos(floorplanData.panos)
        }
        let data = floorplanService.getFloorData()
        if (!data) {
            return
        }
        let walls = data.walls
        for (let key in walls) {
            this.drawGeometry(walls[key])
        }

        let points = data.points
        for (let key in points) {
            this.drawGeometry(points[key])
        }

        draw.drawSpecialPoint()

        let symbols = data.symbols
        for (let key in symbols) {
            this.drawGeometry(symbols[key])
            draw.drawSymbolPoint(symbols[key])
        }
        draw.drawSelectSymbolPoint()

        let components = data.components
        for (let key in components) {
            this.drawGeometry(components[key])
        }

        let furnitures = data.furnitures
        for (let key in furnitures) {
            this.drawGeometry(furnitures[key])
        }

        let tags = data.tags
        for (let key in tags) {
            this.drawGeometry(tags[key])
        }

        this.redrawElements()
    }

    autoRedrawForImg() {
        draw.clear()

        // if (this.displayPanos) {
        //     this.drawPanos(this.layer.panos[floorplanService.currentFloor])
        // }
        let data = floorplanService.getFloorData()
        if (!data) {
            return
        }
        let walls = data.walls
        for (let key in walls) {
            this.drawGeometry(walls[key])
        }

        // let points = data.points
        // for (let key in points) {
        //     this.drawGeometry(points[key])
        // }

        let symbols = data.symbols
        let noEnter = true
        for (let key in symbols) {
            this.drawGeometry(symbols[key], null, noEnter)
        }

        let components = data.components
        for (let key in components) {
            this.drawGeometry(components[key])
        }

        let furnitures = data.furnitures
        for (let key in furnitures) {
            this.drawGeometry(furnitures[key])
        }

        let tags = data.tags
        for (let key in tags) {
            this.drawGeometry(tags[key], null, true)
        }

        //this.redrawElements()
    }

    //下载图片
    //style表示风格
    autoRedrawForDownLoadImg(styleType) {
        draw.clear()

        if (styleType == 'style-1') {
            draw.drawBackGround('#FFFFFF')
            this.redrawRooms(floorplanService.getCurrentFloor())
        } else if (styleType == 'style-2') {
            draw.drawBackGround('#000000')
            this.redrawRooms(floorplanService.getCurrentFloor())
        } else if (styleType == 'style-3') {
            draw.drawBackGround('#FFFFFF')
        } else if (styleType == 'style-4') {
            draw.drawBackGround('#000000')
        }

        let data = floorplanService.getFloorData()
        if (!data) {
            return
        }
        let walls = data.walls
        for (let key in walls) {
            this.drawGeometry(walls[key], styleType)
        }

        let symbols = data.symbols
        let noEnter = false
        for (let key in symbols) {
            this.drawGeometry(symbols[key], styleType, noEnter)
        }

        let components = data.components
        for (let key in components) {
            this.drawGeometry(components[key])
        }

        let furnitures = data.furnitures
        for (let key in furnitures) {
            this.drawGeometry(furnitures[key])
        }
        let tags = data.tags
        for (let key in tags) {
            this.drawGeometry(tags[key], styleType)
        }

        draw.drawCompass(styleType)
    }

    redrawCore() {
        console.log('重绘！')
        draw.clear()

        let data = floorplanService.getFloorData()
        if (!data) {
            return
        }
        let walls = data.walls
        for (let key in walls) {
            this.drawGeometry(walls[key])
        }

        let points = data.points
        for (let key in points) {
            this.drawGeometry(points[key])
        }

        let symbols = data.symbols
        for (let key in symbols) {
            this.drawGeometry(symbols[key])
        }

        let components = data.components
        for (let key in components) {
            this.drawGeometry(components[key])
        }

        let furnitures = data.furnitures
        for (let key in furnitures) {
            this.drawGeometry(furnitures[key])
        }
    }

    clear() {
        draw.clear()
    }

    getContext() {
        return draw.context
    }
}

// const render = new Render()
// export { render }