codecharta-visualization 1.119.0 → 1.120.0

package/app/codeCharta/ui/codeMap/rendering/geometryGenerationHelper.ts

@@ -1,291 +0,0 @@
-import { Node } from "../../../codeCharta.model"
-import { CodeMapBuilding } from "./codeMapBuilding"
-import { Box3, Vector3 } from "three"
-import { CodeMapGeometricDescription } from "./codeMapGeometricDescription"
-import { ColorConverter } from "../../../util/color/colorConverter"
-
-export interface BoxMeasures {
-	x: number
-	y: number
-	z: number
-	width: number
-	height: number
-	depth: number
-}
-
-export interface SurfaceInformation {
-	node: Node
-	surfaceStartIndex: number
-	minPos: { z: number; x: number }
-	maxPos: { z: number; x: number }
-}
-
-export interface IntermediateVertexData {
-	positions: Float32Array
-	normals: Float32Array
-	uvs: Float32Array
-	colors: Float32Array
-
-	indices: Uint32Array
-	ids: Float32Array
-
-	deltas: Float32Array
-	isHeight: Float32Array
-}
-
-enum sides {
-	left = 0,
-	right = 1,
-	bottom = 2,
-	top = 3,
-	back = 4,
-	front = 5
-}
-
-// Vector 3: x, y, z
-const normals = [
-	[-1, 0, 0],
-	[1, 0, 0],
-	[0, -1, 0],
-	[0, 1, 0],
-	[0, 0, -1],
-	[0, 0, 1]
-]
-
-const uvArray = [
-	// Left x, y
-	1, 0, 1, 1, 0, 1, 0, 0,
-
-	// Right x, y
-	0, 0, 0, 1, 1, 1, 1, 0,
-
-	// Bottom x, y
-	0, 1, 1, 1, 1, 0, 0, 0,
-
-	// Top x, y
-	0, 1, 1, 1, 1, 0, 0, 0,
-
-	// Back x, y
-	0, 0, 1, 0, 1, 1, 0, 1,
-
-	// Front x, y
-	1, 0, 0, 0, 0, 1, 1, 1
-]
-
-const numberSides = 6
-const verticesPerSide = 4
-const threeDimensions = 3
-
-export function addBoxToVertexData(
-	data: IntermediateVertexData,
-	node: Node,
-	measures: BoxMeasures,
-	color: string,
-	subGeomIndex: number,
-	desc: CodeMapGeometricDescription,
-	delta: number
-) {
-	desc.add(
-		new CodeMapBuilding(
-			subGeomIndex,
-			new Box3(
-				new Vector3(measures.x, measures.y, measures.z),
-				new Vector3(measures.x + measures.width, measures.y + measures.height, measures.z + measures.depth)
-			),
-			node,
-			color
-		)
-	)
-
-	data.uvs.set(uvArray, subGeomIndex * uvArray.length)
-
-	setPositions(data.positions, measures, subGeomIndex)
-	setVerticesAndFaces(node, measures, color, delta, subGeomIndex, data)
-}
-
-function setPositions(positions: Float32Array, measures: BoxMeasures, index: number) {
-	const { x: minPosX, y: minPosY, z: minPosZ, width, height, depth } = measures
-	const maxPosX = minPosX + width
-	const maxPosY = minPosY + height
-	const maxPosZ = minPosZ + depth
-
-	let positionIndex = index * verticesPerSide * numberSides * threeDimensions
-
-	// Left
-	// Bottom left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = minPosZ
-	// Top left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = minPosZ
-	// Top right
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = maxPosZ
-	// Bottom right
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = maxPosZ
-
-	// Right
-	// Bottom left
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = minPosZ
-	// Top left
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = minPosZ
-	// Top right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = maxPosZ
-	// Bottom right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = maxPosZ
-
-	// Bottom
-	// Bottom left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = minPosZ
-	// Top left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = maxPosZ
-	// Top right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = maxPosZ
-	// Bottom right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = minPosZ
-
-	// Top
-	// Bottom left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = minPosZ
-	// Top left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = maxPosZ
-	// Top right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = maxPosZ
-	// Bottom right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = minPosZ
-
-	// Back
-	// Bottom left
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = maxPosZ
-	// Top left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = maxPosZ
-	// Top right
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = maxPosZ
-	// Bottom right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = maxPosZ
-
-	// Front
-	// Bottom left
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = minPosZ
-	// Top left
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = minPosY
-	positions[positionIndex++] = minPosZ
-	// Top right
-	positions[positionIndex++] = minPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = minPosZ
-	// Bottom right
-	positions[positionIndex++] = maxPosX
-	positions[positionIndex++] = maxPosY
-	positions[positionIndex++] = minPosZ
-}
-
-function isTopSide(side: number, node: Node) {
-	if (!node.isLeaf || side === sides.bottom) {
-		return [0, 0, 0, 0]
-	}
-	if (side === sides.top) {
-		return [1, 1, 1, 1]
-	}
-	if (side <= sides.right) {
-		return [0, 1, 1, 0]
-	}
-	return [0, 0, 1, 1]
-}
-
-function setVerticesAndFaces(
-	node: Node,
-	measures: BoxMeasures,
-	color: string,
-	delta: number,
-	subGeomIndex: number,
-	data: IntermediateVertexData
-) {
-	const { y: minPosY, height } = measures
-	const maxPosY = minPosY + height
-	const deltaRelativeToHeight = delta / (maxPosY - minPosY)
-
-	let index = subGeomIndex * numberSides * verticesPerSide
-	let vector3Index = index * threeDimensions
-	let surfaceStartIndex = subGeomIndex * numberSides * numberSides
-
-	const colors = ColorConverter.getVector3Array(color)
-
-	for (let side = 0; side < numberSides; side++) {
-		const topSides = isTopSide(side, node)
-		const normal = normals[side]
-		const indexBottomLeft = index
-		const indexTopLeft = index + 1
-		const indexTopRight = index + 2
-		const indexBottomRight = index + 3
-
-		data.isHeight.set(topSides, index)
-
-		for (const end = index + verticesPerSide; index < end; index++) {
-			data.normals.set(normal, vector3Index)
-			data.colors.set(colors, vector3Index)
-
-			vector3Index += threeDimensions
-
-			data.ids[index] = subGeomIndex
-			data.deltas[index] = deltaRelativeToHeight
-		}
-
-		const dimension = Math.floor(side / 2)
-		const positiveFacing = normal[dimension] === 1
-
-		if (positiveFacing) {
-			data.indices.set(
-				[indexBottomLeft, indexTopLeft, indexTopRight, indexBottomLeft, indexTopRight, indexBottomRight],
-				surfaceStartIndex
-			)
-		} else {
-			data.indices.set(
-				[indexBottomLeft, indexTopRight, indexTopLeft, indexBottomLeft, indexBottomRight, indexTopRight],
-				surfaceStartIndex
-			)
-		}
-
-		surfaceStartIndex += numberSides
-	}
-}

