arx-level-generator/dist/src/prefabs/rooms/room.js

A tool for creating Arx Fatalis maps

import { ArxPolygonFlags } from 'arx-convert/types';
import { Group, MathUtils, Vector2 } from 'three';
import { ArxMap } from '../../ArxMap.js';
import { Material } from '../../Material.js';
import { createPlaneMesh } from '../mesh/plane.js';
import { scaleUV } from '../../tools/mesh/scaleUV.js';
const fitUV = ({ fitX, fitY, tileSize, size, }, geometry) => {
    if (fitX && fitY) {
        // stretch
        scaleUV(new Vector2(tileSize / size.x, tileSize / size.y), geometry);
    }
    if (fitX && !fitY) {
        // fit horizontally
        scaleUV(new Vector2(tileSize / size.x, tileSize / size.x), geometry);
    }
    if (!fitX && fitY) {
        // fit vertically
        scaleUV(new Vector2(tileSize / size.y, tileSize / size.y), geometry);
    }
    if (!fitX && !fitY) {
        // tile
        scaleUV(new Vector2(tileSize / 100, tileSize / 100), geometry);
    }
};
const createFloor = (size, textureDef, tileSize) => {
    const { x: width, z: depth } = size;
    const { texture, fitX, fitY } = textureDef;
    const size2D = new Vector2(width, depth);
    const mesh = createPlaneMesh({
        size: size2D,
        tileSize,
        texture: Material.fromTexture(texture, {
            flags: fitX && fitY ? ArxPolygonFlags.None : ArxPolygonFlags.Tiled,
        }),
    });
    fitUV({
        fitX,
        fitY,
        tileSize,
        size: size2D,
    }, mesh.geometry);
    return mesh;
};
const createNorthWall = (size, textureDef, tileSize) => {
    const { x: width, y: height, z: depth } = size;
    const { texture, fitX, fitY } = textureDef;
    const size2D = new Vector2(width, height);
    const mesh = createPlaneMesh({
        size: size2D,
        tileSize,
        texture: Material.fromTexture(texture, {
            flags: fitX && fitY ? ArxPolygonFlags.None : ArxPolygonFlags.Tiled,
        }),
    });
    mesh.translateZ(depth / 2).translateY(-height / 2);
    mesh.rotateX(MathUtils.degToRad(90));
    fitUV({
        fitX,
        fitY,
        tileSize,
        size: size2D,
    }, mesh.geometry);
    return mesh;
};
const createSouthWall = (size, textureDef, tileSize) => {
    const { x: width, y: height, z: depth } = size;
    const { texture, fitX, fitY } = textureDef;
    const size2D = new Vector2(width, height);
    const mesh = createPlaneMesh({
        size: size2D,
        tileSize,
        texture: Material.fromTexture(texture, {
            flags: fitX && fitY ? ArxPolygonFlags.None : ArxPolygonFlags.Tiled,
        }),
    });
    mesh.translateZ(-depth / 2).translateY(-height / 2);
    mesh.rotateX(MathUtils.degToRad(90)).rotateZ(MathUtils.degToRad(180));
    fitUV({
        fitX,
        fitY,
        tileSize,
        size: size2D,
    }, mesh.geometry);
    return mesh;
};
const createWestWall = (size, textureDef, tileSize) => {
    const { x: width, y: height, z: depth } = size;
    const { texture, fitX, fitY } = textureDef;
    const size2D = new Vector2(depth, height);
    const mesh = createPlaneMesh({
        size: size2D,
        tileSize,
        texture: Material.fromTexture(texture, {
            flags: fitX && fitY ? ArxPolygonFlags.None : ArxPolygonFlags.Tiled,
        }),
    });
    mesh.translateX(-width / 2).translateY(-height / 2);
    mesh.rotateX(MathUtils.degToRad(90)).rotateZ(MathUtils.degToRad(90));
    fitUV({
        fitX,
        fitY,
        tileSize,
        size: size2D,
    }, mesh.geometry);
    return mesh;
};
const createEastWall = (size, textureDef, tileSize) => {
    const { x: width, y: height, z: depth } = size;
    const { texture, fitX, fitY } = textureDef;
    const size2D = new Vector2(depth, height);
    const mesh = createPlaneMesh({
        size: size2D,
        tileSize,
        texture: Material.fromTexture(texture, {
            flags: fitX && fitY ? ArxPolygonFlags.None : ArxPolygonFlags.Tiled,
        }),
    });
    mesh.translateX(width / 2).translateY(-height / 2);
    mesh.rotateX(MathUtils.degToRad(90)).rotateZ(MathUtils.degToRad(-90));
    fitUV({
        fitX,
        fitY,
        tileSize,
        size: size2D,
    }, mesh.geometry);
    return mesh;
};
const createCeiling = (size, textureDef, tileSize) => {
    const { x: width, y: height, z: depth } = size;
    const { texture, fitX, fitY } = textureDef;
    const size2D = new Vector2(width, depth);
    const mesh = createPlaneMesh({
        size: size2D,
        tileSize,
        texture: Material.fromTexture(texture, {
            flags: fitX && fitY ? ArxPolygonFlags.None : ArxPolygonFlags.Tiled,
        }),
    });
    mesh.translateY(-height);
    mesh.rotateX(MathUtils.degToRad(180));
    fitUV({
        fitX,
        fitY,
        tileSize,
        size: size2D,
    }, mesh.geometry);
    return mesh;
};
export const createRoomMesh = (size, { textures: { wall, floor, ceiling }, tileSize = 50 }) => {
    const walls = Array.isArray(wall) ? wall : [wall, wall, wall, wall];
    const group = new Group();
    if (!floor.isRemoved) {
        group.add(createFloor(size, floor, tileSize));
    }
    if (!walls[0].isRemoved) {
        group.add(createNorthWall(size, walls[0], tileSize));
    }
    if (!walls[1].isRemoved) {
        group.add(createEastWall(size, walls[1], tileSize));
    }
    if (!walls[2].isRemoved) {
        group.add(createSouthWall(size, walls[2], tileSize));
    }
    if (!walls[3].isRemoved) {
        group.add(createWestWall(size, walls[3], tileSize));
    }
    if (!ceiling.isRemoved) {
        group.add(createCeiling(size, ceiling, tileSize));
    }
    return group;
};
export const createArxMapFromMesh = (mesh, tryToQuadify) => {
    return ArxMap.fromThreeJsMesh(mesh, { tryToQuadify });
};
export const createRoom = (dimensions, props, tryToQuadify) => {
    return createArxMapFromMesh(createRoomMesh(dimensions, props), tryToQuadify);
};
//# sourceMappingURL=room.js.map