update materials

src/materials/BasicMaterial.js

@@ -1,12 +1,12 @@
 import { MeshBasicMaterial } from 'three';
+import { propsValues } from '../tools.js';
 import Material from './Material';
 
 export default {
   extends: Material,
-  created() {
+  setup(props) {
-    this.material = new MeshBasicMaterial({
+    const material = new MeshBasicMaterial(propsValues(props, ['id']));
-      color: this.color,
+    return { material };
-    });
   },
   __hmrId: 'BasicMaterial',
 };

src/materials/LambertMaterial.js

@@ -1,12 +1,12 @@
 import { MeshLambertMaterial } from 'three';
+import { propsValues } from '../tools.js';
 import Material from './Material';
 
 export default {
   extends: Material,
-  created() {
+  setup(props) {
-    this.material = new MeshLambertMaterial({
+    const material = new MeshLambertMaterial(propsValues(props, ['id']));
-      color: this.color,
+    return { material };
-    });
   },
   __hmrId: 'LambertMaterial',
 };

src/materials/Material.js

@@ -5,42 +5,20 @@ export default {
   inject: ['three'],
   props: {
     id: String,
-    color: {
+    color: { type: [String, Number], default: '#ffffff' },
-      type: [String, Number],
+    depthTest: { type: Boolean, default: true },
-      default: '#ffffff',
+    depthWrite: { type: Boolean, default: true },
-    },
+    flatShading: Boolean,
-    depthTest: {
+    fog: { type: Boolean, default: true },
-      type: Boolean,
+    opacity: { type: Number, default: 1 },
-      default: true,
+    side: { type: Number, default: FrontSide },
-    },
+    transparent: Boolean,
-    depthWrite: {
+    vertexColors: Boolean,
-      type: Boolean,
-      default: true,
-    },
-    fog: {
-      type: Boolean,
-      default: true,
-    },
-    opacity: {
-      type: Number,
-      default: 1,
-    },
-    side: {
-      type: Number,
-      default: FrontSide,
-    },
-    transparent: {
-      type: Boolean,
-      default: false,
-    },
-    vertexColors: {
-      type: Boolean,
-      default: false,
-    },
   },
-  mounted() {
+  created() {
     this.three.materials[this.id] = this.material;
 
+    // won't work for flatShading
     ['color', 'depthTest', 'depthWrite', 'fog', 'opacity', 'transparent'].forEach(p => {
       watch(() => this[p], () => {
         if (p === 'color') {
@@ -53,15 +31,7 @@ export default {
   },
   unmounted() {
     this.material.dispose();
-  },
+    delete this.three.materials[this.id];
-  methods: {
-    propsValues() {
-      const props = {};
-      Object.entries(this.$props).forEach(([key, value]) => {
-        if (key !== 'id') props[key] = value;
-      });
-      return props;
-    },
   },
   render() {
     return [];

src/materials/PhongMaterial.js

@@ -1,12 +1,12 @@
 import { MeshPhongMaterial } from 'three';
+import { propsValues } from '../tools.js';
 import Material from './Material';
 
 export default {
   extends: Material,
-  created() {
+  setup(props) {
-    this.material = new MeshPhongMaterial({
+    const material = new MeshPhongMaterial(propsValues(props, ['id']));
-      color: this.color,
+    return { material };
-    });
   },
   __hmrId: 'PhongMaterial',
 };

src/materials/PhysicalMaterial.js

@@ -1,12 +1,22 @@
-import { MeshPhysicalMaterial } from 'three';
+import { Color, MeshPhysicalMaterial } from 'three';
-import Material from './Material';
+import { watch } from 'vue';
+import { propsValues } from '../tools.js';
+import StandardMaterial from './StandardMaterial';
 
 export default {
-  extends: Material,
+  extends: StandardMaterial,
-  created() {
+  setup(props) {
-    this.material = new MeshPhysicalMaterial({
+    const material = new MeshPhysicalMaterial(propsValues(props, ['id']));
-      color: this.color,
+    ['emissive', 'emissiveIntensity', 'metalness', 'roughness'].forEach(p => {
+      watch(() => props[p], (value) => {
+        if (p === 'emissive') {
+          material.emissive = new Color(value);
+        } else {
+          material[p] = value;
+        }
+      });
     });
+    return { material };
   },
   __hmrId: 'PhysicalMaterial',
 };

src/materials/ShaderMaterial.js

@@ -9,15 +9,11 @@ export default {
     fragmentShader: String,
   },
   mounted() {
-    if (!this.material) {
-      // this.material = new ShaderMaterial(this.$props);
-    }
     this.three.materials[this.id] = this.material;
   },
   unmounted() {
     this.material.dispose();
-  },
+    delete this.three.materials[this.id];
-  methods: {
   },
   render() {
     return [];

src/materials/StandardMaterial.js

@@ -1,38 +1,28 @@
 import { Color, MeshStandardMaterial } from 'three';
 import { watch } from 'vue';
+import { propsValues } from '../tools.js';
 import Material from './Material';
 
 export default {
   extends: Material,
   props: {
-    emissive: {
+    emissive: { type: [Number, String], default: 0 },
-      type: [Number, String],
+    emissiveIntensity: { type: Number, default: 1 },
-      default: 0,
+    metalness: { type: Number, default: 0 },
-    },
+    roughness: { type: Number, default: 1 },
-    emissiveIntensity: {
-      type: Number,
-      default: 1,
-    },
-    metalness: {
-      type: Number,
-      default: 0,
-    },
-    roughness: {
-      type: Number,
-      default: 1,
-    },
   },
-  created() {
+  setup(props) {
-    this.material = new MeshStandardMaterial(this.propsValues());
+    const material = new MeshStandardMaterial(propsValues(props, ['id']));
     ['emissive', 'emissiveIntensity', 'metalness', 'roughness'].forEach(p => {
-      watch(() => this[p], () => {
+      watch(() => props[p], (value) => {
         if (p === 'emissive') {
-          this.material.emissive = new Color(this.emissive);
+          material.emissive = new Color(value);
         } else {
-          this.material[p] = this[p];
+          material[p] = value;
         }
       });
     });
+    return { material };
   },
   __hmrId: 'StandardMaterial',
 };

src/materials/SubSurfaceMaterial.js

@@ -5,51 +5,21 @@ import ShaderMaterial from './ShaderMaterial.js';
 export default {
   extends: ShaderMaterial,
   props: {
-    diffuse: {
+    diffuse: { type: String, default: '#ffffff' },
-      type: String,
+    thicknessColor: { type: String, default: '#ffffff' },
-      default: '#ffffff',
+    thicknessDistortion: { type: Number, default: 0.4 },
-    },
+    thicknessAmbient: { type: Number, default: 0.01 },
-    thicknessColor: {
+    thicknessAttenuation: { type: Number, default: 0.7 },
-      type: String,
+    thicknessPower: { type: Number, default: 2 },
-      default: '#ffffff',
+    thicknessScale: { type: Number, default: 4 },
-    },
+    transparent: { type: Boolean, default: false },
-    thicknessDistortion: {
+    opacity: { type: Number, default: 1 },
-      type: Number,
+    vertexColors: { type: Boolean, default: false },
-      default: 0.4,
-    },
-    thicknessAmbient: {
-      type: Number,
-      default: 0.01,
-    },
-    thicknessAttenuation: {
-      type: Number,
-      default: 0.7,
-    },
-    thicknessPower: {
-      type: Number,
-      default: 2,
-    },
-    thicknessScale: {
-      type: Number,
-      default: 4,
-    },
-    transparent: {
-      type: Boolean,
-      default: false,
-    },
-    opacity: {
-      type: Number,
-      default: 1,
-    },
-    vertexColors: {
-      type: Boolean,
-      default: false,
-    },
   },
-  created() {
+  setup(props) {
     const params = SubsurfaceScatteringShader;
     const uniforms = UniformsUtils.clone(params.uniforms);
-    Object.entries(this.$props).forEach(([key, value]) => {
+    Object.entries(props).forEach(([key, value]) => {
       if (key === 'diffuse' || key === 'thicknessColor') {
         value = new Color(value);
       }
@@ -58,13 +28,15 @@ export default {
       }
     });
 
-    this.material = new TShaderMaterial({
+    const material = new TShaderMaterial({
       ...params,
       uniforms,
       lights: true,
       transparent: this.transparent,
       vertexColors: this.vertexColors,
     });
+
+    return { material };
   },
   __hmrId: 'SubSurfaceMaterial',
 };

src/tools.js

@@ -6,6 +6,16 @@ export function setFromProp(o, prop) {
   }
 };
 
+export function propsValues(props, exclude) {
+  const values = {};
+  Object.entries(props).forEach(([key, value]) => {
+    if (!exclude || (exclude && !exclude.includes(key))) {
+      values[key] = value;
+    }
+  });
+  return values;
+};
+
 export function lerp(value1, value2, amount) {
   amount = amount < 0 ? 0 : amount;
   amount = amount > 1 ? 1 : amount;