package/app/codeCharta/ui/codeMap/rendering/geometryGenerator.spec.ts

@@ -1,52 +0,0 @@
-import { Node } from "../../../codeCharta.model"
-import { clone } from "../../../util/clone"
-import { STATE, TEST_NODE_ROOT } from "../../../util/dataMocks"
-import { BuildResult, GeometryGenerator } from "./geometryGenerator"
-
-describe("geometryGenerator", () => {
-	let geomGen: GeometryGenerator
-	let testNodes: Node[]
-	const state = clone(STATE)
-	state.dynamicSettings.heightMetric = "a" // set to a, since it is the delta defined in TEST_NODE_ROOT
-
-	beforeEach(() => {
-		initData()
-	})
-
-	const setTestNodes = () => {
-		const updatedNode = { heightDelta: -50 } // delta has to be negative why is that ?
-		return [TEST_NODE_ROOT].map(node => {
-			return { ...node, ...updatedNode }
-		})
-	}
-
-	const initData = () => {
-		geomGen = new GeometryGenerator()
-		testNodes = setTestNodes()
-	}
-
-	describe("addBuilding", () => {
-		let buildResult: BuildResult
-		const setFlattened = (isFlat: boolean) => {
-			for (const node of testNodes) {
-				node.flat = isFlat
-			}
-		}
-
-		it("should add delta to height when not flattened", () => {
-			setFlattened(false)
-			buildResult = geomGen.build(testNodes, null, state, true)
-
-			expect(testNodes[0].flat).toBeFalsy()
-			expect(buildResult.desc.buildings[0].boundingBox.max.y).toBe(58)
-		})
-
-		it("should not add delta to height when flattened", () => {
-			setFlattened(true)
-			buildResult = geomGen.build(testNodes, null, state, true)
-
-			expect(testNodes[0].flat).toBeTruthy()
-			expect(buildResult.desc.buildings[0].boundingBox.max.y).toBe(8)
-		})
-	})
-})

