kitchen-simulator 5.0.0-test.4 → 5.0.0-test.5

package/src/catalog/factories/wall-factory-3d.js

@@ -1,296 +0,0 @@
-import {
-  TextureLoader,
-  Mesh,
-  RepeatWrapping,
-  Vector2,
-  BoxGeometry,
-  MeshBasicMaterial,
-  MeshStandardMaterial,
-  Group,
-  CubeTextureLoader,
-  sRGBEncoding,
-  DoubleSide
-} from 'three';
-
-import { verticesDistance } from '../../utils/geometry';
-import * as Three from 'three';
-import { textureCube, isElevationView } from '../../../src/utils/helper';
-
-import * as SharedStyle from '../../shared-style';
-import {
-  MODE_ELEVATION_VIEW,
-  LINE_THICKNESS,
-  UNIT_CENTIMETER
-} from '../../constants';
-import convert from 'convert-units';
-import ThreeBSP from '../../utils/threeCSG.es6';
-
-const params = {
-  envMap: 'HDR',
-  roughness: 0.1,
-  metalness: 0.1,
-  exposure: 0.1
-  // debug: false
-};
-const halfPI = Math.PI / 2;
-
-/**
- * Apply a texture to a wall face
- * @param material: The material of the face
- * @param texture: The texture to load
- * @param length: The lenght of the face
- * @param height: The height of the face
- */
-const applyTexture = (material, texture, length, height) => {
-  let loader = new TextureLoader();
-
-  if (texture) {
-    material.map = loader.load(texture.uri.default);
-    (material.map.colorSpace = Three.SRGBColorSpace),
-      (material.needsUpdate = true);
-    material.map.wrapS = RepeatWrapping;
-    material.map.wrapT = RepeatWrapping;
-    material.map.repeat.set(
-      length * texture.lengthRepeatScale,
-      height * texture.heightRepeatScale
-    );
-
-    if (texture.normal) {
-      material.normalMap = loader.load(texture.normal.uri.default);
-      material.normalScale = new Vector2(
-        texture.normal.normalScaleX,
-        texture.normal.normalScaleY
-      );
-      material.normalMap.wrapS = RepeatWrapping;
-      material.normalMap.wrapT = RepeatWrapping;
-      material.normalMap.repeat.set(
-        length * texture.normal.lengthRepeatScale,
-        height * texture.normal.heightRepeatScale
-      );
-    }
-  }
-};
-
-export function buildWall(element, layer, scene, textures, mode) {
-  // Get the two vertices of the wall
-  let vetName0 = element.vertices.get(0);
-  let vetName1 = element.vertices.get(1);
-  // let invert = element.toJS().invert;
-
-  // As long as its two ending points is same. This is no longer a line.
-  if (vetName0 === vetName1) {
-    return Promise.resolve(null);
-  }
-
-  let wallColor;
-  layer.lines.forEach(data => {
-    wallColor = data.wallColor;
-  });
-  let vertex0 = layer.vertices.get(vetName0);
-  let vertex1 = layer.vertices.get(vetName1);
-
-  // Get height and thickness of the wall converting them into the current scene units
-  // let height = element.properties.getIn(['height', 'length']);
-  // let thickness = element.properties.getIn(['thickness', 'length']);
-  let height = convert(layer.ceilHeight).from(layer.unit).to(UNIT_CENTIMETER);
-  let thickness = 2.0;
-
-  let distance = verticesDistance(vertex0, vertex1);
-
-  let soulMaterial = new Three.MeshPhongMaterial({
-    color: new Three.Color(wallColor).convertLinearToSRGB()
-  }); //element.selected ? SharedStyle.MESH_SELECTED : 0xD3D3D3
-  let soulVertices = [];
-  soulVertices.push(new Three.Vector2(-distance / 2, height / 2));
-  soulVertices.push(new Three.Vector2(distance / 2, height / 2));
-  soulVertices.push(new Three.Vector2(distance / 2, -height / 2));
-  soulVertices.push(new Three.Vector2(-distance / 2, -height / 2));
-  let soulShape = new Three.Shape(soulVertices);
-  let soulMesh = new Mesh(
-    new BoxGeometry(distance, height, thickness),
-    soulMaterial
-  );
-
-  if (element.userData.stateMode !== 'MODE_DRAWING_HOLE_3D') {
-    element.holes.forEach(holeID => {
-      let holeData = layer.holes.get(holeID);
-      if (holeData !== undefined) {
-        let holeWidth = holeData.properties.getIn(['width', 'length']);
-        let holeHeight = holeData.properties.getIn(['height', 'length']);
-        let holeAltitude = holeData.properties.getIn(['altitude', 'length']);
-        let offset = holeData.offset;
-        // if (vertex0.x > vertex1.x) offset = 1 - offset;
-        // if (invert) offset = 1 - offset;
-        let holeDistance = offset * distance;
-
-        let holeVertices = [];
-        holeVertices.push(new Three.Vector2(0, holeHeight));
-        holeVertices.push(new Three.Vector2(holeWidth, holeHeight));
-        holeVertices.push(new Three.Vector2(holeWidth, 0));
-        holeVertices.push(new Three.Vector2(0, 0));
-        for (let i = 0; i < holeVertices.length; i++) {
-          holeVertices[i].x += holeDistance - distance / 2 - holeWidth / 2;
-          holeVertices[i].y -= height / 2 - holeAltitude;
-        }
-        let shapeHole = new Three.Shape(holeVertices);
-        soulShape.holes.push(shapeHole);
-
-        let holeGeometry = new BoxGeometry(holeWidth, holeHeight, thickness);
-        let holeMesh = new Mesh(holeGeometry);
-        holeMesh.position.x += holeWidth / 2;
-        holeMesh.position.y += holeHeight / 2;
-
-        holeMesh.position.x += holeDistance - distance / 2 - holeWidth / 2;
-        holeMesh.position.y -= height / 2 - holeAltitude;
-
-        let wallBSP = new ThreeBSP(soulMesh);
-        let holeBSP = new ThreeBSP(holeMesh);
-
-        let wallWithHoleBSP = wallBSP.subtract(holeBSP);
-        soulMesh = wallWithHoleBSP.toMesh(soulMaterial);
-      }
-    });
-  }
-
-  let cAlpha = new Three.Vector2(
-    vertex0.x - vertex1.x,
-    vertex0.y - vertex1.y
-  ).angle();
-  let soulGeometry = new Three.ShapeGeometry(soulShape);
-  let soul = new Mesh(soulGeometry, soulMaterial);
-  soul.receiveShadow = true;
-  soul.castShadow = true;
-  soul.position.y += height / 2;
-  soul.rotation.y = cAlpha + Math.PI;
-  soul.name = 'soulFace';
-
-  soulMesh.position.y += height / 2;
-  soulMesh.rotation.y = cAlpha + Math.PI;
-  soulMesh.name = 'soul';
-  soulMesh.castShadow = true;
-
-  let frontMaterial = new MeshStandardMaterial({
-    color: new Three.Color(wallColor).convertLinearToSRGB(),
-    metalness: 0.1,
-    roughness: 0.9
-    // envMap: textureCube,
-  });
-  let backMaterial = new MeshStandardMaterial({
-    color: new Three.Color(wallColor).convertLinearToSRGB(),
-    metalness: 0.1,
-    roughness: 0.9
-    // envMap: textureCube,
-  });
-  applyTexture(
-    frontMaterial,
-    textures[element.properties.get('textureB')],
-    distance,
-    height
-  );
-  applyTexture(
-    backMaterial,
-    textures[element.properties.get('textureB')],
-    distance,
-    height
-  );
-
-  let frontFace = soul.clone();
-  frontFace.material = frontMaterial;
-  frontFace.name = 'frontFace';
-
-  soulMesh.material = frontMaterial;
-
-  let merged = new Group();
-  merged.add(frontFace, soulMesh);
-
-  // if this wall is front of camera, show/hide
-  if (!isElevationView(mode)) {
-    frontFace.onBeforeRender = function (
-      renderer,
-      scene,
-      camera,
-      geometry,
-      material,
-      group
-    ) {
-      var soulMesh = this.parent.getObjectByName('soul');
-      if (geometry.attributes.normal === undefined)
-        return (soulMesh.visible = false);
-      geometry.computeVertexNormals();
-      var normals = geometry.attributes.normal.array;
-      var pos = new Three.Vector4(0, 0, 0, 1);
-      pos = pos.applyMatrix4(this.matrixWorld);
-      pos = pos.applyMatrix4(camera.matrixWorldInverse);
-
-      var normal = new Three.Vector4(normals[0], normals[1], normals[2], 0);
-      normal = normal.applyMatrix4(this.matrixWorld);
-      normal = normal.applyMatrix4(camera.matrixWorldInverse);
-
-      if (soulMesh) {
-        if (pos.dot(normal) >= 0) soulMesh.visible = false;
-        else soulMesh.visible = true;
-      }
-    };
-  }
-  return Promise.resolve(merged);
-}
-
-export function updatedWall(
-  element,
-  layer,
-  scene,
-  textures,
-  mesh,
-  oldElement,
-  differences,
-  selfDestroy,
-  selfBuild
-) {
-  let noPerf = () => {
-    selfDestroy();
-    return selfBuild();
-  };
-
-  let soul = mesh.getObjectByName('soul');
-  let frontFace = mesh.getObjectByName('frontFace');
-  let backFace = mesh.getObjectByName('backFace');
-
-  if (differences[0] == 'selected') {
-    if (soul !== undefined) {
-      if (element.selected) {
-        soul.material = new MeshBasicMaterial({
-          color: new Three.Color(
-            SharedStyle.MESH_SELECTED
-          ).convertLinearToSRGB()
-        });
-      } else {
-        let soulMaterial = frontFace ? frontFace.material : backFace.material;
-        soul.material = soulMaterial;
-      }
-    }
-  } else if (differences[0] == 'properties') {
-    if (differences[1] == 'thickness') {
-      let newThickness = LINE_THICKNESS / 2;
-      let oldThickness = LINE_THICKNESS / 2;
-      // let newThickness = element.getIn(['properties', 'thickness', 'length']);
-      // let oldThickness = oldElement.getIn(['properties', 'thickness', 'length']);
-      let halfNewThickness = newThickness / 2;
-      let texturedFaceDistance = halfNewThickness + 1;
-      let originalThickness = oldThickness / soul.scale.z;
-      let alpha = soul.rotation.y;
-
-      let xTemp = texturedFaceDistance * Math.cos(alpha - halfPI);
-      let zTemp = texturedFaceDistance * Math.sin(alpha - halfPI);
-
-      soul.scale.set(1, 1, newThickness / originalThickness);
-
-      frontFace.position.x = soul.position.x + xTemp;
-      frontFace.position.z = soul.position.z + zTemp;
-
-      backFace.position.x = soul.position.x - xTemp;
-      backFace.position.z = soul.position.z - zTemp;
-    } else return noPerf();
-  } else return noPerf();
-
-  return Promise.resolve(mesh);
-}

