• Index
• Search by APIs
• Search by Words
• Project Search

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• trois-master
  • .github
    • FUNDING.yml
  • src
    • geometries
      • TetrahedronGeometry.ts
      • ShapeGeometry.ts
      • Geometry.ts
      • ConeGeometry.ts
      • OctahedronGeometry.ts
      • index.ts
      • TorusGeometry.ts
      • PlaneGeometry.ts
      • CircleGeometry.ts
      • BoxGeometry.ts
      • RingGeometry.ts
      • LatheGeometry.ts
      • IcosahedronGeometry.ts
      • PolyhedronGeometry.ts
      • TubeGeometry.ts
      • ExtrudeGeometry.ts
      • DodecahedronGeometry.ts
      • TorusKnotGeometry.ts
      • CylinderGeometry.ts
      • SphereGeometry.ts
    • export.ts
    • materials
      • Material.ts
      • ShaderMaterial.ts
      • MatcapMaterial.ts
      • index.ts
      • CubeTexture.ts
      • VideoTexture.ts
      • types.ts
      • SubSurfaceMaterial.ts
      • SubsurfaceScatteringShader.ts
      • Texture.ts
    • shaders
      • default.ts
      • ZoomBlur.ts
      • TiltShift.ts
    • index.ts
    • models
      • GLTF.ts
      • FBX.ts
      • index.ts
      • Model.ts
    • meshes
      • Box.ts
      • Mesh.ts
      • Image.ts
      • InstancedMesh.ts
      • Sphere.ts
      • TorusKnot.ts
      • Tube.ts
      • Ring.ts
      • Sprite.ts
      • Octahedron.ts
      • index.ts
      • Dodecahedron.ts
      • Cylinder.ts
      • Plane.ts
      • Icosahedron.ts
      • Cone.ts
      • Text.ts
      • Lathe.ts
      • Polyhedron.ts
      • Torus.ts
      • Circle.ts
      • Tetrahedron.ts
      • Points.ts
    • components
      • sliders
        • Slider2.vue
        • AnimatedPlane.js
        • Slider1.vue
        • ZoomBlurImage.js
      • postprocessing
        • vanruesc
          • Effect.js
          • EffectPass.js
          • Pass.js
          • EffectComposer.js
          • index.js
      • physics
        • useCannon.js
        • CannonWorld.js
      • noisy
        • NoisyText.js
        • NoisySphere.js
        • NoisyPlane.js
        • NoisyImage.js
      • meshes
        • Gem.js
        • MirrorMesh.js
        • RefractionMesh.js
      • misc
        • VRButton.vue
        • Stats.js
      • liquid
        • LiquidPlane.js
        • LiquidEffect.js
    • plugin.ts
    • glsl
      • snoise4.glsl.js
      • snoise2.glsl.js
      • snoise3.glsl.js
    • tools.ts
    • main.ts
    • core
      • useThree.ts
      • usePointer.ts
      • Renderer.ts
      • Group.ts
      • index.ts
      • Camera.ts
      • Object3D.ts
      • useRaycaster.ts
      • Raycaster.ts
      • OrthographicCamera.ts
      • CubeCamera.ts
      • PerspectiveCamera.ts
      • Scene.ts
    • shims-vue.d.ts
    • App.vue
    • effects
      • EffectPass.ts
      • FXAAPass.ts
      • index.ts
      • SMAAPass.ts
      • UnrealBloomPass.ts
      • FilmPass.ts
      • EffectComposer.ts
      • HalftonePass.ts
      • SSAOPass.ts
      • BokehPass.ts
      • ZoomBlurPass.ts
      • RenderPass.ts
      • TiltShiftPass.ts
    • use
      • useTextures.ts
    • lights
      • HemisphereLight.ts
      • PointLight.ts
      • index.ts
      • DirectionalLight.ts
      • RectAreaLight.ts
      • AmbientLight.ts
      • Light.ts
      • SpotLight.ts
  • .npmignore
  • LICENSE
  • .devcontainer
    • devcontainer.json
  • vite.config.js
  • rollup.config.js
  • README.md
  • package.json
  • screenshots
  • index.html
  • .eslintrc.js
  • tsconfig.json
  • .gitignore
  • .vscode
    • settings.json