package/app/codeCharta/ui/codeMap/rendering/geometryGenerator.ts

@@ -1,142 +0,0 @@
-import { Node, CcState } from "../../../codeCharta.model"
-import { CodeMapGeometricDescription } from "./codeMapGeometricDescription"
-import { addBoxToVertexData, IntermediateVertexData, BoxMeasures } from "./geometryGenerationHelper"
-import { ColorConverter } from "../../../util/color/colorConverter"
-import { Mesh, BufferGeometry, Material, BufferAttribute } from "three"
-import { treeMapSize } from "../../../util/algorithm/treeMapLayout/treeMapHelper"
-
-export interface BuildResult {
-	mesh: Mesh
-	desc: CodeMapGeometricDescription
-}
-
-export class GeometryGenerator {
-	private static MINIMAL_BUILDING_HEIGHT = 1
-
-	private floorGradient: string[]
-	private materials: Material[]
-
-	build(nodes: Node[], material: Material, state: CcState, isDeltaState: boolean): BuildResult {
-		const desc = new CodeMapGeometricDescription(treeMapSize)
-
-		this.floorGradient = ColorConverter.gradient("#333333", "#DDDDDD", this.getMaxNodeDepth(nodes))
-		this.materials = [material]
-
-		const vertices = nodes.length
-		const threeDimension = 3
-		const twoDimension = 2
-		const numberSides = 6
-		const verticesPerSide = 4
-		const size = vertices * verticesPerSide * numberSides
-
-		const data: IntermediateVertexData = {
-			positions: new Float32Array(size * threeDimension),
-			uvs: new Float32Array(size * twoDimension),
-
-			normals: new Float32Array(size * threeDimension),
-			colors: new Float32Array(size * threeDimension),
-
-			indices: new Uint32Array(vertices * numberSides * numberSides),
-			ids: new Float32Array(size),
-
-			deltas: new Float32Array(size),
-			isHeight: new Float32Array(size)
-		}
-
-		for (const [index, node] of nodes.entries()) {
-			if (!node.isLeaf) {
-				this.addFloor(data, node, index, desc)
-			} else {
-				this.addBuilding(data, node, index, desc, state, isDeltaState)
-			}
-		}
-
-		return {
-			mesh: this.buildMeshFromIntermediateVertexData(data),
-			desc
-		}
-	}
-
-	private getMaxNodeDepth(nodes: Node[]) {
-		return nodes.reduce((max, { depth }) => Math.max(depth, max), 0)
-	}
-
-	private mapNodeToLocalBox(node: Node): BoxMeasures {
-		return {
-			x: node.x0,
-			y: node.z0,
-			z: node.y0,
-			width: node.width,
-			height: node.height,
-			depth: node.length
-		}
-	}
-
-	private ensureMinHeightUnlessDeltaIsNegative(height: number, delta: number) {
-		return delta <= 0 ? height : Math.max(height, GeometryGenerator.MINIMAL_BUILDING_HEIGHT)
-	}
-
-	private addFloor(data: IntermediateVertexData, node: Node, index: number, desc: CodeMapGeometricDescription) {
-		const color = this.getMarkingColorWithGradient(node)
-		const measures = this.mapNodeToLocalBox(node)
-
-		addBoxToVertexData(data, node, measures, color, index, desc, 0)
-	}
-
-	private getMarkingColorWithGradient(node: Node) {
-		if (node.markingColor) {
-			const markingColorAsNumber = ColorConverter.getNumber(node.markingColor)
-			const markingColorWithGradient = markingColorAsNumber & (node.depth % 2 === 0 ? 0xdd_dd_dd : 0xff_ff_ff)
-			return ColorConverter.convertNumberToHex(markingColorWithGradient)
-		}
-		return this.floorGradient[node.depth]
-	}
-
-	private addBuilding(
-		data: IntermediateVertexData,
-		node: Node,
-		index: number,
-		desc: CodeMapGeometricDescription,
-		state: CcState,
-		isDeltaState: boolean
-	) {
-		const measures = this.mapNodeToLocalBox(node)
-		measures.height = this.ensureMinHeightUnlessDeltaIsNegative(node.height, node.heightDelta)
-
-		let renderDelta = 0
-
-		if (isDeltaState && node.deltas && node.deltas[state.dynamicSettings.heightMetric] && node.heightDelta) {
-			renderDelta = node.heightDelta // Set the transformed render delta
-
-			if (!node.flat && renderDelta < 0) {
-				measures.height += Math.abs(renderDelta)
-			}
-		}
-
-		addBoxToVertexData(data, node, measures, node.color, index, desc, renderDelta)
-	}
-
-	private buildMeshFromIntermediateVertexData(data: IntermediateVertexData) {
-		const threeDimensions = 3
-		const twoDimensions = 2
-
-		const deltaColors = new Float32Array(data.colors)
-
-		const geometry = new BufferGeometry()
-
-		geometry.setAttribute("position", new BufferAttribute(data.positions, threeDimensions))
-		geometry.setAttribute("normal", new BufferAttribute(data.normals, threeDimensions))
-		geometry.setAttribute("isHeight", new BufferAttribute(data.isHeight, 1))
-		geometry.setAttribute("uv", new BufferAttribute(data.uvs, twoDimensions))
-		geometry.setAttribute("color", new BufferAttribute(data.colors, threeDimensions))
-		geometry.setAttribute("deltaColor", new BufferAttribute(deltaColors, threeDimensions))
-		geometry.setAttribute("subGeomIdx", new BufferAttribute(data.ids, 1))
-		geometry.setAttribute("delta", new BufferAttribute(data.deltas, 1))
-
-		geometry.setIndex(new BufferAttribute(data.indices, 1))
-
-		geometry.addGroup(0, Number.POSITIVE_INFINITY, 0)
-
-		return new Mesh(geometry, this.materials)
-	}
-}