package/src/catalog/factories/wall-factory.jsx

@@ -1,321 +0,0 @@
-import React from 'react';
-import { buildWall, updatedWall } from './wall-factory-3d';
-import * as SharedStyle from '../../shared-style';
-import * as Geometry from '../../utils/geometry';
-import Translator from '../../translator/translator';
-import { LINE_THICKNESS } from '../../../src/constants';
-// import Line from 'src/class/line';
-import Line from '../../class/line';
-const epsilon = 20;
-const STYLE_TEXT = { textAnchor: 'middle' };
-const STYLE_LINE = {
-  stroke: SharedStyle.LINE_MESH_COLOR.unselected
-  // stroke: "red" ,
-
-  // strokeWidth:1
-};
-const STYLE_INTERIOR_LINE = {
-  strokeWidth: 1,
-  stroke: SharedStyle.INTERIOR_LINE.unselected
-};
-const STYLE_INTERIOR_LINE_SELECTED = {
-  strokeWidth: 2,
-  stroke: SharedStyle.INTERIOR_LINE.selected,
-  fill: SharedStyle.INTERIOR_LINE.selected,
-  rx: '2px'
-};
-const STYLE = {
-  fill: '#0096fd',
-  stroke: SharedStyle.COLORS.white,
-  cursor: 'move'
-};
-const STYLE_POLYGON = {
-  strokeWidth: 1,
-  strokeLinejoin: 'round',
-  stroke: SharedStyle.LINE_MESH_COLOR.unselected,
-  rx: '2px',
-  fill: SharedStyle.LINE_MESH_COLOR.unselected
-};
-const STYLE_POLYGON_SELECTED = {
-  strokeWidth: 1,
-  strokeLinejoin: 'round',
-  rx: '2px',
-  stroke: SharedStyle.LINE_MESH_COLOR.selected,
-  fill: SharedStyle.LINE_MESH_COLOR.selected
-};
-
-let translator = new Translator();
-
-/** Create Lines from State */
-let createLineGeometry = (scene, state) => {
-  let wall_thickness = LINE_THICKNESS / 2;
-  let layerID = scene.selectedLayer;
-  let layer = scene.getIn(['layers', layerID]);
-  let lines = layer.lines;
-  lines.toArray().forEach(line => {
-    let vertex0Id = line.vertices.get(0);
-    let vertex1Id = line.vertices.get(1);
-    let { x: x0, y: y0 } = layer.vertices.get(vertex0Id);
-    let { x: x1, y: y1 } = layer.vertices.get(vertex1Id);
-    if (x0 == x1 && y0 == y1) return;
-
-    let allLines = layer.lines.toArray();
-    let relatedLineArray = [];
-    let relatedLine0 = allLines.filter(allLine => {
-      return (
-        allLine.vertices.toArray().includes(vertex0Id) && line.id != allLine.id
-      );
-    })[0];
-    let relatedLine1 = allLines.filter(allLine => {
-      return (
-        allLine.vertices.toArray().includes(vertex1Id) && line.id != allLine.id
-      );
-    })[0];
-    let normalVertice = Geometry.getNormaline(x0, y0, x1, y1);
-    let rx0 = x0 + normalVertice.x * wall_thickness;
-    let ry0 = y0 + normalVertice.y * wall_thickness;
-    let rx1 = x1 + normalVertice.x * wall_thickness;
-    let ry1 = y1 + normalVertice.y * wall_thickness;
-
-    let intersection = [];
-    relatedLine0
-      ? relatedLineArray.push({ index: 0, line: relatedLine0 })
-      : intersection.push({ index: 0, point: { x: rx0, y: ry0 } });
-    relatedLine1
-      ? relatedLineArray.push({ index: 1, line: relatedLine1 })
-      : intersection.push({ index: 1, point: { x: rx1, y: ry1 } });
-
-    let originalLineFunction = Geometry.linePassingThroughTwoPoints(
-      x0,
-      y0,
-      x1,
-      y1
-    );
-    originalLineFunction.c -=
-      Math.sqrt(
-        originalLineFunction.b * originalLineFunction.b +
-          originalLineFunction.a * originalLineFunction.a
-      ) * wall_thickness;
-    relatedLineArray.forEach(lineInfo => {
-      let vertexId, originx, originy;
-      let { index, line: relatedLine } = lineInfo;
-      index == 0
-        ? ((vertexId = vertex0Id), (originx = x0), (originy = y0))
-        : ((vertexId = vertex1Id), (originx = x1), (originy = y1));
-      let relatedVertices = relatedLine.vertices.toArray();
-      let relatedOtherVertexID =
-        relatedVertices[0] == vertexId
-          ? relatedVertices[1]
-          : relatedVertices[0];
-      let relatedVertex = layer.getIn(['vertices', relatedOtherVertexID]);
-      if (originx == relatedVertex.x && originy == relatedVertex.y) return;
-
-      let relatedLineFunction = Geometry.linePassingThroughTwoPoints(
-        originx,
-        originy,
-        relatedVertex.x,
-        relatedVertex.y
-      );
-      let delta = Geometry.distancePointFromLine(
-        relatedLineFunction.a,
-        relatedLineFunction.b,
-        relatedLineFunction.c,
-        index == 0 ? x1 : x0,
-        index == 0 ? y1 : y0
-      );
-      // console.log(relatedLineFunction,"relatedLinefunction")
-      if (delta < 0.01) {
-        // if the directions of the current line and related line, then no need to calculate the inteersection point
-        // let rx = originx + normalVertice.x * wall_thickness;
-        // let ry = originy + normalVertice.y * wall_thickness;
-        let rx = originx + normalVertice.x * wall_thickness;
-        let ry = originy + normalVertice.y * wall_thickness;
-        intersection.push({ index, point: { x: rx, y: ry } });
-      } else {
-        relatedLineFunction.c -=
-          (relatedVertices[0] == vertexId ? 1 : -1) *
-          Math.sqrt(
-            relatedLineFunction.b * relatedLineFunction.b +
-              relatedLineFunction.a * relatedLineFunction.a
-          ) *
-          wall_thickness;
-        let point = Geometry.twoLinesIntersection(
-          originalLineFunction.a,
-          originalLineFunction.b,
-          originalLineFunction.c,
-          relatedLineFunction.a,
-          relatedLineFunction.b,
-          relatedLineFunction.c
-        );
-        point && intersection.push({ index, point });
-      }
-    });
-    state = Line.setRelatedLine(
-      state,
-      layer.id,
-      line.id,
-      intersection
-    ).updatedState;
-  });
-  return { updatedState: state };
-};
-
-export default function WallFactory(name, info, textures) {
-  let wallElement = {
-    name,
-    prototype: 'lines',
-    info,
-    height: {
-      label: translator.t('height'),
-      type: 'length-measure',
-      defaultValue: {
-        length: 243.84
-      }
-    },
-    thickness: {
-      label: translator.t('thickness'),
-      type: 'length-measure',
-      defaultValue: {
-        length: LINE_THICKNESS / 2
-      }
-    },
-    properties: {},
-
-    render2D: function (element, layer, scene, state) {
-      state = createLineGeometry(scene, state).updatedState;
-      scene = state.getIn(['scene']);
-      layer = scene.getIn(['layers', scene.selectedLayer]);
-      element = layer.getIn(['lines', element['id']]);
-      // let element = layer.lines[telement.id];
-      let { x: x1, y: y1 } = layer.vertices.get(element.vertices.get(0));
-      let { x: x2, y: y2 } = layer.vertices.get(element.vertices.get(1));
-      let layertemp = state.sceneHistory.getIn(['last', 'layers', 'layer-1']);
-      let verticesinfo = layer.vertices.get(element.vertices.get(0));
-      let length = Geometry.pointsDistance(x1, y1, x2, y2);
-      let length_5 = length / 5;
-      let thickness = LINE_THICKNESS;
-      // let thickness = element.getIn(['properties', 'thickness', 'length']);
-      let half_thickness = thickness / 2;
-      let half_thickness_eps = half_thickness + epsilon;
-      let char_height = 11;
-      let extra_epsilon = 5;
-      let textDistance = half_thickness + epsilon + extra_epsilon;
-      let related0x = x1,
-        related0y = y1,
-        related1x = x2,
-        related1y = y2;
-      element.relatedVertices.forEach((relatedVertice, index) => {
-        if (relatedVertice.index == undefined)
-          relatedVertice = relatedVertice.toJSON();
-        if (relatedVertice.index == 0) {
-          related0x = relatedVertice.point.x;
-          related0y = relatedVertice.point.y;
-        } else {
-          related1x = relatedVertice.point.x;
-          related1y = relatedVertice.point.y;
-        }
-      });
-
-      //Fill a polygon with the pattern specified by the polygon's id.(For example:fill='url(#pat) =><pattern id="pat">)
-      const outwall = (
-        <defs>
-          <pattern
-            id="pat"
-            x="0"
-            y="0"
-            width="5"
-            height="5"
-            patternUnits="userSpaceOnUse"
-          >
-            <line x1="0" y1="0" x2="3" y2="3" style={STYLE_LINE}></line>
-          </pattern>
-        </defs>
-      );
-      return !element.selected ? (
-        <g>
-          <polygon
-            points={`${x1},${y1} ${related0x},${related0y} ${related1x},${related1y} ${x2},${y2}`}
-            fill="url(#pat)"
-            fillRule="evenodd"
-          ></polygon>
-          {outwall}
-          <line
-            x1={x1}
-            y1={y1}
-            x2={x2}
-            y2={y2}
-            style={STYLE_INTERIOR_LINE}
-          ></line>
-        </g>
-      ) : (
-        <g>
-          <polygon
-            points={`${x1},${y1} ${related0x},${related0y} ${related1x},${related1y} ${x2},${y2}`}
-            fill="url(#pat)"
-            fillRule="evenodd"
-          ></polygon>
-          {outwall}
-          <line
-            x1={x1}
-            y1={y1}
-            x2={x2}
-            y2={y2}
-            style={STYLE_INTERIOR_LINE_SELECTED}
-          ></line>
-        </g>
-      );
-    },
-
-    render3D: function (element, layer, scene, mode) {
-      return buildWall(element, layer, scene, textures, mode);
-    },
-
-    updateRender3D: (
-      element,
-      layer,
-      scene,
-      mesh,
-      oldElement,
-      differences,
-      selfDestroy,
-      selfBuild
-    ) => {
-      return updatedWall(
-        element,
-        layer,
-        scene,
-        textures,
-        mesh,
-        oldElement,
-        differences,
-        selfDestroy,
-        selfBuild
-      );
-    }
-  };
-
-  if (textures && textures !== {}) {
-    let textureValues = { none: 'None' };
-
-    for (let textureName in textures) {
-      textureValues[textureName] = textures[textureName].name;
-    }
-
-    /*    wallElement.properties.textureA = {
-      label:'Fronts ' + translator.t('texture'),
-      type: 'enum',
-      defaultValue: textureValues.bricks ? 'bricks' : 'none',
-      values: textureValues
-    };
-*/
-    wallElement.properties.textureB = {
-      //label:'Back ' + translator.t('texture'),
-      label: 'Walls',
-      type: 'enum',
-      defaultValue: textureValues.bricks ? 'bricks' : 'none',
-      values: textureValues
-    };
-  }
-
-  return wallElement;
-}