Gecko [ dp-client.com ]

Name	Size	Permission
LineBasicMaterial.js	727 B	-rw-r--r--
LineDashedMaterial.js	524 B	-rw-r--r--
Material.js	14.4 KB	-rw-r--r--
Materials.js	1.39 KB	-rw-r--r--
MeshBasicMaterial.js	1.57 KB	-rw-r--r--
MeshDepthMaterial.js	977 B	-rw-r--r--
MeshDistanceMaterial.js	699 B	-rw-r--r--
MeshLambertMaterial.js	2.54 KB	-rw-r--r--
MeshMatcapMaterial.js	1.49 KB	-rw-r--r--
MeshNormalMaterial.js	1.24 KB	-rw-r--r--
MeshPhongMaterial.js	2.67 KB	-rw-r--r--
MeshPhysicalMaterial.js	4.22 KB	-rw-r--r--
MeshStandardMaterial.js	2.66 KB	-rw-r--r--
MeshToonMaterial.js	2.2 KB	-rw-r--r--
PointsMaterial.js	719 B	-rw-r--r--
RawShaderMaterial.js	268 B	-rw-r--r--
ShaderMaterial.js	3.91 KB	-rw-r--r--
ShadowMaterial.js	513 B	-rw-r--r--
SpriteMaterial.js	761 B	-rw-r--r--

Code Editor : Material.js

import { EventDispatcher } from '../core/EventDispatcher.js';
import { FrontSide, NormalBlending, LessEqualDepth, AddEquation, OneMinusSrcAlphaFactor, SrcAlphaFactor, AlwaysStencilFunc, KeepStencilOp } from '../constants.js';
import * as MathUtils from '../math/MathUtils.js';

let _materialId = 0;