package/app/codeCharta/ui/codeMap/rendering/postprocessor/customComposer.spec.ts

@@ -1,170 +0,0 @@
-import { Clock, WebGLRenderer, WebGLRenderTarget } from "three"
-import { Pass } from "three/examples/jsm/postprocessing/Pass"
-import { CustomComposer } from "./customComposer"
-
-describe("CustomComposer", () => {
-	let renderer: WebGLRenderer
-	let renderTarget: WebGLRenderTarget
-	let customComposer: CustomComposer
-
-	const mockGL = () => {
-		renderer = {
-			render: jest.fn(),
-			getRenderTarget: jest.fn(),
-			setRenderTarget: jest.fn(),
-			info: {
-				render: {},
-				memory: {}
-			}
-		} as unknown as WebGLRenderer
-
-		renderTarget = {
-			clone: jest.fn().mockReturnValue({
-				texture: {
-					name: null
-				}
-			})
-		} as unknown as WebGLRenderTarget
-
-		customComposer = new CustomComposer(renderer, renderTarget)
-	}
-
-	beforeEach(() => {
-		mockGL()
-	})
-
-	describe("getInfo", () => {
-		it("should return initial result", () => {
-			expect(customComposer.getInfo()).toStrictEqual({
-				calls: 0,
-				frame: 0,
-				lines: 0,
-				triangles: 0,
-				points: 0
-			})
-		})
-
-		it("should update stats when webgl infos", () => {
-			const renderInfo = {
-				calls: 10,
-				frame: 0,
-				lines: 10,
-				triangles: 10,
-				points: 10
-			}
-
-			customComposer["info"] = [renderInfo]
-
-			expect(customComposer.getInfo()).toStrictEqual(renderInfo)
-		})
-	})
-
-	describe("getMemoryInfo", () => {
-		it("should return initial values", () => {
-			expect(customComposer.getMemoryInfo()).toStrictEqual({
-				geometries: 0,
-				textures: 0
-			})
-		})
-
-		it("should update stats when threejs infos changes", () => {
-			const memoryInfo = {
-				geometries: 10,
-				textures: 10
-			}
-
-			customComposer["memInfo"] = [memoryInfo]
-
-			expect(customComposer.getMemoryInfo()).toStrictEqual(memoryInfo)
-		})
-	})
-
-	describe("render", () => {
-		beforeEach(() => {
-			customComposer.clock = {
-				getDelta: jest.fn()
-			} as unknown as Clock
-
-			customComposer.swapBuffers = jest.fn()
-		})
-
-		it("should call getDelta", () => {
-			customComposer.render()
-
-			expect(customComposer.clock.getDelta).toBeCalled()
-		})
-
-		it("should not call getDelta when delta time is available", () => {
-			customComposer.render(1)
-
-			expect(customComposer.clock.getDelta).not.toBeCalled()
-		})
-
-		it("should call renderer getRenderTarget", () => {
-			customComposer.render()
-
-			expect(renderer.getRenderTarget).toBeCalled()
-		})
-
-		it("should call swapBuffers when needSwap is active", () => {
-			customComposer.passes = [
-				{
-					enabled: true,
-					render: jest.fn(),
-					needsSwap: true
-				} as unknown
-			] as Pass[]
-
-			customComposer.render()
-
-			expect(customComposer.swapBuffers).toHaveBeenCalledTimes(1)
-		})
-
-		it("should call renderer setRenderTarget", () => {
-			customComposer.render()
-
-			expect(renderer.setRenderTarget).toBeCalled()
-		})
-	})
-
-	describe("dispose", () => {
-		let fullScreenQuad: Pass.FullScreenQuad
-
-		beforeAll(() => {
-			fullScreenQuad = new Pass.FullScreenQuad()
-			fullScreenQuad["fsQuad"] = {
-				material: {
-					dispose: jest.fn()
-				},
-				_mesh: {
-					geometry: {
-						dispose: jest.fn()
-					}
-				}
-			}
-		})
-
-		it("should not call dispose", () => {
-			customComposer.passes = [{ enabled: true }, { enabled: true }] as Pass[]
-
-			customComposer.dispose()
-
-			expect(fullScreenQuad["fsQuad"].material.dispose).not.toBeCalled()
-			expect(fullScreenQuad["fsQuad"]._mesh.geometry.dispose).not.toBeCalled()
-		})
-
-		it("should call dispose only once", () => {
-			customComposer.passes = [
-				{
-					enabled: true
-				} as Pass,
-				fullScreenQuad as unknown as Pass
-			]
-
-			customComposer.dispose()
-
-			expect(fullScreenQuad["fsQuad"].material.dispose).toBeCalled()
-			expect(fullScreenQuad["fsQuad"]._mesh.geometry.dispose).toBeCalled()
-		})
-	})
-})