import { ComponentPropsOptions, ComponentPublicInstance, defineComponent, InjectionKey, PropType, watch } from 'vue'
import { Color, Material, MeshBasicMaterial, MeshLambertMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MeshToonMaterial, PointsMaterial as TPointsMaterial, Texture, ShadowMaterial as TShadowMaterial } from 'three'
import { MeshInjectionKey, MeshInterface } from '../meshes/Mesh'
import { bindObjectProp, propsValues } from '../tools'
import { BasicMaterialPropsInterface, LambertMaterialPropsInterface, MaterialPropsInterface, PhongMaterialPropsInterface, PhysicalMaterialPropsInterface, PointsMaterialPropsInterface, StandardMaterialPropsInterface, ToonMaterialPropsInterface } from './types'

export interface MaterialSetupInterface {
  mesh?: MeshInterface
  material?: Material
  createMaterial?(): Material
}

export interface MaterialInterface extends MaterialSetupInterface {
  setTexture(texture: Texture | null, key: string): void
}

export interface MaterialPublicInterface extends ComponentPublicInstance, MaterialInterface {}

export const MaterialInjectionKey: InjectionKey<MaterialPublicInterface> = Symbol('Material')

const BaseMaterial = defineComponent({
  emits: ['created'],
  props: {
    color: { type: String, default: '#ffffff' },
    props: { type: Object as PropType<MaterialPropsInterface>, default: () => ({}) },
  },
  inject: {
    mesh: MeshInjectionKey as symbol,
  },
  setup(): MaterialSetupInterface {
    return {}
  },
  provide() {
    return {
      [MaterialInjectionKey as symbol]: this,
    }
  },
  created() {
    if (!this.mesh) {
      console.error('Missing parent Mesh')
      return
    }

    if (this.createMaterial) {
      const material = this.material = this.createMaterial()
      // @ts-ignore
      watch(() => this.color, (value) => { material.color.set(value) })
      bindObjectProp(this, 'props', material, false, this.setProp)
      this.$emit('created', material)
      this.mesh.setMaterial(material)
    }
  },
  unmounted() {
    this.material?.dispose()
  },
  methods: {
    getMaterialParams() {
      return { ...propsValues(this.$props, ['props']), ...this.props }
    },
    setProp(material: any, key: string, value: any, needsUpdate = false) {
      const dstVal = material[key]
      if (dstVal instanceof Color) dstVal.set(value)
      else material[key] = value
      material.needsUpdate = needsUpdate
    },
    setTexture(texture: Texture | null, key = 'map') {
      this.setProp(this.material, key, texture, true)
    },
  },
  render() {
    return this.$slots.default ? this.$slots.default() : []
  },
  __hmrId: 'Material',
})

export default BaseMaterial

// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
export function materialComponent<P extends Readonly<ComponentPropsOptions>>(
  name: string,
  props: P,
  createMaterial: {(opts: any): Material}
) {
  return defineComponent({
    name,
    extends: BaseMaterial,
    props,
    methods: {
      createMaterial() {
        return createMaterial(this.getMaterialParams())
      },
    },
  })
}

// TODO : proper
export const BasicMaterial = materialComponent('BasicMaterial', { props: { type: Object as PropType<BasicMaterialPropsInterface>, default: () => ({}) } }, (opts) => new MeshBasicMaterial(opts))
export const LambertMaterial = materialComponent('LambertMaterial', { props: { type: Object as PropType<LambertMaterialPropsInterface>, default: () => ({}) } }, (opts) => new MeshLambertMaterial(opts))
export const PhongMaterial = materialComponent('PhongMaterial', { props: { type: Object as PropType<PhongMaterialPropsInterface>, default: () => ({}) } }, (opts) => new MeshPhongMaterial(opts))
export const PhysicalMaterial = materialComponent('PhysicalMaterial', { props: { type: Object as PropType<PhysicalMaterialPropsInterface>, default: () => ({}) } }, (opts) => new MeshPhysicalMaterial(opts))
export const PointsMaterial = materialComponent('PointsMaterial', { props: { type: Object as PropType<PointsMaterialPropsInterface>, default: () => ({}) } }, (opts) => new TPointsMaterial(opts))
export const ShadowMaterial = materialComponent('ShadowMaterial', { color: { type: String, default: '#000000' }, props: { type: Object as PropType<MaterialPropsInterface>, default: () => ({}) } }, (opts) => new TShadowMaterial(opts))
export const StandardMaterial = materialComponent('StandardMaterial', { props: { type: Object as PropType<StandardMaterialPropsInterface>, default: () => ({}) } }, (opts) => new MeshStandardMaterial(opts))
export const ToonMaterial = materialComponent('ToonMaterial', { props: { type: Object as PropType<ToonMaterialPropsInterface>, default: () => ({}) } }, (opts) => new MeshToonMaterial(opts))