class Material extends EventDispatcher {

constructor() {

super();

this.isMaterial = true;

Object.defineProperty( this, 'id', { value: _materialId ++ } );

this.uuid = MathUtils.generateUUID();

this.name = '';
		this.type = 'Material';

this.blending = NormalBlending;
		this.side = FrontSide;
		this.vertexColors = false;

this.opacity = 1;
		this.transparent = false;
		this.alphaHash = false;

this.blendSrc = SrcAlphaFactor;
		this.blendDst = OneMinusSrcAlphaFactor;
		this.blendEquation = AddEquation;
		this.blendSrcAlpha = null;
		this.blendDstAlpha = null;
		this.blendEquationAlpha = null;

this.depthFunc = LessEqualDepth;
		this.depthTest = true;
		this.depthWrite = true;

this.stencilWriteMask = 0xff;
		this.stencilFunc = AlwaysStencilFunc;
		this.stencilRef = 0;
		this.stencilFuncMask = 0xff;
		this.stencilFail = KeepStencilOp;
		this.stencilZFail = KeepStencilOp;
		this.stencilZPass = KeepStencilOp;
		this.stencilWrite = false;

this.clippingPlanes = null;
		this.clipIntersection = false;
		this.clipShadows = false;

this.shadowSide = null;

this.colorWrite = true;

this.precision = null; // override the renderer's default precision for this material

this.polygonOffset = false;
		this.polygonOffsetFactor = 0;
		this.polygonOffsetUnits = 0;

this.dithering = false;

this.alphaToCoverage = false;
		this.premultipliedAlpha = false;
		this.forceSinglePass = false;

this.visible = true;

this.toneMapped = true;

this.userData = {};

this.version = 0;

this._alphaTest = 0;

}

get alphaTest() {

return this._alphaTest;

}

set alphaTest( value ) {

if ( this._alphaTest > 0 !== value > 0 ) {

this.version ++;

}

this._alphaTest = value;

}

onBuild( /* shaderobject, renderer */ ) {}

onBeforeRender( /* renderer, scene, camera, geometry, object, group */ ) {}

onBeforeCompile( /* shaderobject, renderer */ ) {}

customProgramCacheKey() {

return this.onBeforeCompile.toString();

}

setValues( values ) {

if ( values === undefined ) return;

for ( const key in values ) {

const newValue = values[ key ];

if ( newValue === undefined ) {

console.warn( `THREE.Material: parameter '${ key }' has value of undefined.` );
				continue;

}

const currentValue = this[ key ];

if ( currentValue === undefined ) {

console.warn( `THREE.Material: '${ key }' is not a property of THREE.${ this.type }.` );
				continue;

}

if ( currentValue && currentValue.isColor ) {

currentValue.set( newValue );

} else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) {

currentValue.copy( newValue );

} else {

this[ key ] = newValue;

}

toJSON( meta ) {

const isRootObject = ( meta === undefined || typeof meta === 'string' );

if ( isRootObject ) {

meta = {
				textures: {},
				images: {}
			};

}

const data = {
			metadata: {
				version: 4.6,
				type: 'Material',
				generator: 'Material.toJSON'
			}
		};

// standard Material serialization
		data.uuid = this.uuid;
		data.type = this.type;

if ( this.name !== '' ) data.name = this.name;

if ( this.color && this.color.isColor ) data.color = this.color.getHex();

if ( this.roughness !== undefined ) data.roughness = this.roughness;
		if ( this.metalness !== undefined ) data.metalness = this.metalness;

if ( this.sheen !== undefined ) data.sheen = this.sheen;
		if ( this.sheenColor && this.sheenColor.isColor ) data.sheenColor = this.sheenColor.getHex();
		if ( this.sheenRoughness !== undefined ) data.sheenRoughness = this.sheenRoughness;
		if ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex();
		if ( this.emissiveIntensity && this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity;

if ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex();
		if ( this.specularIntensity !== undefined ) data.specularIntensity = this.specularIntensity;
		if ( this.specularColor && this.specularColor.isColor ) data.specularColor = this.specularColor.getHex();
		if ( this.shininess !== undefined ) data.shininess = this.shininess;
		if ( this.clearcoat !== undefined ) data.clearcoat = this.clearcoat;
		if ( this.clearcoatRoughness !== undefined ) data.clearcoatRoughness = this.clearcoatRoughness;

if ( this.clearcoatMap && this.clearcoatMap.isTexture ) {

data.clearcoatMap = this.clearcoatMap.toJSON( meta ).uuid;

}

if ( this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture ) {

data.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON( meta ).uuid;

}

if ( this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture ) {

data.clearcoatNormalMap = this.clearcoatNormalMap.toJSON( meta ).uuid;
			data.clearcoatNormalScale = this.clearcoatNormalScale.toArray();

}

if ( this.iridescence !== undefined ) data.iridescence = this.iridescence;
		if ( this.iridescenceIOR !== undefined ) data.iridescenceIOR = this.iridescenceIOR;
		if ( this.iridescenceThicknessRange !== undefined ) data.iridescenceThicknessRange = this.iridescenceThicknessRange;

if ( this.iridescenceMap && this.iridescenceMap.isTexture ) {

data.iridescenceMap = this.iridescenceMap.toJSON( meta ).uuid;

}

if ( this.iridescenceThicknessMap && this.iridescenceThicknessMap.isTexture ) {

data.iridescenceThicknessMap = this.iridescenceThicknessMap.toJSON( meta ).uuid;

}

if ( this.anisotropy !== undefined ) data.anisotropy = this.anisotropy;
		if ( this.anisotropyRotation !== undefined ) data.anisotropyRotation = this.anisotropyRotation;

if ( this.anisotropyMap && this.anisotropyMap.isTexture ) {

data.anisotropyMap = this.anisotropyMap.toJSON( meta ).uuid;

}

if ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;
		if ( this.matcap && this.matcap.isTexture ) data.matcap = this.matcap.toJSON( meta ).uuid;
		if ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;

if ( this.lightMap && this.lightMap.isTexture ) {

data.lightMap = this.lightMap.toJSON( meta ).uuid;
			data.lightMapIntensity = this.lightMapIntensity;

}

if ( this.aoMap && this.aoMap.isTexture ) {

data.aoMap = this.aoMap.toJSON( meta ).uuid;
			data.aoMapIntensity = this.aoMapIntensity;

}

if ( this.bumpMap && this.bumpMap.isTexture ) {

data.bumpMap = this.bumpMap.toJSON( meta ).uuid;
			data.bumpScale = this.bumpScale;

}

if ( this.normalMap && this.normalMap.isTexture ) {

data.normalMap = this.normalMap.toJSON( meta ).uuid;
			data.normalMapType = this.normalMapType;
			data.normalScale = this.normalScale.toArray();

}

if ( this.displacementMap && this.displacementMap.isTexture ) {

data.displacementMap = this.displacementMap.toJSON( meta ).uuid;
			data.displacementScale = this.displacementScale;
			data.displacementBias = this.displacementBias;

}

if ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;
		if ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;

if ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;
		if ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;
		if ( this.specularIntensityMap && this.specularIntensityMap.isTexture ) data.specularIntensityMap = this.specularIntensityMap.toJSON( meta ).uuid;
		if ( this.specularColorMap && this.specularColorMap.isTexture ) data.specularColorMap = this.specularColorMap.toJSON( meta ).uuid;

if ( this.envMap && this.envMap.isTexture ) {

data.envMap = this.envMap.toJSON( meta ).uuid;

if ( this.combine !== undefined ) data.combine = this.combine;

}

if ( this.envMapIntensity !== undefined ) data.envMapIntensity = this.envMapIntensity;
		if ( this.reflectivity !== undefined ) data.reflectivity = this.reflectivity;
		if ( this.refractionRatio !== undefined ) data.refractionRatio = this.refractionRatio;

if ( this.gradientMap && this.gradientMap.isTexture ) {

data.gradientMap = this.gradientMap.toJSON( meta ).uuid;

}

if ( this.transmission !== undefined ) data.transmission = this.transmission;
		if ( this.transmissionMap && this.transmissionMap.isTexture ) data.transmissionMap = this.transmissionMap.toJSON( meta ).uuid;
		if ( this.thickness !== undefined ) data.thickness = this.thickness;
		if ( this.thicknessMap && this.thicknessMap.isTexture ) data.thicknessMap = this.thicknessMap.toJSON( meta ).uuid;
		if ( this.attenuationDistance !== undefined && this.attenuationDistance !== Infinity ) data.attenuationDistance = this.attenuationDistance;
		if ( this.attenuationColor !== undefined ) data.attenuationColor = this.attenuationColor.getHex();

if ( this.size !== undefined ) data.size = this.size;
		if ( this.shadowSide !== null ) data.shadowSide = this.shadowSide;
		if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;

if ( this.blending !== NormalBlending ) data.blending = this.blending;
		if ( this.side !== FrontSide ) data.side = this.side;
		if ( this.vertexColors ) data.vertexColors = true;

if ( this.opacity < 1 ) data.opacity = this.opacity;
		if ( this.transparent === true ) data.transparent = this.transparent;

data.depthFunc = this.depthFunc;
		data.depthTest = this.depthTest;
		data.depthWrite = this.depthWrite;
		data.colorWrite = this.colorWrite;

data.stencilWrite = this.stencilWrite;
		data.stencilWriteMask = this.stencilWriteMask;
		data.stencilFunc = this.stencilFunc;
		data.stencilRef = this.stencilRef;
		data.stencilFuncMask = this.stencilFuncMask;
		data.stencilFail = this.stencilFail;
		data.stencilZFail = this.stencilZFail;
		data.stencilZPass = this.stencilZPass;

// rotation (SpriteMaterial)
		if ( this.rotation !== undefined && this.rotation !== 0 ) data.rotation = this.rotation;

if ( this.polygonOffset === true ) data.polygonOffset = true;
		if ( this.polygonOffsetFactor !== 0 ) data.polygonOffsetFactor = this.polygonOffsetFactor;
		if ( this.polygonOffsetUnits !== 0 ) data.polygonOffsetUnits = this.polygonOffsetUnits;

if ( this.linewidth !== undefined && this.linewidth !== 1 ) data.linewidth = this.linewidth;
		if ( this.dashSize !== undefined ) data.dashSize = this.dashSize;
		if ( this.gapSize !== undefined ) data.gapSize = this.gapSize;
		if ( this.scale !== undefined ) data.scale = this.scale;

if ( this.dithering === true ) data.dithering = true;

if ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest;
		if ( this.alphaHash === true ) data.alphaHash = this.alphaHash;
		if ( this.alphaToCoverage === true ) data.alphaToCoverage = this.alphaToCoverage;
		if ( this.premultipliedAlpha === true ) data.premultipliedAlpha = this.premultipliedAlpha;
		if ( this.forceSinglePass === true ) data.forceSinglePass = this.forceSinglePass;

if ( this.wireframe === true ) data.wireframe = this.wireframe;
		if ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth;
		if ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap;
		if ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin;

if ( this.flatShading === true ) data.flatShading = this.flatShading;

if ( this.visible === false ) data.visible = false;

if ( this.toneMapped === false ) data.toneMapped = false;

if ( this.fog === false ) data.fog = false;

if ( Object.keys( this.userData ).length > 0 ) data.userData = this.userData;

// TODO: Copied from Object3D.toJSON

function extractFromCache( cache ) {

const values = [];

for ( const key in cache ) {

const data = cache[ key ];
				delete data.metadata;
				values.push( data );

}

return values;

}

if ( isRootObject ) {

const textures = extractFromCache( meta.textures );
			const images = extractFromCache( meta.images );

if ( textures.length > 0 ) data.textures = textures;
			if ( images.length > 0 ) data.images = images;

}

return data;

}

clone() {

return new this.constructor().copy( this );

}

copy( source ) {

this.name = source.name;

this.blending = source.blending;
		this.side = source.side;
		this.vertexColors = source.vertexColors;

this.opacity = source.opacity;
		this.transparent = source.transparent;

this.blendSrc = source.blendSrc;
		this.blendDst = source.blendDst;
		this.blendEquation = source.blendEquation;
		this.blendSrcAlpha = source.blendSrcAlpha;
		this.blendDstAlpha = source.blendDstAlpha;
		this.blendEquationAlpha = source.blendEquationAlpha;

this.depthFunc = source.depthFunc;
		this.depthTest = source.depthTest;
		this.depthWrite = source.depthWrite;

this.stencilWriteMask = source.stencilWriteMask;
		this.stencilFunc = source.stencilFunc;
		this.stencilRef = source.stencilRef;
		this.stencilFuncMask = source.stencilFuncMask;
		this.stencilFail = source.stencilFail;
		this.stencilZFail = source.stencilZFail;
		this.stencilZPass = source.stencilZPass;
		this.stencilWrite = source.stencilWrite;

const srcPlanes = source.clippingPlanes;
		let dstPlanes = null;

if ( srcPlanes !== null ) {

const n = srcPlanes.length;
			dstPlanes = new Array( n );

for ( let i = 0; i !== n; ++ i ) {

dstPlanes[ i ] = srcPlanes[ i ].clone();

}

this.clippingPlanes = dstPlanes;
		this.clipIntersection = source.clipIntersection;
		this.clipShadows = source.clipShadows;

this.shadowSide = source.shadowSide;

this.colorWrite = source.colorWrite;

this.precision = source.precision;

this.polygonOffset = source.polygonOffset;
		this.polygonOffsetFactor = source.polygonOffsetFactor;
		this.polygonOffsetUnits = source.polygonOffsetUnits;

this.dithering = source.dithering;

this.alphaTest = source.alphaTest;
		this.alphaHash = source.alphaHash;
		this.alphaToCoverage = source.alphaToCoverage;
		this.premultipliedAlpha = source.premultipliedAlpha;
		this.forceSinglePass = source.forceSinglePass;

this.visible = source.visible;

this.toneMapped = source.toneMapped;

this.userData = JSON.parse( JSON.stringify( source.userData ) );

return this;

}

dispose() {

this.dispatchEvent( { type: 'dispose' } );

}

set needsUpdate( value ) {

if ( value === true ) this.version ++;

}

export { Material };

${this.title}

Code Editor : Material.js